drivers/midi/MidiInputDeviceCoreMidi.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2004, 2005 Grame                                        *
 *   Copyright (C) 2005 - 2012 Christian Schoenebeck                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#include "MidiInputDeviceCoreMidi.h"
#include "MidiInputDeviceFactory.h"

namespace LinuxSampler {
        
// *************** privat static functions ***************
// *
        
        static void _bridgeInputEvent(const MIDIPacketList* packetList, void* /*device*/, void* port) {
                //MidiInputDeviceCoreMidi* pDevice = (MidiInputDeviceCoreMidi*) device;
                MidiInputDeviceCoreMidi::MidiInputPortCoreMidi* pPort = (MidiInputDeviceCoreMidi::MidiInputPortCoreMidi*) port;
                pPort->ProcessMidiEvents(packetList);
        }
        
        static String _getDisplayName(MIDIObjectRef object) {
                CFStringRef name = nil;
                if (MIDIObjectGetStringProperty(object, kMIDIPropertyDisplayName, &name) != noErr) {
                        dmsg(1,("CoreMIDI: could not resolve display name of object\n"));
                        return "";
                }
                // convert NSString to C string
                char* buf = new char[256];
                if (!CFStringGetCString(name, buf, 256, kCFStringEncodingUTF8)) {
                        dmsg(1,("CoreMIDI: could not convert display name string\n"));
                        delete[] buf;
                        return "";
                }
                String result = buf;
                delete[] buf;
                return result;
        }
        
        
// *************** ParameterName ***************
// *

        MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterName::ParameterName(MidiInputPort* pPort) throw (Exception) : MidiInputPort::ParameterName(pPort, "Port " + ToString(pPort->GetPortNumber())) {
        OnSetValue(ValueAsString()); // initialize port name
    }

    void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterName::OnSetValue(String s) throw (Exception) {
                //TODO: renaming of port to be implemented
    }

// *************** ParameterCoreMidiBindings ***************
// *

    MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::ParameterCoreMidiBindings(MidiInputPortCoreMidi* pPort) : DeviceRuntimeParameterStrings( std::vector<String>() ) {
        this->pPort = pPort;
    }

    String MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::Description() {
        return "Bindings to other CoreMidi clients";
    }
    bool MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::Fix() {
        return false;
    }

    std::vector<String> MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::PossibilitiesAsString() {
        std::vector<String> res;
                
                const ItemCount sourceCount = MIDIGetNumberOfSources();
                for (ItemCount i = 0; i < sourceCount; ++i) {
                        MIDIEndpointRef source = MIDIGetSource(i);
                        res.push_back(
                                _getDisplayName(source)
                        );
                }
                
                return res;
    }

    void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::OnSetValue(std::vector<String> vS) throw (Exception) {
        for (int k = 0; k < vS.size(); ++k) {
                        const ItemCount sourceCount = MIDIGetNumberOfSources();
                        for (ItemCount i = 0; i < sourceCount; ++i) {
                                MIDIEndpointRef source = MIDIGetSource(i);
                                String name = _getDisplayName(source);
                                if (name == vS[k]) {
                                        pPort->connectToSource(source);
                                        goto matchFound;
                                }
                        }
                        throw MidiInputException("No CoreMIDI source '" + vS[k] + "' found to connect to");
                        matchFound:
                        ; // noop
                }
    }
        
// *************** ParameterAutoBind ***************
// *
        
        MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterAutoBind::ParameterAutoBind(MidiInputPortCoreMidi* pPort)
                : DeviceRuntimeParameterBool(false)
        {
                this->pPort = pPort;
        }
        
        String MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterAutoBind::Description() {
                return "Whether port shall automatically be connected to all CoreMIDI source endpoints.";
        }
        
        bool MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterAutoBind::Fix() {
                return false;
        }
        
        void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterAutoBind::OnSetValue(bool b) throw (Exception) {
                if (b) pPort->connectToAllSources();
        }


// *************** MidiInputPortCoreMidi ***************
// *
        
        int MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::pPortID = 0;

    MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::MidiInputPortCoreMidi(MidiInputDeviceCoreMidi* pDevice) throw (MidiInputException) : MidiInputPort(pDevice, -1) {
                this->pDevice = pDevice;
                
        // create CoreMidi virtual destination

           /*  20080105 Toshi Nagata  */
                char buf[32];
                CFStringRef str;
                snprintf(buf, sizeof buf, "LinuxSampler_in_%d", pPortID);
                str = CFStringCreateWithCString(NULL, buf, kCFStringEncodingUTF8);
                MIDIDestinationCreate(pDevice->hCoreMidiClient, str, ReadProc, this, &pDestination);
                /*  */

                if (!pDestination) throw MidiInputException("Error creating CoreMidi virtual destination");
                this->portNumber = pPortID++;

        Parameters["NAME"]      = new ParameterName(this);
        Parameters["CORE_MIDI_BINDINGS"] = new ParameterCoreMidiBindings(this);
                Parameters["AUTO_BIND"] = new ParameterAutoBind(this);
    }

    MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::~MidiInputPortCoreMidi() {
                MIDIEndpointDispose(pDestination);
    }

        void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ReadProc(const MIDIPacketList* pktlist, void* refCon, void* connRefCon)
        {
                MidiInputPortCoreMidi* port = (MidiInputPortCoreMidi*)refCon;
                port->ProcessMidiEvents(pktlist);
        }
        
        void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ProcessMidiEvents(const MIDIPacketList *pktlist) {
                MIDIPacket *packet = (MIDIPacket *)pktlist->packet;
                for (unsigned int i = 0; i < pktlist->numPackets; ++i) {
                        uint8_t* pData = (uint8_t*) packet->data;
                        int k = 0;
                        // A MIDIPacket can have more than one (non SysEx) MIDI event in one
                        // packet. However SysEx messages are guaranteed to be alone in one
                        // MIDIPacket.
                        do {
                                int eventSize = expectedEventSize(pData[k]);
                                if (eventSize < 0) eventSize = packet->length - k;

                                if (k + eventSize > packet->length) goto next_packet;

                                DispatchRaw(&pData[k]);
                                k += eventSize;
                        } while (k < packet->length);

                next_packet:
                        packet = MIDIPacketNext(packet);
                }
        }
        
        void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::connectToSource(MIDIEndpointRef source) {
                // check if we already have such a connection, if yes, ignore it
                for (uint i = 0; i < bindings.size(); ++i) {
                        if (bindings[i] == source) return;
                }
                // now establish the CoreMIDI connection
                MIDIPortConnectSource(pDevice->pBridge, source, this);
                // and remember it
                bindings.push_back(source);
        }
        
        void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::connectToAllSources() {
                const ItemCount sourceCount = MIDIGetNumberOfSources();
                for (ItemCount i = 0; i < sourceCount; ++i) {
                        MIDIEndpointRef source = MIDIGetSource(i);
                        connectToSource(source);
                        dmsg(1,("Auto binded to CoreMIDI source '%s'\n", _getDisplayName(source).c_str()));
                }
        }
        
        void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::onNewSourceAppeared(MIDIEndpointRef source) {
                if (((ParameterAutoBind*)Parameters["AUTO_BIND"])->ValueAsBool()) {
                        connectToSource(source);
                        dmsg(1,("Auto binded to new CoreMIDI source '%s'\n", _getDisplayName(source).c_str()));
                }
        }
        
        void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::onNewSourceDisappeared(MIDIEndpointRef source) {
                std::vector<MIDIEndpointRef>::iterator iter = std::find(bindings.begin(), bindings.end(), source);
                if (iter != bindings.end()) {
                        dmsg(1,("CoreMIDI source '%s' disappeared, disconnecting it.\n", _getDisplayName(source).c_str()));
                        bindings.erase(iter);
                }
        }


// *************** MidiInputDeviceCoreMidi ***************
// *

