void MidiInputDeviceMme::MidiInputPortMme::ConnectToMmeMidiSource(const char* MidiSource) { // close the old MIDI Input port if it was already opened CloseMmeMidiPort(); MIDIINCAPS midiincaps; int NumDevs = midiInGetNumDevs(); int FoundMidiInDeviceId = -1; for(int i=0;i<NumDevs;i++) { int res = midiInGetDevCaps(i, &midiincaps, sizeof(MIDIINCAPS)); if(res == MMSYSERR_NOERROR) { if(!strcmp(midiincaps.szPname, MidiSource)) { FoundMidiInDeviceId = i; break; } } } if(FoundMidiInDeviceId == -1) throw MidiInputException("MIDI port connect failed"); int res; res = midiInOpen(&MidiInHandle, FoundMidiInDeviceId, (DWORD_PTR)win32_midiin_callback, (DWORD_PTR)this, CALLBACK_FUNCTION); if(res != MMSYSERR_NOERROR) { throw MidiInputException("MIDI port connect failed. midiInOpen error"); } MidiInOpened = true; /* Store pointer to our input buffer for System Exclusive messages in MIDIHDR */ midiHdr.lpData = &TmpSysExBuf[0]; /* Store its size in the MIDIHDR */ midiHdr.dwBufferLength = MME_MAX_SYSEX_BUF_SIZE; /* Flags must be set to 0 */ midiHdr.dwFlags = 0; /* Prepare the buffer and MIDIHDR */ res = midiInPrepareHeader(MidiInHandle, &midiHdr, sizeof(MIDIHDR)); if(res != MMSYSERR_NOERROR) { CloseMmeMidiPort(); throw MidiInputException("MIDI port connect failed. midiInPrepareHeader error"); } /* Queue MIDI input buffer */ res = midiInAddBuffer(MidiInHandle, &midiHdr, sizeof(MIDIHDR)); if(res != MMSYSERR_NOERROR) { CloseMmeMidiPort(); throw MidiInputException("MIDI port connect failed. midiInAddBuffer error"); } res = midiInStart(MidiInHandle); if(res != MMSYSERR_NOERROR) { CloseMmeMidiPort(); throw MidiInputException("MIDI port connect failed, midiInStart failed."); } }
void CMidiDevice::EnumMidiDev() { int i = 0; MIDIINCAPS midiInDevCaps; MIDIOUTCAPS midiOutDevCaps; // get the number of midi device in and out m_nTotalNumOfDevIn = midiInGetNumDevs(); m_nTotalNumOfDevOut = midiOutGetNumDevs(); // init the device name and device id for(i = 0; i < MAX_MIDI_DEV; i++) { m_midiDevIn[i].nDevID = -1; m_midiDevOut[i].nDevID = -1; memset(m_midiDevIn[i].szPnameIn, 0, MAXPNAMELEN); memset(m_midiDevOut[i].szPnameOut, 0, MAXPNAMELEN); } // get the device name and device id of midi device in for(i = 0; i < m_nTotalNumOfDevIn; i++) { midiInGetDevCaps(i, &midiInDevCaps, sizeof(MIDIINCAPS)); memcpy(m_midiDevIn[i].szPnameIn, midiInDevCaps.szPname, MAXPNAMELEN); m_midiDevIn[i].nDevID = i; } // get the device name and device id of midi device out for(i = 0; i < m_nTotalNumOfDevOut; i++) { midiOutGetDevCaps(i, &midiOutDevCaps, sizeof(MIDIOUTCAPS)); memcpy(m_midiDevOut[i].szPnameOut, midiOutDevCaps.szPname, MAXPNAMELEN); m_midiDevOut[i].nDevID = i; } }
Parameter::Parameter(void) { /* Initialize values */ for (int i = 0; i < NUM_PARAMETERS; i++) { value[i] = 0.0f; changed[i] = false; } /* Open Midi device */ numDevices = midiInGetNumDevs(); if (numDevices > MAX_NUM_DEVICES) numDevices = MAX_NUM_DEVICES; for (unsigned int devID = 0; devID < numDevices; devID++) { MMRESULT rc; rc = midiInOpen(&(midiInDevice[devID]), devID, (DWORD_PTR)MidiInProc, NULL, CALLBACK_FUNCTION); /* Create input buffers */ midiInHeader[devID].lpData = (LPSTR)midiData[devID]; midiInHeader[devID].dwBufferLength = MIDI_DATA_SIZE; midiInHeader[devID].dwFlags = 0; rc = midiInPrepareHeader(midiInDevice[devID], &midiInHeader[devID], sizeof(midiInHeader[devID])); rc = midiInAddBuffer(midiInDevice[devID], &midiInHeader[devID], sizeof(midiInHeader[devID])); rc = midiInStart(midiInDevice[devID]); } }
void reloadDeviceList(bool advanced) { MMRESULT res; MIDIINCAPS deviceCaps; QString devName; unsigned int dev, max = midiInGetNumDevs(); m_inputDevices.clear(); m_clientFilter = !advanced; for ( dev = 0; dev < max; ++dev) { bool excluded = false; res = midiInGetDevCaps( dev, &deviceCaps, sizeof(MIDIINCAPS)); if (res != MMSYSERR_NOERROR) break; #if defined(UNICODE) devName = QString::fromWCharArray(deviceCaps.szPname); #else devName = QString::fromLocal8Bit(deviceCaps.szPname); #endif foreach(const QString& n, m_excludedNames) { if (devName.startsWith(n)) { excluded = true; break; } } if (!excluded) m_inputDevices[dev] = devName; } }
void MidiWinMM::openDevices() { m_inputDevices.clear(); for( unsigned int i = 0; i < midiInGetNumDevs(); ++i ) { MIDIINCAPS c; midiInGetDevCaps( i, &c, sizeof( c ) ); HMIDIIN hm = 0; MMRESULT res = midiInOpen( &hm, i, (DWORD_PTR) &inputCallback, (DWORD_PTR) this, CALLBACK_FUNCTION ); if( res == MMSYSERR_NOERROR ) { m_inputDevices[hm] = qstrdup( c.szPname ); midiInStart( hm ); } } m_outputDevices.clear(); for( unsigned int i = 0; i < midiOutGetNumDevs(); ++i ) { MIDIOUTCAPS c; midiOutGetDevCaps( i, &c, sizeof( c ) ); HMIDIOUT hm = 0; MMRESULT res = midiOutOpen( &hm, i, 0, 0, CALLBACK_NULL ); if( res == MMSYSERR_NOERROR ) { m_outputDevices[hm] = qstrdup( c.szPname ); } } }
/* * new_fluid_winmidi_driver */ fluid_midi_driver_t* new_fluid_winmidi_driver(fluid_settings_t* settings, handle_midi_event_func_t handler, void* data) { fluid_winmidi_driver_t* dev; MMRESULT res; UINT i, err, num; MIDIINCAPS in_caps; int midi_num = 0; /* not much use doing anything */ if (handler == NULL) { FLUID_LOG(FLUID_ERR, "Invalid argument"); return NULL; } dev = FLUID_MALLOC(sizeof(fluid_winmidi_driver_t)); if (dev == NULL) { return NULL; } dev->hmidiin = NULL; dev->driver.handler = handler; dev->driver.data = data; /* check if there any midi devices installed */ num = midiInGetNumDevs(); if (num == 0) { FLUID_LOG(FLUID_ERR, "no MIDI in devices found"); goto error_recovery; } /* find the device */ for (i = 0; i < num; i++) { res = midiInGetDevCaps(i, &in_caps, sizeof(LPMIDIINCAPS)); if (res == MMSYSERR_NOERROR) { } } /* try opening the device */ err = midiInOpen(&dev->hmidiin, midi_num, (DWORD) fluid_winmidi_callback, (DWORD) dev, CALLBACK_FUNCTION); if (err != MMSYSERR_NOERROR) { FLUID_LOG(FLUID_WARN, "Couldn't open MIDI input: %s (error %d)", fluid_winmidi_input_error(err), err); goto error_recovery; } if (midiInStart(dev->hmidiin) != MMSYSERR_NOERROR) { FLUID_LOG(FLUID_ERR, "Failed to start the MIDI input. MIDI input not available."); goto error_recovery; } return (fluid_midi_driver_t*) dev; error_recovery: delete_fluid_winmidi_driver((fluid_midi_driver_t*) dev); return NULL; }
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); }
/* ============================================================================= general MIDI device queries ============================================================================= */ static void pm_winmm_general_inputs() { UINT i; WORD wRtn; midi_num_inputs = midiInGetNumDevs(); midi_in_caps = pm_alloc(sizeof(MIDIINCAPS) * midi_num_inputs); if (midi_in_caps == NULL) { // if you can't open a particular system-level midi interface // (such as winmm), we just consider that system or API to be // unavailable and move on without reporting an error. This // may be the wrong thing to do, especially in this case. return; } for (i = 0; i < midi_num_inputs; i++) { wRtn = midiInGetDevCaps(i, (LPMIDIINCAPS) &midi_in_caps[i], sizeof(MIDIINCAPS)); if (wRtn == MMSYSERR_NOERROR) { /* ignore errors here -- if pm_descriptor_max is exceeded, some devices will not be accessible. */ pm_add_device("MMSystem", midi_in_caps[i].szPname, TRUE, (void *) i, &pm_winmm_in_dictionary); } } }
// Plug-in state update function. void ResetPluginIfRequired() { // Reset only if the number of devices was changed. int deviceCount = midiInGetNumDevs(); if (deviceCount == handles.size()) return; // Close the all MIDI handles. for (auto& handle : handles) { midiInClose(handle); } handles.resize(0); // Clear the message queue. std::queue<Message> emptyQueue; std::swap(messageQueue, emptyQueue); // Enumerate the all MIDI devices. for (int i = 0; i < deviceCount; i++) { HMIDIIN handle; MMRESULT result = midiInOpen(&handle, i, reinterpret_cast<DWORD_PTR>(MyMidiInProc), NULL, CALLBACK_FUNCTION); assert(result == MMSYSERR_NOERROR); result = midiInStart(handle); assert(result == MMSYSERR_NOERROR); handles.push_back(handle); } }
void ProjectOptions::InitDevInfo() { long id = 0; HMODULE h = LoadLibrary("dsound.dll"); if (h) { tDirectSoundEnumerate pDirectSoundEnumerate = (tDirectSoundEnumerate)GetProcAddress(h, "DirectSoundEnumerateA"); if (pDirectSoundEnumerate) pDirectSoundEnumerate(EnumWaveDevice, &id); } UINT ndev = midiInGetNumDevs(); for (UINT n = 0; n < ndev; n++) { MIDIINCAPS caps; memset(&caps, 0, sizeof(caps)); midiInGetDevCaps(n, &caps, sizeof(caps)); SoundDevInfo *inf = midiList.AddItem(); inf->name = caps.szPname; inf->info = NULL; inf->id = (long)n; inf->sub = 0; inf->type = 1; } }
std::vector<std::string> getInputPorts() { std::vector< std:: string > res; MIDIINCAPS caps; int n_devices = midiInGetNumDevs(); for(int i=0; i < n_devices; ++i) { midiInGetDevCaps(i, &caps, sizeof(MIDIINCAPS)); WCHAR *wname = caps.szPname; char name[256]; int j; for(j=0; j<255 && wname[j]!=0; ++j) { name[j] = (char)wname[j]; } name[j] = 0; res.push_back(std::string(name)); } return res; }
void rtsyn_get_port_list(){ int i; MIDIINCAPS InCaps; InNum = midiInGetNumDevs(); for (i=1;i <=InNum && i<=32;i++){ midiInGetDevCaps(i-1,(LPMIDIINCAPSA) &InCaps,sizeof(InCaps)); sprintf(rtsyn_portlist[i-1],"%d:%s",i,(LPSTR)InCaps.szPname); } rtsyn_nportlist=i-1; }
BOOL Midi_LookupPortIndexes(MIDI *midi) { BOOL setupValid = TRUE; int midiInDevCnt = midiInGetNumDevs(); int midiOutDevCnt = midiOutGetNumDevs(); int i; if (StrEq(midi->inPortName, _T("Disabled"))) { midi->inPort = -1; goto InPortFound; } for (i = 0; i < midiInDevCnt; i++) { MIDIINCAPS midiDevInfo; midiInGetDevCaps(i, &midiDevInfo, sizeof midiDevInfo); if (StrEq(midi->inPortName, midiDevInfo.szPname)) { midi->inPort = i; goto InPortFound; } } setupValid = FALSE; InPortFound: if (StrEq(midi->outPortName, _T("Disabled"))) { midi->outPort = -1; goto OutPortFound; } for (i = 0; i < midiOutDevCnt; i++) { MIDIOUTCAPS midiDevInfo; midiOutGetDevCaps(i, &midiDevInfo, sizeof midiDevInfo); if (StrEq(midi->outPortName, midiDevInfo.szPname)) { midi->outPort = i; goto OutPortFound; } } setupValid = FALSE; OutPortFound: if (StrEq(midi->masterInPortName, _T("Disabled"))) { midi->masterInPort = -1; goto MasterInPortFound; } for (i = 0; i < midiInDevCnt; i++) { MIDIINCAPS midiDevInfo; midiInGetDevCaps(i, &midiDevInfo, sizeof midiDevInfo); if (StrEq(midi->masterInPortName, midiDevInfo.szPname)) { midi->masterInPort = i; goto MasterInPortFound; } } MasterInPortFound: return setupValid; }
void Win32MidiDriver::enumPorts(QList<QString> &midiInPortNames) { UINT inPortNum = midiInGetNumDevs(); for (UINT i = 0; i < inPortNum; i++) { MIDIINCAPS mic; if (midiInGetDevCaps(i, &mic, sizeof(MIDIINCAPS)) != MMSYSERR_NOERROR) { midiInPortNames.append(""); } else { midiInPortNames.append("MidiIn" + QString().setNum(i) + ": " + QString().fromLocal8Bit(mic.szPname)); } } }
//---------------------------------------------------------------------------// // EnumDevices // //---------------------------------------------------------------------------// void CMidiDevice::EnumDevices(vector<string> &vDevices) { vDevices.clear(); int iNumDevices = midiInGetNumDevs(); MIDIINCAPS miCaps; for (int i = 0; i < iNumDevices; i++) { midiInGetDevCaps(i, &miCaps, sizeof(miCaps)); vDevices.push_back(miCaps.szPname); } }
void MidiUartWinClass::listInputMidiDevices() { MIDIINCAPS mic; unsigned long iNumDevs, i; iNumDevs = midiInGetNumDevs(); for (i = 0; i < iNumDevs; i++) { if (!midiInGetDevCaps(i, &mic, sizeof(MIDIINCAPS))) { printf("%lu) %s\r\n", i, mic.szPname); } } }
//============================================================================== StringArray MidiInput::getDevices() { StringArray s; const int num = midiInGetNumDevs(); for (int i = 0; i < num; ++i) { MIDIINCAPS mc = { 0 }; if (midiInGetDevCaps (i, &mc, sizeof (mc)) == MMSYSERR_NOERROR) s.add (String (mc.szPname, sizeof (mc.szPname))); } return s; }
void RtMidiIn :: initialize( const std::string& /*clientName*/ ) { // We'll issue a warning here if no devices are available but not // throw an error since the user can plugin something later. unsigned int nDevices = midiInGetNumDevs(); if ( nDevices == 0 ) { errorString_ = "RtMidiIn::initialize: no MIDI input devices currently available."; error( RtError::WARNING ); } // Save our api-specific connection information. WinMidiData *data = (WinMidiData *) new WinMidiData; apiData_ = (void *) data; inputData_.apiData = (void *) data; data->message.bytes.clear(); // needs to be empty for first input message }
std::vector<String> MidiInputDeviceMme::MidiInputPortMme::ParameterPort::PossibilitiesAsString() { // returns a list of the available MME Input MIDI ports you can connect to std::vector<String> ports; MIDIINCAPS midiincaps; int NumDevs = midiInGetNumDevs(); for(int i=0;i<NumDevs;i++) { int res = midiInGetDevCaps(i, &midiincaps, sizeof(MIDIINCAPS)); if(res == MMSYSERR_NOERROR) { ports.push_back( (String)midiincaps.szPname); } } return ports; }
void midiInitialize() { MIDIINCAPSA inCap; MIDIOUTCAPSA outCap; int num; memset(&midi, 0, sizeof(midi)); midi.enabled = 1; num = midiOutGetNumDevs(); if (num > 0 && midiOutGetDevCapsA(MIDI_MAPPER, &outCap, sizeof(outCap)) == MMSYSERR_NOERROR) { int i; midi.out.dev = (DevInfo*)calloc(1, (num + 1) * sizeof(DevInfo)); strcpy(midi.out.dev[0].name, outCap.szPname); midi.out.dev[0].id = MIDI_MAPPER; strcpy(midi.out.dev[0].idString, "midi-out"); midi.out.count++; for (i = 0; i < num; i++) { if (midiOutGetDevCapsA(i, &outCap, sizeof(outCap)) == MMSYSERR_NOERROR) { strcpy(midi.out.dev[midi.out.count].name, outCap.szPname); midi.out.dev[midi.out.count].id = i; sprintf(midi.out.dev[midi.out.count].idString, "midi-out-%u", i); midi.out.count++; } } } num = midiInGetNumDevs(); if (num > 0) { int i; midi.in.dev = (DevInfo*)calloc(1, num * sizeof(DevInfo)); for (i = 0; i < num; ++i) { if (midiInGetDevCapsA(i, &inCap, sizeof(inCap)) == MMSYSERR_NOERROR) { strcpy(midi.in.dev[midi.in.count].name, inCap.szPname); midi.in.dev[midi.in.count].id = i; sprintf(midi.in.dev[midi.in.count].idString, "midi-in-%u", i); midi.in.count++; } } } }
MidiInput* MidiInput::openDevice (const int index, MidiInputCallback* const callback) { if (callback == nullptr) return nullptr; UINT deviceId = MIDI_MAPPER; int n = 0; String name; const int num = midiInGetNumDevs(); for (int i = 0; i < num; ++i) { MIDIINCAPS mc = { 0 }; if (midiInGetDevCaps (i, &mc, sizeof (mc)) == MMSYSERR_NOERROR) { if (index == n) { deviceId = i; name = String (mc.szPname, numElementsInArray (mc.szPname)); break; } ++n; } } ScopedPointer <MidiInput> in (new MidiInput (name)); ScopedPointer <MidiInCollector> collector (new MidiInCollector (in, *callback)); HMIDIIN h; HRESULT err = midiInOpen (&h, deviceId, (DWORD_PTR) &MidiInCollector::midiInCallback, (DWORD_PTR) (MidiInCollector*) collector, CALLBACK_FUNCTION); if (err == MMSYSERR_NOERROR) { collector->deviceHandle = h; in->internal = collector.release(); return in.release(); } return nullptr; }
void midi_device_manager::enum_device_infos() { // MIDI IN デバイスの列挙 { const uint32_t num_devs_ = midiInGetNumDevs(); if(num_devs_ > 0) { midi_input_device_infos_.clear(); for( uint32_t dev_id_ = 0;dev_id_ < num_devs_;++dev_id_) { MIDIINCAPS2 caps2_; uint32_t result = midiInGetDevCaps(dev_id_,reinterpret_cast<LPMIDIINCAPS>(&caps2_),sizeof(MIDIINCAPS2)); if(result != MMSYSERR_NOERROR) { throw midi_input_error(result); } else { midi_input_device_infos_.push_back(new midi_input_device_t(caps2_,dev_id_)); } } } } // MIDI OUT デバイスの列挙 { const uint32_t num_devs_ = midiOutGetNumDevs(); if(num_devs_ > 0) { midi_output_device_infos_.clear(); for( uint32_t dev_id_ = 0;dev_id_ < num_devs_;++dev_id_) { MIDIOUTCAPS2 device_infos_2_; uint32_t result = midiOutGetDevCaps(dev_id_,reinterpret_cast<LPMIDIOUTCAPS>(&device_infos_2_),sizeof(MIDIOUTCAPS2)); if(result != MMSYSERR_NOERROR) { throw midi_output_error(result); } else { midi_output_device_infos_ .push_back(new midi_output_device_t(device_infos_2_,dev_id_)); } } } } }
void listInputMidiDevices(void) { MIDIINCAPS mic; unsigned long iNumDevs, i; /* Get the number of MIDI Out devices in this computer */ iNumDevs = midiInGetNumDevs(); debugPrintf(1, "%lu input midi devices found\r\n", iNumDevs); /* Go through all of those devices, displaying their names */ for (i = 0; i < iNumDevs; i++) { /* Get info about the next device */ if (!midiInGetDevCaps(i, &mic, sizeof(MIDIINCAPS))) { /* Display its Device ID and name */ printf("%lu) %s\r\n", i, mic.szPname); } } }
void MManagerWin32::GetDriverNames() { // get the names of all devices int numIns = midiInGetNumDevs(); int numOuts = midiOutGetNumDevs(); MIDIINCAPS inCaps; MIDIOUTCAPS outCaps; std::wstring name; for(int n = 0; n < numIns; n++) { midiInGetDevCaps(n,&inCaps,sizeof(MIDIINCAPS)); name = inCaps.szPname; inputDeviceNames.push_back(name); } for(int n = 0; n < numOuts; n++) { midiOutGetDevCaps(n,&outCaps,sizeof(MIDIOUTCAPS)); name = outCaps.szPname; outputDeviceNames.push_back(name); } }
/* print to stdout the midi input devices on your win32 system.. */ virtual void printInDevices() { MIDIINCAPS mic; unsigned long iNumDevs, i; /* Get the number of MIDI In devices in this computer */ iNumDevs = midiInGetNumDevs(); /* Go through all of those devices, displaying their names */ for (i = 0; i < iNumDevs; i++) { /* Get info about the next device */ if (!midiInGetDevCaps(i, &mic, sizeof(MIDIINCAPS))) { /* Display its Device ID and name */ printf("Device ID #%u: %s\r\n", i, mic.szPname); } } }
static BRESULT getmidiinid(const OEMCHAR *midiin, UINT *ret) { UINT num; UINT i; MIDIINCAPS moc; num = midiInGetNumDevs(); for (i=0; i<num; i++) { if ((midiInGetDevCaps(i, &moc, sizeof(moc)) == MMSYSERR_NOERROR) && (!milstr_cmp(midiin, moc.szPname))) { *ret = i; return(SUCCESS); } } if (!milstr_cmp(midiin, cmmidi_midimapper)) { *ret = MIDI_MAPPER; return(SUCCESS); } return(FAILURE); }
std::string RtMidiIn :: getPortName( unsigned int portNumber ) { unsigned int nDevices = midiInGetNumDevs(); if ( portNumber >= nDevices ) { std::ostringstream ost; ost << "RtMidiIn::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtError::INVALID_PARAMETER ); } MIDIINCAPS deviceCaps; midiInGetDevCaps( portNumber, &deviceCaps, sizeof(MIDIINCAPS)); // For some reason, we need to copy character by character with // UNICODE (thanks to Eduardo Coutinho!). //std::string stringName = std::string( deviceCaps.szPname ); char nameString[MAXPNAMELEN]; for( int i=0; i<MAXPNAMELEN; ++i ) nameString[i] = (char)( deviceCaps.szPname[i] ); std::string stringName( nameString ); return stringName; }
void msInit() { int i; CString s; MIDIINCAPS mc; msusedev=-1; mscpu=0; OutputDebugString("MIDI init...\n"); msnumdevs=midiInGetNumDevs(); s.Format("- found %d devices\n",msnumdevs); OutputDebugString(s); for (int i=0; i<msnumdevs; i++) { midiInGetDevCaps(i,&mc,sizeof(mc)); s.Format("device %d is '%s'\n",i,mc.szPname); OutputDebugString(s); strcpy_s(msdevnames[i],256,mc.szPname); } InitializeCriticalSection(&cs); mbuflen=0; for (i=0; i<msnumdevs; i++) if (!strncmp(msdevnames[i],"LB",2) || !strncmp(msdevnames[i],"MIDI Yoke",9) || !strncmp(msdevnames[i],"LoopBe Internal MIDI", 20)) { msSetDevice(i); break; } pleft=pright=0; clipl=clipr=0; QueryPerformanceFrequency(&pfreq); }
unsigned int RtMidiIn :: getPortCount() { return midiInGetNumDevs(); }
void RtMidiIn :: openPort( unsigned int portNumber, const std::string /*portName*/ ) { if ( connected_ ) { errorString_ = "RtMidiIn::openPort: a valid connection already exists!"; error( RtError::WARNING ); return; } unsigned int nDevices = midiInGetNumDevs(); if (nDevices == 0) { errorString_ = "RtMidiIn::openPort: no MIDI input sources found!"; error( RtError::NO_DEVICES_FOUND ); } std::ostringstream ost; if ( portNumber >= nDevices ) { ost << "RtMidiIn::openPort: the 'portNumber' argument (" << portNumber << ") is invalid."; errorString_ = ost.str(); error( RtError::INVALID_PARAMETER ); } WinMidiData *data = static_cast<WinMidiData *> (apiData_); MMRESULT result = midiInOpen( &data->inHandle, portNumber, (DWORD)&midiInputCallback, (DWORD)&inputData_, CALLBACK_FUNCTION ); if ( result != MMSYSERR_NOERROR ) { errorString_ = "RtMidiIn::openPort: error creating Windows MM MIDI input port."; error( RtError::DRIVER_ERROR ); } // Allocate and init the sysex buffers. for ( int i=0; i<RT_SYSEX_BUFFER_COUNT; ++i ) { data->sysexBuffer[i] = (MIDIHDR*) new char[ sizeof(MIDIHDR) ]; data->sysexBuffer[i]->lpData = new char[ RT_SYSEX_BUFFER_SIZE ]; data->sysexBuffer[i]->dwBufferLength = RT_SYSEX_BUFFER_SIZE; data->sysexBuffer[i]->dwUser = i; // We use the dwUser parameter as buffer indicator data->sysexBuffer[i]->dwFlags = 0; result = midiInPrepareHeader( data->inHandle, data->sysexBuffer[i], sizeof(MIDIHDR) ); if ( result != MMSYSERR_NOERROR ) { midiInClose( data->inHandle ); errorString_ = "RtMidiIn::openPort: error starting Windows MM MIDI input port (PrepareHeader)."; error( RtError::DRIVER_ERROR ); } // Register the buffer. result = midiInAddBuffer( data->inHandle, data->sysexBuffer[i], sizeof(MIDIHDR) ); if ( result != MMSYSERR_NOERROR ) { midiInClose( data->inHandle ); errorString_ = "RtMidiIn::openPort: error starting Windows MM MIDI input port (AddBuffer)."; error( RtError::DRIVER_ERROR ); } } result = midiInStart( data->inHandle ); if ( result != MMSYSERR_NOERROR ) { midiInClose( data->inHandle ); errorString_ = "RtMidiIn::openPort: error starting Windows MM MIDI input port."; error( RtError::DRIVER_ERROR ); } connected_ = true; }