Exemplo n.º 1
26
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.");
    }

}
Exemplo n.º 2
0
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]);
	}
}
Exemplo n.º 4
0
        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;
            }
        }
Exemplo n.º 5
0
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 );
		}
	}
}
Exemplo n.º 6
0
/*
 * 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;
}
Exemplo n.º 7
0
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);
}
Exemplo n.º 8
0
/*  
=============================================================================
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);
        }
    }
Exemplo n.º 10
0
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;
	}
}
Exemplo n.º 11
0
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;
}
Exemplo n.º 12
0
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;
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
0
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));
		}
	}
}
Exemplo n.º 15
0
//---------------------------------------------------------------------------//
// 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);
    }
}
Exemplo n.º 16
0
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);
    }
  }  
}
Exemplo n.º 17
0
//==============================================================================
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;
}
Exemplo n.º 18
0
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
}
Exemplo n.º 19
0
    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;
}
Exemplo n.º 20
0
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++;
            }
        }
    }
}
Exemplo n.º 21
0
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;
}
Exemplo n.º 22
0
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_));
        }
      }
    }

  }

}
Exemplo n.º 23
0
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);
      }
    }  
}
Exemplo n.º 24
0
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);
	}
}
Exemplo n.º 25
0
      /* 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);
             }
         }

      }
Exemplo n.º 26
0
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);
}
Exemplo n.º 27
0
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;
}
Exemplo n.º 28
0
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);

}
Exemplo n.º 29
0
unsigned int RtMidiIn :: getPortCount()
{
  return midiInGetNumDevs();
}
Exemplo n.º 30
0
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;
}