    MidiInputDeviceCoreMidi::MidiInputDeviceCoreMidi(std::map<String,DeviceCreationParameter*> Parameters, void* pSampler) : MidiInputDevice(Parameters, pSampler)
        {
                MIDIClientCreate(CFSTR("LinuxSampler"), NotifyProc, this, &hCoreMidiClient);
                if (!hCoreMidiClient) throw MidiInputException("Error opening CoreMidi client");
                
                OSStatus status = MIDIInputPortCreate(hCoreMidiClient, CFSTR("bridge"), _bridgeInputEvent, this, &pBridge);
                if (status != noErr) throw MidiInputException("Could not create bridge port for CoreMIDI client");
                                                        
                AcquirePorts(((DeviceCreationParameterInt*)Parameters["PORTS"])->ValueAsInt());
        }

    MidiInputDeviceCoreMidi::~MidiInputDeviceCoreMidi()
        {
                if (hCoreMidiClient) {
                        MIDIClientDispose(hCoreMidiClient);
                }
    }

        MidiInputDeviceCoreMidi::MidiInputPortCoreMidi* MidiInputDeviceCoreMidi::CreateMidiPort() {
                return new MidiInputPortCoreMidi(this);
    }

        String MidiInputDeviceCoreMidi::Name() {
            return "COREMIDI";
    }

        String MidiInputDeviceCoreMidi::Driver() {
            return Name();
    }

         String MidiInputDeviceCoreMidi::Description() {
            return "Apple CoreMidi";
    }

    String MidiInputDeviceCoreMidi::Version() {
            String s = "$Revision$";
            return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
    }

