drivers/midi/MidiInputDeviceCoreMidi.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2004 Grame                                                                                      *
 *                                                                         *
 *   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"

namespace LinuxSampler {

    MidiInputDeviceCoreMidi::MidiInputDeviceCoreMidi(char* AutoConnectPortID) : MidiInputDevice(MidiInputDevice::type_core_midi) 
        {
                OSStatus err;
        
                err = MIDIClientCreate(CFSTR("LinuxSampler"), NotifyProc, NULL, &hCoreMidiClient);
                if (!hCoreMidiClient) {
                        fprintf(stderr, "Cannot open CoreMidi client\n");
                        goto error;
                }
                
                err = MIDIInputPortCreate(hCoreMidiClient, CFSTR("Input port"), ReadProc, this, &hCoreMidiInPort);
                if (!hCoreMidiInPort) {
                        fprintf(stderr, "Cannot open Midi in port\n");
                        goto error;
                }
                
                if (AutoConnectPortID) ConnectToCoreMidiSource(AutoConnectPortID);
                
                // for test : to be improved
                ConnectToCoreMidiSource(NULL);
                return;
                
        error :
                if (hCoreMidiInPort){
                         MIDIPortDispose(hCoreMidiInPort);
                }
                
                if (hCoreMidiClient) {
                        MIDIClientDispose(hCoreMidiClient);
                }
                
                throw MidiInputException("Error opening CoreMidi device");
    }

    void MidiInputDeviceCoreMidi::SetInputPort(const char * MidiSource) 
        {
            ConnectToCoreMidiSource(MidiSource);
    }

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

        void MidiInputDeviceCoreMidi::ConnectToCoreMidiSource(const char* MidiSource)
        {
                // Open connections from all sources : to be improved
                int n = MIDIGetNumberOfSources();
                for (int i = 0; i < n; ++i) {
                        MIDIEndpointRef src = MIDIGetSource(i);
                        MIDIPortConnectSource(hCoreMidiInPort, src, NULL);
                }
        }
        
        void MidiInputDeviceCoreMidi::NotifyProc(const MIDINotification *message, void *refCon)
        {
                if (message->messageID == kMIDIMsgSetupChanged) {
                        printf("kMIDIMsgSetupChanged\n");
                }
        }
        
