/[svn]/linuxsampler/trunk/src/drivers/midi/MidiInputDeviceAlsa.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/drivers/midi/MidiInputDeviceAlsa.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1344 - (show annotations) (download)
Thu Sep 13 08:46:51 2007 UTC (11 years, 11 months ago) by schoenebeck
File size: 13320 byte(s)
- just to aoid some compiler warning

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2007 Christian Schoenebeck *
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 "MidiInputDeviceAlsa.h"
25 #include "MidiInputDeviceFactory.h"
26
27 #define perm_ok(pinfo,bits) ((snd_seq_port_info_get_capability(pinfo) & (bits)) == (bits))
28
29 namespace LinuxSampler {
30
31 // *************** ParameterName ***************
32 // *
33
34 MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterName::ParameterName(MidiInputPort* pPort) throw (Exception) : MidiInputPort::ParameterName(pPort, "Port " + ToString(pPort->GetPortNumber())) {
35 OnSetValue(ValueAsString()); // initialize port name
36 }
37
38 void MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterName::OnSetValue(String s) throw (Exception) {
39 if (s.size() > 16) throw Exception("Name too long for ALSA MIDI input port (max. 16 characters)");
40 snd_seq_port_info_t* hInfo;
41 snd_seq_port_info_malloc(&hInfo);
42 snd_seq_get_port_info(((MidiInputDeviceAlsa*)pPort->GetDevice())->hAlsaSeq, pPort->GetPortNumber(), hInfo);
43 snd_seq_port_info_set_name(hInfo, s.c_str());
44 snd_seq_set_port_info(((MidiInputDeviceAlsa*)pPort->GetDevice())->hAlsaSeq, pPort->GetPortNumber(), hInfo);
45 snd_seq_port_info_free(hInfo);
46 }
47
48
49
50 // *************** ParameterAlsaSeqBindings ***************
51 // *
52
53
54 MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqBindings::ParameterAlsaSeqBindings(MidiInputPortAlsa* pPort) : DeviceRuntimeParameterStrings( std::vector<String>() ) {
55 this->pPort = pPort;
56 }
57
58 String MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqBindings::Description() {
59 return "Bindings to other Alsa sequencer clients";
60 }
61 bool MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqBindings::Fix() {
62 return false;
63 }
64
65 std::vector<String> MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqBindings::PossibilitiesAsString() {
66 std::vector<String> res;
67 snd_seq_client_info_t* cinfo;
68 snd_seq_port_info_t* pinfo;
69
70 snd_seq_client_info_alloca(&cinfo);
71 snd_seq_port_info_alloca(&pinfo);
72 snd_seq_client_info_set_client(cinfo, -1);
73 while (snd_seq_query_next_client(pPort->pDevice->hAlsaSeq, cinfo) >= 0) {
74 snd_seq_port_info_set_client(pinfo, snd_seq_client_info_get_client(cinfo));
75 snd_seq_port_info_set_port(pinfo, -1);
76 while (snd_seq_query_next_port(pPort->pDevice->hAlsaSeq, pinfo) >= 0) {
77 if (perm_ok(pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ)) {
78 String seq_id = ToString(snd_seq_client_info_get_client(cinfo)) + ":" +
79 ToString(snd_seq_port_info_get_port(pinfo));
80 res.push_back(seq_id);
81 }
82 }
83 }
84
85 return res;
86 }
87
88 void MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqBindings::OnSetValue(std::vector<String> vS) throw (Exception) {
89 std::vector<snd_seq_port_subscribe_t*>::iterator it = pPort->subscriptions.begin();
90 for (; it != pPort->subscriptions.end(); it++) {
91 if(snd_seq_unsubscribe_port(pPort->pDevice->hAlsaSeq, *it)) {
92 dmsg(1,("ParameterAlsaSeqBindings::OnSetValue: Can't unsubscribe port connection!.\n"));
93 }
94 snd_seq_port_subscribe_free(*it);
95 }
96 pPort->subscriptions.clear();
97
98 std::vector<String>::iterator iter = vS.begin();
99 for (; iter != vS.end(); iter++) pPort->ConnectToAlsaMidiSource((*iter).c_str());
100 }
101
102
103
104 // *************** ParameterAlsaSeqId ***************
105 // *
106
107 MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqId::ParameterAlsaSeqId(MidiInputPortAlsa* pPort)
108 : DeviceRuntimeParameterString(ToString(pPort->pDevice->hAlsaSeqClient) + ":" + ToString(pPort->portNumber)) {
109 }
110
111 String MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqId::Description() {
112 return "ALSA Sequencer ID";
113 }
114
115 bool MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqId::Fix() {
116 return true;
117 }
118
119 std::vector<String> MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqId::PossibilitiesAsString() {
120 return std::vector<String>(); // nothing
121 }
122
123 void MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterAlsaSeqId::OnSetValue(String s) {
124 // not possible as parameter is 'fix'
125 }
126
127
128
129 // *************** MidiInputPortAlsa ***************
130 // *
131
132 MidiInputDeviceAlsa::MidiInputPortAlsa::MidiInputPortAlsa(MidiInputDeviceAlsa* pDevice) throw (MidiInputException) : MidiInputPort(pDevice, -1) {
133 this->pDevice = pDevice;
134
135 // create Alsa sequencer port
136 int alsaPort = snd_seq_create_simple_port(pDevice->hAlsaSeq, "unnamed port",
137 SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE,
138 SND_SEQ_PORT_TYPE_APPLICATION);
139 if (alsaPort < 0) throw MidiInputException("Error creating sequencer port");
140 this->portNumber = alsaPort;
141
142 delete Parameters["NAME"];
143 Parameters["NAME"] = new ParameterName(this);
144 Parameters["ALSA_SEQ_BINDINGS"] = new ParameterAlsaSeqBindings(this);
145 Parameters["ALSA_SEQ_ID"] = new ParameterAlsaSeqId(this);
146 }
147
148 MidiInputDeviceAlsa::MidiInputPortAlsa::~MidiInputPortAlsa() {
149 snd_seq_delete_simple_port(pDevice->hAlsaSeq, portNumber);
150 }
151
152 /**
153 * Connects this Alsa midi input device with an Alsa MIDI source.
154 *
155 * @param Client - Alsa sequencer client and port ID of a MIDI source
156 * (e.g. "64:0")
157 * @throws MidiInputException if connection cannot be established
158 */
159 void MidiInputDeviceAlsa::MidiInputPortAlsa::ConnectToAlsaMidiSource(const char* MidiSource) {
160 snd_seq_addr_t sender, dest;
161 snd_seq_port_subscribe_t* subs;
162 int hExtClient, hExtPort;
163
164 sscanf(MidiSource, "%d:%d", &hExtClient, &hExtPort);
165 sender.client = (char) hExtClient;
166 sender.port = (char) hExtPort;
167 dest.client = (char) pDevice->hAlsaSeqClient;
168 dest.port = (char) portNumber;
169 snd_seq_port_subscribe_malloc(&subs);
170 snd_seq_port_subscribe_set_sender(subs, &sender);
171 snd_seq_port_subscribe_set_dest(subs, &dest);
172 snd_seq_port_subscribe_set_queue(subs, 1);
173 snd_seq_port_subscribe_set_time_update(subs, 1);
174 snd_seq_port_subscribe_set_time_real(subs, 1);
175 if (snd_seq_subscribe_port(pDevice->hAlsaSeq, subs) < 0) {
176 snd_seq_port_subscribe_free(subs);
177 throw MidiInputException(String("Unable to connect to Alsa seq client \'") + MidiSource + "\' (" + snd_strerror(errno) + ")");
178 }
179
180 subscriptions.push_back(subs);
181 }
182
183
184
185 // *************** MidiInputDeviceAlsa ***************
186 // *
187
188 MidiInputDeviceAlsa::MidiInputDeviceAlsa(std::map<String,DeviceCreationParameter*> Parameters, void* pSampler) : MidiInputDevice(Parameters, pSampler), Thread(true, true, 1, -1) {
189 if (snd_seq_open(&hAlsaSeq, "default", SND_SEQ_OPEN_INPUT, 0) < 0) {
190 throw MidiInputException("Error opening ALSA sequencer");
191 }
192 this->hAlsaSeqClient = snd_seq_client_id(hAlsaSeq);
193 snd_seq_set_client_name(hAlsaSeq, "LinuxSampler");
194 AcquirePorts(((DeviceCreationParameterInt*)Parameters["PORTS"])->ValueAsInt());
195 if (((DeviceCreationParameterBool*)Parameters["ACTIVE"])->ValueAsBool()) {
196 Listen();
197 }
198 }
199
200 MidiInputDeviceAlsa::~MidiInputDeviceAlsa() {
201 // free the midi ports (we can't let the base class do this,
202 // as the MidiInputPortAlsa destructors need access to
203 // hAlsaSeq)
204 for (std::map<int,MidiInputPort*>::iterator iter = Ports.begin(); iter != Ports.end() ; iter++) {
205 delete static_cast<MidiInputPortAlsa*>(iter->second);
206 }
207 Ports.clear();
208
209 snd_seq_close(hAlsaSeq);
210 }
211
212 MidiInputDeviceAlsa::MidiInputPortAlsa* MidiInputDeviceAlsa::CreateMidiPort() {
213 return new MidiInputPortAlsa(this);
214 }
215
216 String MidiInputDeviceAlsa::Name() {
217 return "ALSA";
218 }
219
220 String MidiInputDeviceAlsa::Driver() {
221 return Name();
222 }
223
224 void MidiInputDeviceAlsa::Listen() {
225 StartThread();
226 }
227
228 void MidiInputDeviceAlsa::StopListen() {
229 StopThread();
230 }
231
232 String MidiInputDeviceAlsa::Description() {
233 return "Advanced Linux Sound Architecture";
234 }
235
236 String MidiInputDeviceAlsa::Version() {
237 String s = "$Revision: 1.21 $";
238 return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
239 }
240
241 int MidiInputDeviceAlsa::Main() {
242 int npfd;
243 struct pollfd* pfd;
244 snd_seq_event_t* ev;
245
246 npfd = snd_seq_poll_descriptors_count(hAlsaSeq, POLLIN);
247 pfd = (struct pollfd*) alloca(npfd * sizeof(struct pollfd));
248 snd_seq_poll_descriptors(hAlsaSeq, pfd, npfd, POLLIN);
249 while (true) {
250 if (poll(pfd, npfd, 100000) > 0) {
251 do {
252 snd_seq_event_input(hAlsaSeq, &ev);
253 int port = (int) ev->dest.port;
254 MidiInputPort* pMidiInputPort = Ports[port];
255
256 switch (ev->type) {
257 case SND_SEQ_EVENT_CONTROLLER:
258 if (ev->data.control.param == 0)
259 pMidiInputPort->DispatchBankSelectMsb(ev->data.control.value, ev->data.control.channel);
260 else if (ev->data.control.param == 32)
261 pMidiInputPort->DispatchBankSelectLsb(ev->data.control.value, ev->data.control.channel);
262 else
263 pMidiInputPort->DispatchControlChange(ev->data.control.param, ev->data.control.value, ev->data.control.channel);
264 break;
265
266 case SND_SEQ_EVENT_CHANPRESS:
267 pMidiInputPort->DispatchControlChange(128, ev->data.control.value, ev->data.control.channel);
268 break;
269
270 case SND_SEQ_EVENT_PITCHBEND:
271 pMidiInputPort->DispatchPitchbend(ev->data.control.value, ev->data.control.channel);
272 break;
273
274 case SND_SEQ_EVENT_NOTEON:
275 if (ev->data.note.velocity != 0) {
276 pMidiInputPort->DispatchNoteOn(ev->data.note.note, ev->data.note.velocity, ev->data.control.channel);
277 }
278 else {
279 pMidiInputPort->DispatchNoteOff(ev->data.note.note, 0, ev->data.control.channel);
280 }
281 break;
282
283 case SND_SEQ_EVENT_NOTEOFF:
284 pMidiInputPort->DispatchNoteOff(ev->data.note.note, ev->data.note.velocity, ev->data.control.channel);
285 break;
286
287 case SND_SEQ_EVENT_SYSEX:
288 pMidiInputPort->DispatchSysex(ev->data.ext.ptr, ev->data.ext.len);
289 break;
290
291 case SND_SEQ_EVENT_PGMCHANGE:
292 pMidiInputPort->DispatchProgramChange(ev->data.control.value, ev->data.control.channel);
293 break;
294 }
295 snd_seq_free_event(ev);
296 } while (snd_seq_event_input_pending(hAlsaSeq, 0) > 0);
297 }
298 }
299 // just to avoid a compiler warning
300 return EXIT_FAILURE;
301 }
302
303 } // namespace LinuxSampler

  ViewVC Help
Powered by ViewVC