int main(void) {
// Prepare MIDI Interface Client/Port for writing MIDI data:
MIDIClientRef midiclient;
MIDIPortRef midiin;
OSStatus status;
if (status = MIDIClientCreate(CFSTR("TeStInG"), NULL, NULL, &midiclient)) {
printf("Error trying to create MIDI Client structure: %d\n", status);
printf("%s\n", GetMacOSStatusErrorString(status));
exit(status);
}
if (status = MIDIInputPortCreate(midiclient, CFSTR("InPuT"), myReadProc,
NULL, &midiin)) {
printf("Error trying to create MIDI output port: %d\n", status);
printf("%s\n", GetMacOSStatusErrorString(status));
exit(status);
}
ItemCount nSrcs = MIDIGetNumberOfSources();
ItemCount iSrc;
for (iSrc=0; iSrc<nSrcs; iSrc++) {
MIDIEndpointRef src = MIDIGetSource(iSrc);
MIDIPortConnectSource(midiin, src, NULL);
}
t = lo_address_new(NULL, "7777");
CFRunLoopRef runLoop;
runLoop = CFRunLoopGetCurrent();
CFRunLoopRun();
return 0;
}
void setupMIDI(MyMIDIPlayer *player) {
MIDIClientRef client;
CheckError (MIDIClientCreate(CFSTR("Core MIDI to System Sounds Demo"), MyMIDINotifyProc, player, &client),
"Couldn't create MIDI client");
MIDIPortRef inPort;
CheckError (MIDIInputPortCreate(client, CFSTR("Input port"), MyMIDIReadProc, player, &inPort),
"Couldn't create MIDI input port");
unsigned long sourceCount = MIDIGetNumberOfSources();
printf ("%ld sources\n", sourceCount);
for (int i = 0; i < sourceCount; ++i) {
MIDIEndpointRef src = MIDIGetSource(i);
CFStringRef endpointName = NULL;
CheckError(MIDIObjectGetStringProperty(src, kMIDIPropertyName, &endpointName),
"Couldn't get endpoint name");
char endpointNameC[255];
CFStringGetCString(endpointName, endpointNameC, 255, kCFStringEncodingUTF8);
printf(" source %d: %s\n", i, endpointNameC);
CheckError (MIDIPortConnectSource(inPort, src, NULL),
"Couldn't connect MIDI port");
}
}
void reloadDeviceList(bool advanced)
{
int num = MIDIGetNumberOfSources();
m_clientFilter = !advanced;
m_inputDevices.clear();
for (int i = 0; i < num; ++i) {
bool excluded = false;
MIDIEndpointRef dest = MIDIGetSource( i );
if (dest != 0) {
QString name = getEndpointName(dest);
if ( m_clientFilter &&
name.contains(QLatin1String("IAC"), Qt::CaseSensitive) )
continue;
if ( name.contains(m_publicName))
continue;
foreach( const QString& n, m_excludedNames) {
if (name.contains(n)) {
excluded = true;
break;
}
}
if (!excluded)
m_inputDevices << name;
}
}
std::vector<QString> CoreMidiDriver::getOutputPortList()
{
INFOLOG( "retrieving output list" );
OSStatus err = noErr;
std::vector<QString> cmPortList;
cmSources = MIDIGetNumberOfSources();
INFOLOG ( "Getting number of MIDI sources . . .\n" );
unsigned i;
for ( i = 0; i < cmSources; i++ ) {
CFStringRef H2MidiNames;
cmH2Src = MIDIGetSource( i );
if ( cmH2Src == NULL ) {
ERRORLOG( "Could not open input device" );
}
if ( cmH2Src ) {
err = MIDIObjectGetStringProperty( cmH2Src, kMIDIPropertyName, &H2MidiNames );
INFOLOG ( "Getting MIDI object string property . . .\n" );
char cmName[ 64 ];
CFStringGetCString( H2MidiNames, cmName, 64, kCFStringEncodingASCII );
INFOLOG ( "Getting MIDI object name . . .\n" );
QString h2MidiPortName = cmName;
cmPortList.push_back( h2MidiPortName );
}
CFRelease( H2MidiNames );
}
return cmPortList;
}
static void _macosx_poll(struct midi_provider *p)
{
struct macosx_midi *data;
MIDIEndpointRef ep;
int i;
int num_out, num_in;
num_out = MIDIGetNumberOfDestinations();
num_in = MIDIGetNumberOfSources();
for (i = max_outputs; i < num_out; i++) {
ep = MIDIGetDestination(i);
if (!ep) continue;
data = mem_alloc(sizeof(struct macosx_midi));
memcpy(&data->ep, &ep, sizeof(ep));
data->name = get_ep_name(ep);
midi_port_register(p, MIDI_OUTPUT, data->name, data, 1);
}
max_outputs = i;
for (i = max_inputs; i < num_in; i++) {
ep = MIDIGetSource(i);
if (!ep) continue;
data = mem_alloc(sizeof(struct macosx_midi));
memcpy(&data->ep, &ep, sizeof(ep));
data->name = get_ep_name(ep);
midi_port_register(p, MIDI_INPUT, data->name, data, 1);
}
max_inputs = i;
}
Error MIDIDriverCoreMidi::open() {
CFStringRef name = CFStringCreateWithCString(NULL, "Godot", kCFStringEncodingASCII);
OSStatus result = MIDIClientCreate(name, NULL, NULL, &client);
CFRelease(name);
if (result != noErr) {
ERR_PRINTS("MIDIClientCreate failed, code: " + itos(result));
return ERR_CANT_OPEN;
}
result = MIDIInputPortCreate(client, CFSTR("Godot Input"), MIDIDriverCoreMidi::read, (void *)this, &port_in);
if (result != noErr) {
ERR_PRINTS("MIDIInputPortCreate failed, code: " + itos(result));
return ERR_CANT_OPEN;
}
int sources = MIDIGetNumberOfSources();
for (int i = 0; i < sources; i++) {
MIDIEndpointRef source = MIDIGetSource(i);
if (source) {
MIDIPortConnectSource(port_in, source, (void *)this);
connected_sources.insert(i, source);
}
}
return OK;
}
static StringArray findDevices (const bool forInput)
{
// It seems that OSX can be a bit picky about the thread that's first used to
// search for devices. It's safest to use the message thread for calling this.
jassert (MessageManager::getInstance()->isThisTheMessageThread());
const ItemCount num = forInput ? MIDIGetNumberOfSources()
: MIDIGetNumberOfDestinations();
StringArray s;
for (ItemCount i = 0; i < num; ++i)
{
MIDIEndpointRef dest = forInput ? MIDIGetSource (i)
: MIDIGetDestination (i);
String name;
if (dest != 0)
name = getConnectedEndpointName (dest);
if (name.isEmpty())
name = "<error>";
s.add (name);
}
return s;
}
static int findLaunchpadPro()
{
// find the input hardware port
for (ItemCount i=0; i < MIDIGetNumberOfSources(); ++i)
{
MIDIEndpointRef endpoint = MIDIGetSource(i);
if (endpoint)
{
// get the endpoint name (always available)
CFStringRef endpointName = NULL;
if (noErr != MIDIObjectGetStringProperty(endpoint, kMIDIPropertyName, &endpointName))
{
return -1;
}
if (CFStringCompare(endpointName, CFSTR("Standalone Port"), kCFCompareCaseInsensitive) == 0)
{
// found it! open the endpoint.
if (noErr != MIDIInputPortCreate(g_client, CFSTR("In"), readProc, NULL, &g_inDevPort))
{
return -1;
}
if (noErr != MIDIPortConnectSource(g_inDevPort, endpoint, NULL))
{
return -1;
}
}
}
}
// now find the output
for (ItemCount i=0; i < MIDIGetNumberOfDestinations(); ++i)
{
MIDIEndpointRef endpoint = MIDIGetDestination(i);
if (endpoint)
{
// get the endpoint name (always available)
CFStringRef endpointName = NULL;
if (noErr != MIDIObjectGetStringProperty(endpoint, kMIDIPropertyName, &endpointName))
{
return -1;
}
if (CFStringCompare(endpointName, CFSTR("Standalone Port"), kCFCompareCaseInsensitive) == 0)
{
// found it! open the endpoint.
if (noErr != MIDIOutputPortCreate(g_client, CFSTR("Out"), &g_outDevPort))
{
return -1;
}
g_outDevEndpoint = endpoint;
}
}
}
return !(g_inDevPort && g_outDevPort);
}
void PlatformMIDIDevices::refresh()
{
for (int i = 0; i < MIDIGetNumberOfSources(); ++i)
{
m_devicesIn.push_back(new MIDIDeviceIn(MIDIGetSource(i)));
}
for (int i = 0; i < MIDIGetNumberOfDestinations(); ++i)
{
//m_devicesOut.push_back(new MIDIDeviceOut(MIDIGetDestination(i)));
}
}
bool Midi_CoreMidi::start() {
OSStatus err;
MIDIPortRef mport;
err = MIDIClientCreate(CFSTR("murth"), 0, NULL, &mcli);
CHECK_ERR("MIDIClientCreate");
err = MIDIInputPortCreate(mcli, CFSTR("input"), midiread_cb, this, &mport);
CHECK_ERR("MIDIInputPortCreate");
unsigned long midi_sources = MIDIGetNumberOfSources();
for (int i = 0; i < midi_sources; ++i)
MIDIPortConnectSource(mport, MIDIGetSource(i), 0);
return true;
}
// Note direction is either MIDI_IN or MIDI_OUT.
INT32 MIDI_Utils_GetNumDevices(int direction) {
int num_endpoints;
if (direction == MIDI_IN) {
num_endpoints = MIDIGetNumberOfSources();
//fprintf(stdout, "MIDIGetNumberOfSources() returns %d\n", num_endpoints);
} else if (direction == MIDI_OUT) {
num_endpoints = MIDIGetNumberOfDestinations();
//printf(stdout, "MIDIGetNumberOfDestinations() returns %d\n", num_endpoints);
} else {
assert((direction == MIDI_IN || direction == MIDI_OUT));
num_endpoints = 0;
}
return (INT32) num_endpoints;
}
// ----------------------------------------------------------
vector<string> ofxAudioUnitMidi::getSourceNames()
// ----------------------------------------------------------
{
vector<string> sourceNames;
ItemCount sourceCount = MIDIGetNumberOfSources();
for(int i = 0; i < sourceCount; i++)
{
MIDIEndpointRef source = MIDIGetSource(i);
CFStringRef sourceName = NULL;
MIDIObjectGetStringProperty(source, kMIDIPropertyName, &sourceName);
char sourceNameCString[255];
CFStringGetCString(sourceName, sourceNameCString, 255, kCFStringEncodingUTF8);
sourceNames.push_back(sourceNameCString);
}
return sourceNames;
}
MIDIEndpointRef MIDIClient::getSource(CFStringRef name) {
MIDIEndpointRef ret(0);
for(int i=0;i<MIDIGetNumberOfSources();++i) {
MIDIEndpointRef src = MIDIGetSource(i);
CFStringRef n = getName(src);
if(CFStringFind(name, name, kCFCompareCaseInsensitive).length == CFStringGetLength(name)) {
CFRelease(n);
return src;
}
CFRelease(n);
}
return ret;
}
void Input::initialize()
{
MIDIEndpointRef source = NULL;
ItemCount sourceCount = MIDIGetNumberOfSources();
for (ItemCount i = 0; i < sourceCount; i++) {
MIDIEndpointRef src = MIDIGetSource(i);
source = src;
break;
}
if (source) {
MIDIClientRef client;
MIDIClientCreate(CFSTR("Greg"), Input::notifyProc, NULL, &client);
MIDIPortRef inputPort;
MIDIInputPortCreate(client, CFSTR("Greg Input"), Input::readProc, NULL, &inputPort);
MIDIPortConnectSource(inputPort, source, NULL);
}
}
void CoreMidiDriver::open()
{
INFOLOG( "open" );
OSStatus err = noErr;
QString sMidiPortName = Preferences::get_instance()->m_sMidiPortName;
cmSources = MIDIGetNumberOfSources();
unsigned i;
for ( i = 0; i < cmSources; i++ ) {
CFStringRef H2MidiNames;
cmH2Src = MIDIGetSource( i );
if ( cmH2Src ) {
err = MIDIObjectGetStringProperty( cmH2Src, kMIDIPropertyName, &H2MidiNames );
char cmName[64];
err = CFStringGetCString( H2MidiNames, cmName, 64, kCFStringEncodingASCII );
QString h2MidiPortName = cmName;
if ( h2MidiPortName == sMidiPortName ) {
MIDIPortConnectSource ( h2InputRef, cmH2Src, NULL );
m_bRunning = true;
}
}
CFRelease ( H2MidiNames );
}
int n = MIDIGetNumberOfDestinations();
if (n > 0) {
cmH2Dst = MIDIGetDestination(0);
}
if (cmH2Dst != NULL) {
CFStringRef H2MidiNames;
MIDIObjectGetStringProperty(cmH2Dst, kMIDIPropertyName, &H2MidiNames);
//CFStringGetCString(pname, name, sizeof(name), 0);
//MIDIPortConnectSource ( h2OutputRef, cmH2Dst, NULL );
MIDIPortConnectSource ( h2OutputRef, cmH2Dst, NULL );
if( H2MidiNames != NULL){
CFRelease( H2MidiNames );
}
}
}
void CAMIDIEndpoints::UpdateFromCurrentState()
{
Clear();
UInt32 i, n;
MIDIEndpointRef epRef;
n = MIDIGetNumberOfSources();
mSources.reserve(n);
for (i = 0; i < n; ++i) {
epRef = MIDIGetSource(i);
if (epRef)
AddEndpoints(epRef, mSources);
}
n = MIDIGetNumberOfDestinations();
mDestinations.reserve(n);
for (i = 0; i < n; ++i) {
epRef = MIDIGetDestination(i);
if (epRef)
AddEndpoints(epRef, mDestinations);
}
// pairing
for (EndpointList::iterator dit = mDestinations.begin(); dit != mDestinations.end(); ++dit) {
Endpoint *ep = *dit;
MIDIEntityRef destEntity = ep->Entity();
if (destEntity != NULL) {
for (EndpointList::iterator eit = mSources.begin(); eit != mSources.end(); ++eit) {
Endpoint *ep2 = *eit;
MIDIEntityRef srcEntity = ep2->Entity();
if (srcEntity == destEntity && ep2->DriverOwned() == ep->DriverOwned()) {
ep2->SetPairMate(ep);
ep->SetPairMate(ep2);
}
}
}
}
}
// Return an array of all available sources, filled with the names of the sources
static VALUE t_get_sources(VALUE self)
{
int number_of_sources = MIDIGetNumberOfSources();
VALUE source_ary = rb_ary_new2(number_of_sources);
int idx;
for(idx = 0; idx < number_of_sources; ++idx)
{
MIDIEndpointRef src = MIDIGetSource(idx);
CFStringRef pname;
char name[64];
MIDIObjectGetStringProperty(src, kMIDIPropertyName, &pname);
CFStringGetCString(pname, name, sizeof(name), 0);
CFRelease(pname);
rb_ary_push(source_ary, rb_str_new2(name));
}
return source_ary;
}
static StringArray findDevices (const bool forInput)
{
const ItemCount num = forInput ? MIDIGetNumberOfSources()
: MIDIGetNumberOfDestinations();
StringArray s;
for (ItemCount i = 0; i < num; ++i)
{
MIDIEndpointRef dest = forInput ? MIDIGetSource (i)
: MIDIGetDestination (i);
String name;
if (dest != 0)
name = getConnectedEndpointName (dest);
if (name.isEmpty())
name = "<error>";
s.add (name);
}
return s;
}
LONG CoreAudio_MIDIInit(void)
{
int i;
CHAR szPname[MAXPNAMELEN] = {0};
int numDest = MIDIGetNumberOfDestinations();
CFStringRef name = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("wineMIDIClient.%d"), getpid());
wineMIDIClient = CoreMIDI_CreateClient( name );
if (wineMIDIClient == NULL)
{
CFRelease(name);
ERR("can't create wineMIDIClient\n");
return DRV_FAILURE;
}
CFRelease(name);
MIDIOut_NumDevs = MAX_MIDI_SYNTHS;
MIDIOut_NumDevs += numDest;
MIDIIn_NumDevs = MIDIGetNumberOfSources();
TRACE("MIDIOut_NumDevs %d MIDIIn_NumDevs %d\n", MIDIOut_NumDevs, MIDIIn_NumDevs);
destinations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MIDIOut_NumDevs * sizeof(MIDIDestination));
sources = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MIDIIn_NumDevs * sizeof(MIDISource));
if (MIDIIn_NumDevs > 0)
{
InitializeCriticalSection(&midiInLock);
MIDIInThreadPortName = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("MIDIInThreadPortName.%u"), getpid());
CreateThread(NULL, 0, MIDIIn_MessageThread, NULL, 0, NULL);
name = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("WineInputPort.%u"), getpid());
MIDIInputPortCreate(wineMIDIClient, name, MIDIIn_ReadProc, NULL, &MIDIInPort);
CFRelease(name);
}
if (numDest > 0)
{
name = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("WineOutputPort.%u"), getpid());
MIDIOutputPortCreate(wineMIDIClient, name, &MIDIOutPort);
CFRelease(name);
}
/* initialize sources */
for (i = 0; i < MIDIIn_NumDevs; i++)
{
sources[i].wDevID = i;
sources[i].source = MIDIGetSource(i);
CoreMIDI_GetObjectName(sources[i].source, szPname, sizeof(szPname));
MultiByteToWideChar(CP_ACP, 0, szPname, -1, sources[i].caps.szPname, sizeof(sources[i].caps.szPname)/sizeof(WCHAR));
MIDIPortConnectSource(MIDIInPort, sources[i].source, &sources[i].wDevID);
sources[i].state = 0;
/* FIXME */
sources[i].caps.wMid = 0x00FF; /* Manufac ID */
sources[i].caps.wPid = 0x0001; /* Product ID */
sources[i].caps.vDriverVersion = 0x0001;
sources[i].caps.dwSupport = 0;
}
/* initialise MIDI synths */
for (i = 0; i < MAX_MIDI_SYNTHS; i++)
{
snprintf(szPname, sizeof(szPname), "CoreAudio MIDI Synth %d", i);
MultiByteToWideChar(CP_ACP, 0, szPname, -1, destinations[i].caps.szPname, sizeof(destinations[i].caps.szPname)/sizeof(WCHAR));
destinations[i].caps.wTechnology = MOD_SYNTH;
destinations[i].caps.wChannelMask = 0xFFFF;
destinations[i].caps.wMid = 0x00FF; /* Manufac ID */
destinations[i].caps.wPid = 0x0001; /* Product ID */
destinations[i].caps.vDriverVersion = 0x0001;
destinations[i].caps.dwSupport = MIDICAPS_VOLUME;
destinations[i].caps.wVoices = 16;
destinations[i].caps.wNotes = 16;
}
/* initialise available destinations */
for (i = MAX_MIDI_SYNTHS; i < numDest + MAX_MIDI_SYNTHS; i++)
{
destinations[i].dest = MIDIGetDestination(i - MAX_MIDI_SYNTHS);
CoreMIDI_GetObjectName(destinations[i].dest, szPname, sizeof(szPname));
MultiByteToWideChar(CP_ACP, 0, szPname, -1, destinations[i].caps.szPname, sizeof(destinations[i].caps.szPname)/sizeof(WCHAR));
destinations[i].caps.wTechnology = MOD_MIDIPORT;
destinations[i].caps.wChannelMask = 0xFFFF;
destinations[i].caps.wMid = 0x00FF; /* Manufac ID */
destinations[i].caps.wPid = 0x0001;
destinations[i].caps.vDriverVersion = 0x0001;
destinations[i].caps.dwSupport = 0;
destinations[i].caps.wVoices = 0;
destinations[i].caps.wNotes = 0;
}
return DRV_SUCCESS;
}
static VALUE t_get_num_sources(VALUE self)
{
return INT2FIX(MIDIGetNumberOfSources());
}
JNIEXPORT jint JNICALL Java_com_apple_audio_midi_MIDISetup_MIDIGetNumberOfSources
(JNIEnv *, jclass)
{
return (jint)MIDIGetNumberOfSources();
}
unsigned long MidiDeviceUtil::GetInDeviceCount()
{
return MIDIGetNumberOfSources();
}
int prListMIDIEndpoints(struct VMGlobals *g, int numArgsPushed)
{
OSStatus error;
PyrSlot *a = g->sp;
int numSrc = (int)MIDIGetNumberOfSources();
int numDst = (int)MIDIGetNumberOfDestinations();
PyrObject* idarray = newPyrArray(g->gc, 6 * sizeof(PyrObject), 0 , true);
SetObject(a, idarray);
PyrObject* idarraySo = newPyrArray(g->gc, numSrc * sizeof(SInt32), 0 , true);
SetObject(idarray->slots+idarray->size++, idarraySo);
g->gc->GCWrite(idarray, idarraySo);
PyrObject* devarraySo = newPyrArray(g->gc, numSrc * sizeof(PyrObject), 0 , true);
SetObject(idarray->slots+idarray->size++, devarraySo);
g->gc->GCWrite(idarray, devarraySo);
PyrObject* namearraySo = newPyrArray(g->gc, numSrc * sizeof(PyrObject), 0 , true);
SetObject(idarray->slots+idarray->size++, namearraySo);
g->gc->GCWrite(idarray, namearraySo);
PyrObject* idarrayDe = newPyrArray(g->gc, numDst * sizeof(SInt32), 0 , true);
SetObject(idarray->slots+idarray->size++, idarrayDe);
g->gc->GCWrite(idarray, idarrayDe);
PyrObject* namearrayDe = newPyrArray(g->gc, numDst * sizeof(PyrObject), 0 , true);
SetObject(idarray->slots+idarray->size++, namearrayDe);
g->gc->GCWrite(idarray, namearrayDe);
PyrObject* devarrayDe = newPyrArray(g->gc, numDst * sizeof(PyrObject), 0 , true);
SetObject(idarray->slots+idarray->size++, devarrayDe);
g->gc->GCWrite(idarray, devarrayDe);
for (int i=0; i<numSrc; ++i) {
MIDIEndpointRef src = MIDIGetSource(i);
SInt32 id;
MIDIObjectGetIntegerProperty(src, kMIDIPropertyUniqueID, &id);
MIDIEntityRef ent;
error = MIDIEndpointGetEntity(src, &ent);
CFStringRef devname, endname;
char cendname[1024], cdevname[1024];
// Virtual sources don't have entities
if(error)
{
MIDIObjectGetStringProperty(src, kMIDIPropertyName, &devname);
MIDIObjectGetStringProperty(src, kMIDIPropertyName, &endname);
CFStringGetCString(devname, cdevname, 1024, kCFStringEncodingUTF8);
CFStringGetCString(endname, cendname, 1024, kCFStringEncodingUTF8);
}
else
{
MIDIDeviceRef dev;
MIDIEntityGetDevice(ent, &dev);
MIDIObjectGetStringProperty(dev, kMIDIPropertyName, &devname);
MIDIObjectGetStringProperty(src, kMIDIPropertyName, &endname);
CFStringGetCString(devname, cdevname, 1024, kCFStringEncodingUTF8);
CFStringGetCString(endname, cendname, 1024, kCFStringEncodingUTF8);
}
PyrString *string = newPyrString(g->gc, cendname, 0, true);
SetObject(namearraySo->slots+i, string);
namearraySo->size++;
g->gc->GCWrite(namearraySo, (PyrObject*)string);
PyrString *devstring = newPyrString(g->gc, cdevname, 0, true);
SetObject(devarraySo->slots+i, devstring);
devarraySo->size++;
g->gc->GCWrite(devarraySo, (PyrObject*)devstring);
SetInt(idarraySo->slots+i, id);
idarraySo->size++;
CFRelease(devname);
CFRelease(endname);
}
// post("numDst %d\n", numDst);
for (int i=0; i<numDst; ++i) {
MIDIEndpointRef dst = MIDIGetDestination(i);
SInt32 id;
MIDIObjectGetIntegerProperty(dst, kMIDIPropertyUniqueID, &id);
MIDIEntityRef ent;
error = MIDIEndpointGetEntity(dst, &ent);
CFStringRef devname, endname;
char cendname[1024], cdevname[1024];
// Virtual destinations don't have entities either
if(error)
{
MIDIObjectGetStringProperty(dst, kMIDIPropertyName, &devname);
MIDIObjectGetStringProperty(dst, kMIDIPropertyName, &endname);
CFStringGetCString(devname, cdevname, 1024, kCFStringEncodingUTF8);
CFStringGetCString(endname, cendname, 1024, kCFStringEncodingUTF8);
}
else
{
MIDIDeviceRef dev;
MIDIEntityGetDevice(ent, &dev);
MIDIObjectGetStringProperty(dev, kMIDIPropertyName, &devname);
MIDIObjectGetStringProperty(dst, kMIDIPropertyName, &endname);
CFStringGetCString(devname, cdevname, 1024, kCFStringEncodingUTF8);
CFStringGetCString(endname, cendname, 1024, kCFStringEncodingUTF8);
}
PyrString *string = newPyrString(g->gc, cendname, 0, true);
SetObject(namearrayDe->slots+namearrayDe->size++, string);
g->gc->GCWrite(namearrayDe, (PyrObject*)string);
PyrString *devstring = newPyrString(g->gc, cdevname, 0, true);
SetObject(devarrayDe->slots+devarrayDe->size++, devstring);
g->gc->GCWrite(devarrayDe, (PyrObject*)devstring);
SetInt(idarrayDe->slots+idarrayDe->size++, id);
CFRelease(devname);
CFRelease(endname);
}
return errNone;
}
//_________________________________________________________
void AddSlots (short refNum)
{
int i, n;
MIDIEndpointRef src,dest;
CFStringRef pname;
char slotname[SlotLength], name[StringLen], model[StringLen]; // 'name' + 'model' length must be < slotname 'length'
OSStatus err;
SlotPtr slot;
n = MIDIGetNumberOfSources();
for (i=0; i<n; i++) {
src = MIDIGetSource(i);
err = MIDIObjectGetStringProperty(src, kMIDIPropertyName, &pname);
if (err == noErr) {
CFStringGetCString(pname, name, sizeof(name), 0);
CFRelease(pname);
// If found, add the model name before the device name, copy no more than SlotLength
if (GetModel(src,model,StringLen)) {
snprintf(slotname, SlotLength-1, "%s:%s", name,model); // 'name' and 'model' are concatenated to build 'slotname'
}else {
strncpy(slotname,name,SlotLength-1);
}
slot = CreateSlot (refNum, slotname, MidiInputSlot, src);
if (slot) {
slot->next = gInSlots;
gInSlots = slot;
// No connection with the source : done by the application alarm
}
}
}
n = MIDIGetNumberOfDestinations();
for (i=0; i<n; i++) {
dest = MIDIGetDestination(i);
err = MIDIObjectGetStringProperty(dest, kMIDIPropertyName, &pname);
if (err == noErr) {
CFStringGetCString(pname, name, sizeof(name), 0);
CFRelease(pname);
// If found, add the model name before the device name, copy no more than SlotLength
if (GetModel(dest,model,StringLen)) {
snprintf(slotname, SlotLength-1, "%s:%s",name, model); // 'name' and 'model' are concatenated to build 'slotname'
}else {
strncpy(slotname,name,SlotLength-1);
}
slot = CreateSlot (refNum, slotname, MidiOutputSlot, 0);
if (slot) {
slot->port = gOutPort;
slot->dest = dest;
slot->next = gOutSlots;
gOutSlots = slot;
}
}
}
}
int MidiIn::getNoDevices()
{
return MIDIGetNumberOfSources();
}
static unsigned int numberOfSources() { return MIDIGetNumberOfSources(); }
// Counts the number of endpoints.
extern "C" int MidiJackCountEndpoints()
{
ResetPluginIfRequired();
return static_cast<int>(MIDIGetNumberOfSources());
}
int main(int argc, char *argv[])
{
if (argc >= 2) {
// first argument, if present, is the MIDI channel number to echo to (1-16)
sscanf(argv[1], "%d", &gChannel);
if (gChannel < 1) gChannel = 1;
else if (gChannel > 16) gChannel = 16;
--gChannel; // convert to 0-15
}
// create client and ports
MIDIClientRef client = NULL;
MIDIClientCreate(CFSTR("MIDI Echo"), NULL, NULL, &client);
MIDIPortRef inPort = NULL;
MIDIInputPortCreate(client, CFSTR("Input port"), MyReadProc, NULL, &inPort);
MIDIOutputPortCreate(client, CFSTR("Output port"), &gOutPort);
// enumerate devices (not really related to purpose of the echo program
// but shows how to get information about devices)
int i, n;
CFStringRef pname, pmanuf, pmodel;
char name[64], manuf[64], model[64];
n = MIDIGetNumberOfDevices();
for (i = 0; i < n; ++i) {
MIDIDeviceRef dev = MIDIGetDevice(i);
MIDIObjectGetStringProperty(dev, kMIDIPropertyName, &pname);
MIDIObjectGetStringProperty(dev, kMIDIPropertyManufacturer, &pmanuf);
MIDIObjectGetStringProperty(dev, kMIDIPropertyModel, &pmodel);
CFStringGetCString(pname, name, sizeof(name), 0);
CFStringGetCString(pmanuf, manuf, sizeof(manuf), 0);
CFStringGetCString(pmodel, model, sizeof(model), 0);
CFRelease(pname);
CFRelease(pmanuf);
CFRelease(pmodel);
printf("name=%s, manuf=%s, model=%s\n", name, manuf, model);
}
// open connections from all sources
n = MIDIGetNumberOfSources();
printf("%d sources\n", n);
for (i = 0; i < n; ++i) {
MIDIEndpointRef src = MIDIGetSource(i);
MIDIPortConnectSource(inPort, src, NULL);
}
// find the first destination
n = MIDIGetNumberOfDestinations();
if (n > 0)
gDest = MIDIGetDestination(0);
if (gDest != NULL) {
MIDIObjectGetStringProperty(gDest, kMIDIPropertyName, &pname);
CFStringGetCString(pname, name, sizeof(name), 0);
CFRelease(pname);
printf("Echoing to channel %d of %s\n", gChannel + 1, name);
} else {
printf("No MIDI destinations present\n");
}
CFRunLoopRun();
// run until aborted with control-C
return 0;
}
ItemCount MIDIClient::numSources() {
return MIDIGetNumberOfSources();
}