        void MidiInputDeviceCoreMidi::ReadProc(const MIDIPacketList *pktlist, void *refCon, void *connRefCon)
        {
                MidiInputDeviceCoreMidi* driver = (MidiInputDeviceCoreMidi*)refCon;
                MIDIPacket *packet = (MIDIPacket *)pktlist->packet;     
        
                for (int i = 0; i < pktlist->numPackets; ++i) {
                
                        int cin = packet->data[0] & 0xF0;
                        
                        // To be checked : several events per packet
                
                        switch(cin) { // status byte
                        
                                case 0xB0:
                                        driver->DispatchControlChange(packet->data[1],packet->data[2],packet->data[0]&0x0F);
                                        break;
                                        
                                case 0xE0:
                                        driver->DispatchPitchbend(packet->data[1],packet->data[0]&0x0F);
                                        break;

                                case 0x90:
                                        if (packet->data[1] < 128){
                                                if (packet->data[2] > 0){
                                                        driver->DispatchNoteOn(packet->data[1],packet->data[2], packet->data[0]&0x0F);
                                                }else{
                                                        driver->DispatchNoteOff(packet->data[1],packet->data[2],packet->data[0]&0x0F);
                                                }
                                        }
                                        break;
                                
                                case 0x80:
                                        if (packet->data[1] < 128){
                                                driver->DispatchNoteOff(packet->data[1],packet->data[2],packet->data[0]&0x0F);
                                        }
                                        break;
                        }
                        
                        packet = MIDIPacketNext(packet);
                }
        }


} // namespace LinuxSampler
1	schoenebeck	201	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6			* Copyright (C) 2004 Grame *
7			* *
8			* This program is free software; you can redistribute it and/or modify *
9			* it under the terms of the GNU General Public License as published by *
10			* the Free Software Foundation; either version 2 of the License, or *
11			* (at your option) any later version. *
12			* *
13			* This program is distributed in the hope that it will be useful, *
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16			* GNU General Public License for more details. *
17			* *
18			* You should have received a copy of the GNU General Public License *
19			* along with this program; if not, write to the Free Software *
20			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21			* MA 02111-1307 USA *
22			***************************************************************************/
23
24			#include "MidiInputDeviceCoreMidi.h"
25
26			namespace LinuxSampler {
27
28			MidiInputDeviceCoreMidi::MidiInputDeviceCoreMidi(char* AutoConnectPortID) : MidiInputDevice(MidiInputDevice::type_core_midi)
29			{
30			OSStatus err;
31
32			err = MIDIClientCreate(CFSTR("LinuxSampler"), NotifyProc, NULL, &hCoreMidiClient);
33			if (!hCoreMidiClient) {
34			fprintf(stderr, "Cannot open CoreMidi client\n");
35			goto error;
36			}
37
38			err = MIDIInputPortCreate(hCoreMidiClient, CFSTR("Input port"), ReadProc, this, &hCoreMidiInPort);
39			if (!hCoreMidiInPort) {
40			fprintf(stderr, "Cannot open Midi in port\n");
41			goto error;
42			}
43
44			if (AutoConnectPortID) ConnectToCoreMidiSource(AutoConnectPortID);
45
46			// for test : to be improved
47			ConnectToCoreMidiSource(NULL);
48			return;
49
50			error :
51			if (hCoreMidiInPort){
52			MIDIPortDispose(hCoreMidiInPort);
53			}
54
55			if (hCoreMidiClient) {
56			MIDIClientDispose(hCoreMidiClient);
57			}
58
59			throw MidiInputException("Error opening CoreMidi device");
60			}
61
62			void MidiInputDeviceCoreMidi::SetInputPort(const char * MidiSource)
63			{
64			ConnectToCoreMidiSource(MidiSource);
65			}
66
67			MidiInputDeviceCoreMidi::~MidiInputDeviceCoreMidi()
68			{
69			if (hCoreMidiInPort){
70			MIDIPortDispose(hCoreMidiInPort);
71			}
72
73			if (hCoreMidiClient) {
74			MIDIClientDispose(hCoreMidiClient);
75			}
76			}
77
78			void MidiInputDeviceCoreMidi::ConnectToCoreMidiSource(const char* MidiSource)
79			{
80			// Open connections from all sources : to be improved
81			int n = MIDIGetNumberOfSources();
82			for (int i = 0; i < n; ++i) {
83			MIDIEndpointRef src = MIDIGetSource(i);
84			MIDIPortConnectSource(hCoreMidiInPort, src, NULL);
85			}
86			}
87
88			void MidiInputDeviceCoreMidi::NotifyProc(const MIDINotification message, void refCon)
89			{
90			if (message->messageID == kMIDIMsgSetupChanged) {
91			printf("kMIDIMsgSetupChanged\n");
92			}
93			}
94
95			void MidiInputDeviceCoreMidi::ReadProc(const MIDIPacketList pktlist, void refCon, void *connRefCon)
96			{
97			MidiInputDeviceCoreMidi* driver = (MidiInputDeviceCoreMidi*)refCon;
98			MIDIPacket packet = (MIDIPacket )pktlist->packet;
99
100			for (int i = 0; i < pktlist->numPackets; ++i) {
101
102			int cin = packet->data[0] & 0xF0;
103
104			// To be checked : several events per packet
105
106			switch(cin) { // status byte
107
108			case 0xB0:
109			driver->DispatchControlChange(packet->data[1],packet->data[2],packet->data[0]&0x0F);
110			break;
111
112			case 0xE0:
113			driver->DispatchPitchbend(packet->data[1],packet->data[0]&0x0F);
114			break;
115
116			case 0x90:
117			if (packet->data[1] < 128){
118			if (packet->data[2] > 0){
119			driver->DispatchNoteOn(packet->data[1],packet->data[2], packet->data[0]&0x0F);
120			}else{
121			driver->DispatchNoteOff(packet->data[1],packet->data[2],packet->data[0]&0x0F);
122			}
123			}
124			break;
125
126			case 0x80:
127			if (packet->data[1] < 128){
128			driver->DispatchNoteOff(packet->data[1],packet->data[2],packet->data[0]&0x0F);
129			}
130			break;
131			}
132
133			packet = MIDIPacketNext(packet);
134			}
135			}
136
137
138			} // namespace LinuxSampler