        void MidiInputDeviceCoreMidi::NotifyProc(const MIDINotification* message, void* refCon)
        {
                MidiInputDeviceCoreMidi* pDevice = (MidiInputDeviceCoreMidi*) refCon;
                
                switch (message->messageID) {
                        case kMIDIMsgObjectAdded: {
                                MIDIObjectAddRemoveNotification* notification = (MIDIObjectAddRemoveNotification*) message;
                                if (notification->childType == kMIDIObjectType_Source) {
                                        for (std::map<int,MidiInputPort*>::iterator iter = pDevice->Ports.begin();
                                                 iter != pDevice->Ports.end(); ++iter)
                                        {
                                                MidiInputPortCoreMidi* pPort = (MidiInputPortCoreMidi*) iter->second;
                                                MIDIEndpointRef source = (MIDIEndpointRef) notification->child;
                                                pPort->onNewSourceAppeared(source);
                                        }
                                }
                                break;
                        }
                                
                        case kMIDIMsgObjectRemoved: {
                                MIDIObjectAddRemoveNotification* notification = (MIDIObjectAddRemoveNotification*) message;
                                if (notification->childType == kMIDIObjectType_Source) {
                                        for (std::map<int,MidiInputPort*>::iterator iter = pDevice->Ports.begin();
                                                 iter != pDevice->Ports.end(); ++iter)
                                        {
                                                MidiInputPortCoreMidi* pPort = (MidiInputPortCoreMidi*) iter->second;
                                                MIDIEndpointRef source = (MIDIEndpointRef) notification->child;
                                                pPort->onNewSourceDisappeared(source);
                                        }
                                }
                                break;
                        }
                                
                        case kMIDIMsgSetupChanged:
                        case kMIDIMsgPropertyChanged:
                        case kMIDIMsgThruConnectionsChanged:
                        case kMIDIMsgSerialPortOwnerChanged:
                        case kMIDIMsgIOError:
                                break;
                }
        }

} // namespace LinuxSampler
1	/***************************************************************************
2	* *
3	* Copyright (C) 2004, 2005 Grame *
4	* Copyright (C) 2005 - 2012 Christian Schoenebeck *
5	* *
6	* This program is free software; you can redistribute it and/or modify *
7	* it under the terms of the GNU General Public License as published by *
8	* the Free Software Foundation; either version 2 of the License, or *
9	* (at your option) any later version. *
10	* *
11	* This program is distributed in the hope that it will be useful, *
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14	* GNU General Public License for more details. *
15	* *
16	* You should have received a copy of the GNU General Public License *
17	* along with this program; if not, write to the Free Software *
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
19	* MA 02111-1307 USA *
20	***************************************************************************/
21
22	#include "MidiInputDeviceCoreMidi.h"
23	#include "MidiInputDeviceFactory.h"
24
25	namespace LinuxSampler {
26
27	// ************* privat static functions *************
28	// *
29
30	static void _bridgeInputEvent(const MIDIPacketList* packetList, void* /device/, void* port) {
31	//MidiInputDeviceCoreMidi* pDevice = (MidiInputDeviceCoreMidi*) device;
32	MidiInputDeviceCoreMidi::MidiInputPortCoreMidi* pPort = (MidiInputDeviceCoreMidi::MidiInputPortCoreMidi*) port;
33	pPort->ProcessMidiEvents(packetList);
34	}
35
36	static String _getDisplayName(MIDIObjectRef object) {
37	CFStringRef name = nil;
38	if (MIDIObjectGetStringProperty(object, kMIDIPropertyDisplayName, &name) != noErr) {
39	dmsg(1,("CoreMIDI: could not resolve display name of object\n"));
40	return "";
41	}
42	// convert NSString to C string
43	char* buf = new char[256];
44	if (!CFStringGetCString(name, buf, 256, kCFStringEncodingUTF8)) {
45	dmsg(1,("CoreMIDI: could not convert display name string\n"));
46	delete[] buf;
47	return "";
48	}
49	String result = buf;
50	delete[] buf;
51	return result;
52	}
53
54
55	// ************* ParameterName *************
56	// *
57
58	MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterName::ParameterName(MidiInputPort* pPort) throw (Exception) : MidiInputPort::ParameterName(pPort, "Port " + ToString(pPort->GetPortNumber())) {
59	OnSetValue(ValueAsString()); // initialize port name
60	}
61
62	void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterName::OnSetValue(String s) throw (Exception) {
63	//TODO: renaming of port to be implemented
64	}
65
66	// ************* ParameterCoreMidiBindings *************
67	// *
68
69	MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::ParameterCoreMidiBindings(MidiInputPortCoreMidi* pPort) : DeviceRuntimeParameterStrings( std::vector<String>() ) {
70	this->pPort = pPort;
71	}
72
73	String MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::Description() {
74	return "Bindings to other CoreMidi clients";
75	}
76	bool MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::Fix() {
77	return false;
78	}
79
80	std::vector<String> MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::PossibilitiesAsString() {
81	std::vector<String> res;
82
83	const ItemCount sourceCount = MIDIGetNumberOfSources();
84	for (ItemCount i = 0; i < sourceCount; ++i) {
85	MIDIEndpointRef source = MIDIGetSource(i);
86	res.push_back(
87	_getDisplayName(source)
88	);
89	}
90
91	return res;
92	}
93
94	void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterCoreMidiBindings::OnSetValue(std::vector<String> vS) throw (Exception) {
95	for (int k = 0; k < vS.size(); ++k) {
96	const ItemCount sourceCount = MIDIGetNumberOfSources();
97	for (ItemCount i = 0; i < sourceCount; ++i) {
98	MIDIEndpointRef source = MIDIGetSource(i);
99	String name = _getDisplayName(source);
100	if (name == vS[k]) {
101	pPort->connectToSource(source);
102	goto matchFound;
103	}
104	}
105	throw MidiInputException("No CoreMIDI source '" + vS[k] + "' found to connect to");
106	matchFound:
107	; // noop
108	}
109	}
110
111	// ************* ParameterAutoBind *************
112	// *
113
114	MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterAutoBind::ParameterAutoBind(MidiInputPortCoreMidi* pPort)
115	: DeviceRuntimeParameterBool(false)
116	{
117	this->pPort = pPort;
118	}
119
120	String MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterAutoBind::Description() {
121	return "Whether port shall automatically be connected to all CoreMIDI source endpoints.";
122	}
123
124	bool MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterAutoBind::Fix() {
125	return false;
126	}
127
128	void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ParameterAutoBind::OnSetValue(bool b) throw (Exception) {
129	if (b) pPort->connectToAllSources();
130	}
131
132
133	// ************* MidiInputPortCoreMidi *************
134	// *
135
136	int MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::pPortID = 0;
137
138	MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::MidiInputPortCoreMidi(MidiInputDeviceCoreMidi* pDevice) throw (MidiInputException) : MidiInputPort(pDevice, -1) {
139	this->pDevice = pDevice;
140
141	// create CoreMidi virtual destination
142
143	/* 20080105 Toshi Nagata */
144	char buf[32];
145	CFStringRef str;
146	snprintf(buf, sizeof buf, "LinuxSampler_in_%d", pPortID);
147	str = CFStringCreateWithCString(NULL, buf, kCFStringEncodingUTF8);
148	MIDIDestinationCreate(pDevice->hCoreMidiClient, str, ReadProc, this, &pDestination);
149	/* */
150
151	if (!pDestination) throw MidiInputException("Error creating CoreMidi virtual destination");
152	this->portNumber = pPortID++;
153
154	Parameters["NAME"] = new ParameterName(this);
155	Parameters["CORE_MIDI_BINDINGS"] = new ParameterCoreMidiBindings(this);
156	Parameters["AUTO_BIND"] = new ParameterAutoBind(this);
157	}
158
159	MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::~MidiInputPortCoreMidi() {
160	MIDIEndpointDispose(pDestination);
161	}
162
163	void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ReadProc(const MIDIPacketList* pktlist, void* refCon, void* connRefCon)
164	{
165	MidiInputPortCoreMidi* port = (MidiInputPortCoreMidi*)refCon;
166	port->ProcessMidiEvents(pktlist);
167	}
168
169	void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::ProcessMidiEvents(const MIDIPacketList *pktlist) {
170	MIDIPacket packet = (MIDIPacket )pktlist->packet;
171	for (unsigned int i = 0; i < pktlist->numPackets; ++i) {
172	uint8_t* pData = (uint8_t*) packet->data;
173	int k = 0;
174	// A MIDIPacket can have more than one (non SysEx) MIDI event in one
175	// packet. However SysEx messages are guaranteed to be alone in one
176	// MIDIPacket.
177	do {
178	int eventSize = expectedEventSize(pData[k]);
179	if (eventSize < 0) eventSize = packet->length - k;
180
181	if (k + eventSize > packet->length) goto next_packet;
182
183	DispatchRaw(&pData[k]);
184	k += eventSize;
185	} while (k < packet->length);
186
187	next_packet:
188	packet = MIDIPacketNext(packet);
189	}
190	}
191
192	void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::connectToSource(MIDIEndpointRef source) {
193	// check if we already have such a connection, if yes, ignore it
194	for (uint i = 0; i < bindings.size(); ++i) {
195	if (bindings[i] == source) return;
196	}
197	// now establish the CoreMIDI connection
198	MIDIPortConnectSource(pDevice->pBridge, source, this);
199	// and remember it
200	bindings.push_back(source);
201	}
202
203	void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::connectToAllSources() {
204	const ItemCount sourceCount = MIDIGetNumberOfSources();
205	for (ItemCount i = 0; i < sourceCount; ++i) {
206	MIDIEndpointRef source = MIDIGetSource(i);
207	connectToSource(source);
208	dmsg(1,("Auto binded to CoreMIDI source '%s'\n", _getDisplayName(source).c_str()));
209	}
210	}
211
212	void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::onNewSourceAppeared(MIDIEndpointRef source) {
213	if (((ParameterAutoBind*)Parameters["AUTO_BIND"])->ValueAsBool()) {
214	connectToSource(source);
215	dmsg(1,("Auto binded to new CoreMIDI source '%s'\n", _getDisplayName(source).c_str()));
216	}
217	}
218
219	void MidiInputDeviceCoreMidi::MidiInputPortCoreMidi::onNewSourceDisappeared(MIDIEndpointRef source) {
220	std::vector<MIDIEndpointRef>::iterator iter = std::find(bindings.begin(), bindings.end(), source);
221	if (iter != bindings.end()) {
222	dmsg(1,("CoreMIDI source '%s' disappeared, disconnecting it.\n", _getDisplayName(source).c_str()));
223	bindings.erase(iter);
224	}
225	}
226
227
228	// ************* MidiInputDeviceCoreMidi *************
229	// *
230
231	MidiInputDeviceCoreMidi::MidiInputDeviceCoreMidi(std::map<String,DeviceCreationParameter> Parameters, void pSampler) : MidiInputDevice(Parameters, pSampler)
232	{
233	MIDIClientCreate(CFSTR("LinuxSampler"), NotifyProc, this, &hCoreMidiClient);
234	if (!hCoreMidiClient) throw MidiInputException("Error opening CoreMidi client");
235
236	OSStatus status = MIDIInputPortCreate(hCoreMidiClient, CFSTR("bridge"), _bridgeInputEvent, this, &pBridge);
237	if (status != noErr) throw MidiInputException("Could not create bridge port for CoreMIDI client");
238
239	AcquirePorts(((DeviceCreationParameterInt*)Parameters["PORTS"])->ValueAsInt());
240	}
241
242	MidiInputDeviceCoreMidi::~MidiInputDeviceCoreMidi()
243	{
244	if (hCoreMidiClient) {
245	MIDIClientDispose(hCoreMidiClient);
246	}
247	}
248
249	MidiInputDeviceCoreMidi::MidiInputPortCoreMidi* MidiInputDeviceCoreMidi::CreateMidiPort() {
250	return new MidiInputPortCoreMidi(this);
251	}
252
253	String MidiInputDeviceCoreMidi::Name() {
254	return "COREMIDI";
255	}
256
257	String MidiInputDeviceCoreMidi::Driver() {
258	return Name();
259	}
260
261	String MidiInputDeviceCoreMidi::Description() {
262	return "Apple CoreMidi";
263	}
264
265	String MidiInputDeviceCoreMidi::Version() {
266	String s = "$Revision$";
267	return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
268	}
269
270	void MidiInputDeviceCoreMidi::NotifyProc(const MIDINotification* message, void* refCon)
271	{
272	MidiInputDeviceCoreMidi* pDevice = (MidiInputDeviceCoreMidi*) refCon;
273
274	switch (message->messageID) {
275	case kMIDIMsgObjectAdded: {
276	MIDIObjectAddRemoveNotification* notification = (MIDIObjectAddRemoveNotification*) message;
277	if (notification->childType == kMIDIObjectType_Source) {
278	for (std::map<int,MidiInputPort*>::iterator iter = pDevice->Ports.begin();
279	iter != pDevice->Ports.end(); ++iter)
280	{
281	MidiInputPortCoreMidi* pPort = (MidiInputPortCoreMidi*) iter->second;
282	MIDIEndpointRef source = (MIDIEndpointRef) notification->child;
283	pPort->onNewSourceAppeared(source);
284	}
285	}
286	break;
287	}
288
289	case kMIDIMsgObjectRemoved: {
290	MIDIObjectAddRemoveNotification* notification = (MIDIObjectAddRemoveNotification*) message;
291	if (notification->childType == kMIDIObjectType_Source) {
292	for (std::map<int,MidiInputPort*>::iterator iter = pDevice->Ports.begin();
293	iter != pDevice->Ports.end(); ++iter)
294	{
295	MidiInputPortCoreMidi* pPort = (MidiInputPortCoreMidi*) iter->second;
296	MIDIEndpointRef source = (MIDIEndpointRef) notification->child;
297	pPort->onNewSourceDisappeared(source);
298	}
299	}
300	break;
301	}
302
303	case kMIDIMsgSetupChanged:
304	case kMIDIMsgPropertyChanged:
305	case kMIDIMsgThruConnectionsChanged:
306	case kMIDIMsgSerialPortOwnerChanged:
307	case kMIDIMsgIOError:
308	break;
309	}
310	}
311
312	} // namespace LinuxSampler