/[svn]/linuxsampler/trunk/src/network/lscpserver.cpp
ViewVC logotype

Annotation of /linuxsampler/trunk/src/network/lscpserver.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 184 - (hide annotations) (download)
Wed Jul 7 02:00:37 2004 UTC (19 years, 8 months ago) by senkov
File size: 53140 byte(s)
* Added MISCELLANEOUS event to help debugging client/server
interaction. It spits out every line received by the server.

1 schoenebeck 35 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 schoenebeck 56 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 35 * *
7     * This program is free software; you can redistribute it and/or modify *
8     * it under the terms of the GNU General Public License as published by *
9     * the Free Software Foundation; either version 2 of the License, or *
10     * (at your option) any later version. *
11     * *
12     * This program is distributed in the hope that it will be useful, *
13     * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15     * GNU General Public License for more details. *
16     * *
17     * You should have received a copy of the GNU General Public License *
18     * along with this program; if not, write to the Free Software *
19     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20     * MA 02111-1307 USA *
21     ***************************************************************************/
22    
23     #include "lscpserver.h"
24 senkov 113 #include "lscpresultset.h"
25 senkov 170 #include "lscpevent.h"
26 schoenebeck 35
27 schoenebeck 53 #include "../engines/gig/Engine.h"
28 schoenebeck 123 #include "../audiodriver/AudioOutputDeviceFactory.h"
29 senkov 155 #include "../mididriver/MidiInputDeviceFactory.h"
30 schoenebeck 53
31 senkov 170 /**
32     * Below are a few static members of the LSCPServer class.
33     * The big assumption here is that LSCPServer is going to remain a singleton.
34     * These members are used to support client connections.
35     * Class handles multiple connections at the same time using select() and non-blocking recv()
36     * Commands are processed by a single LSCPServer thread.
37     * Notifications are delivered either by the thread that originated them
38     * or (if the resultset is currently in progress) by the LSCPServer thread
39     * after the resultset was sent out.
40     * This makes sure that resultsets can not be interrupted by notifications.
41     * This also makes sure that the thread sending notification is not blocked
42     * by the LSCPServer thread.
43     */
44     fd_set LSCPServer::fdSet;
45     int LSCPServer::currentSocket = -1;
46     std::vector<int> LSCPServer::hSessions = std::vector<int>();
47     std::map<int,String> LSCPServer::bufferedNotifies = std::map<int,String>();
48     std::map<int,String> LSCPServer::bufferedCommands = std::map<int,String>();
49     std::map< LSCPEvent::event_t, std::list<int> > LSCPServer::eventSubscriptions = std::map< LSCPEvent::event_t, std::list<int> >();
50     Mutex LSCPServer::NotifyMutex = Mutex();
51     Mutex LSCPServer::NotifyBufferMutex = Mutex();
52     Mutex LSCPServer::SubscriptionMutex = Mutex();
53    
54 schoenebeck 53 LSCPServer::LSCPServer(Sampler* pSampler) : Thread(false, 0, -4) {
55     this->pSampler = pSampler;
56 senkov 170 LSCPEvent::RegisterEvent(LSCPEvent::event_channels, "CHANNELS");
57     LSCPEvent::RegisterEvent(LSCPEvent::event_voice_count, "VOICE_COUNT");
58     LSCPEvent::RegisterEvent(LSCPEvent::event_stream_count, "STREAM_COUNT");
59     LSCPEvent::RegisterEvent(LSCPEvent::event_buffer_fill, "BUFFER_FILL");
60     LSCPEvent::RegisterEvent(LSCPEvent::event_info, "INFO");
61     LSCPEvent::RegisterEvent(LSCPEvent::event_misc, "MISCELLANEOUS");
62 schoenebeck 35 }
63    
64     int LSCPServer::Main() {
65 senkov 170 int hSocket = socket(AF_INET, SOCK_STREAM, 0);
66 schoenebeck 35 if (hSocket < 0) {
67     std::cerr << "LSCPServer: Could not create server socket." << std::endl;
68 schoenebeck 53 //return -1;
69     exit(EXIT_FAILURE);
70 schoenebeck 35 }
71    
72     SocketAddress.sin_family = AF_INET;
73     SocketAddress.sin_port = htons(LSCP_PORT);
74     SocketAddress.sin_addr.s_addr = htonl(INADDR_ANY);
75    
76     if (bind(hSocket, (sockaddr*) &SocketAddress, sizeof(sockaddr_in)) < 0) {
77     std::cerr << "LSCPServer: Could not bind server socket." << std::endl;
78     close(hSocket);
79 schoenebeck 53 //return -1;
80     exit(EXIT_FAILURE);
81 schoenebeck 35 }
82    
83     listen(hSocket, 1);
84     dmsg(1,("LSCPServer: Server running.\n")); // server running
85    
86     // now wait for client connections and handle their requests
87     sockaddr_in client;
88     int length = sizeof(client);
89 senkov 170 struct timeval tv;
90     tv.tv_sec = 30;
91     tv.tv_usec = 0;
92     FD_ZERO(&fdSet);
93     FD_SET(hSocket, &fdSet);
94     int maxSessions = hSocket;
95    
96     // Parser initialization
97     yyparse_param_t yyparse_param;
98     yyparse_param.pServer = this;
99    
100 schoenebeck 35 while (true) {
101 senkov 170 fd_set selectSet = fdSet;
102     int retval = select(maxSessions+1, &selectSet, NULL, NULL, &tv);
103     if (retval == 0)
104     continue; //Nothing in 30 seconds, try again
105     if (retval == -1) {
106     std::cerr << "LSCPServer: Socket select error." << std::endl;
107     close(hSocket);
108     exit(EXIT_FAILURE);
109     }
110    
111     //Accept new connections now (if any)
112     if (FD_ISSET(hSocket, &selectSet)) {
113     int socket = accept(hSocket, (sockaddr*) &client, (socklen_t*) &length);
114     if (socket < 0) {
115     std::cerr << "LSCPServer: Client connection failed." << std::endl;
116     exit(EXIT_FAILURE);
117     }
118 schoenebeck 35
119 senkov 170 if (fcntl(socket, F_SETFL, O_NONBLOCK)) {
120     std::cerr << "LSCPServer: F_SETFL O_NONBLOCK failed." << std::endl;
121     exit(EXIT_FAILURE);
122     }
123 schoenebeck 35
124 senkov 170 hSessions.push_back(socket);
125     FD_SET(socket, &fdSet);
126     if (socket > maxSessions)
127     maxSessions = socket;
128     dmsg(1,("LSCPServer: Client connection established on socket:%d.\n", socket));
129     LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_misc, "Client connection established on socket", socket));
130     continue; //Maybe this was the only selected socket, better select again
131     }
132 schoenebeck 35
133 senkov 170 //Something was selected and it was not the hSocket, so it must be some command(s) coming.
134     for (std::vector<int>::iterator iter = hSessions.begin(); iter != hSessions.end(); iter++) {
135     if (FD_ISSET(*iter, &selectSet)) { //Was it this socket?
136     if (GetLSCPCommand(iter)) { //Have we read the entire command?
137     dmsg(3,("LSCPServer: Got command on socket %d, calling parser.\n", currentSocket));
138     yylex_init(&yyparse_param.pScanner);
139     currentSocket = *iter; //a hack
140     int result = yyparse(&yyparse_param);
141     currentSocket = -1; //continuation of a hack
142     dmsg(3,("LSCPServer: Done parsing on socket %d.\n", currentSocket));
143     if (result == LSCP_QUIT) { //Was it a quit command by any chance?
144     CloseConnection(iter);
145     }
146     }
147     //socket may have been closed, iter may be invalid, get out of the loop for now.
148     //we'll be back if there is data.
149     break;
150     }
151     }
152    
153     //Now let's deliver late notifies (if any)
154     NotifyBufferMutex.Lock();
155     for (std::map<int,String>::iterator iterNotify = bufferedNotifies.begin(); iterNotify != bufferedNotifies.end(); iterNotify++) {
156     send(iterNotify->first, iterNotify->second.c_str(), iterNotify->second.size(), 0);
157     bufferedNotifies.erase(iterNotify);
158     }
159     NotifyBufferMutex.Unlock();
160 schoenebeck 35 }
161 senkov 170 //It will never get here anyway
162     //yylex_destroy(yyparse_param.pScanner);
163 schoenebeck 35 }
164    
165 senkov 170 void LSCPServer::CloseConnection( std::vector<int>::iterator iter ) {
166     int socket = *iter;
167     dmsg(1,("LSCPServer: Client connection terminated on socket:%d.\n",socket));
168     LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_misc, "Client connection terminated on socket", socket));
169     hSessions.erase(iter);
170     FD_CLR(socket, &fdSet);
171     SubscriptionMutex.Lock(); //Must unsubscribe this socket from all events (if any)
172     for (std::map< LSCPEvent::event_t, std::list<int> >::iterator iter = eventSubscriptions.begin(); iter != eventSubscriptions.end(); iter++) {
173     iter->second.remove(socket);
174     }
175     SubscriptionMutex.Unlock();
176     NotifyMutex.Lock();
177     bufferedCommands.erase(socket);
178     bufferedNotifies.erase(socket);
179     close(socket);
180     NotifyMutex.Unlock();
181     }
182    
183     void LSCPServer::SendLSCPNotify( LSCPEvent event ) {
184     SubscriptionMutex.Lock();
185     if (eventSubscriptions.count(event.GetType()) == 0) {
186     SubscriptionMutex.Unlock(); //Nobody is subscribed to this event
187     return;
188     }
189     std::list<int>::iterator iter = eventSubscriptions[event.GetType()].begin();
190     std::list<int>::iterator end = eventSubscriptions[event.GetType()].end();
191     String notify = event.Produce();
192    
193     while (true) {
194     if (NotifyMutex.Trylock()) {
195     for(;iter != end; iter++)
196     send(*iter, notify.c_str(), notify.size(), 0);
197     NotifyMutex.Unlock();
198     break;
199     } else {
200     if (NotifyBufferMutex.Trylock()) {
201     for(;iter != end; iter++)
202     bufferedNotifies[*iter] += notify;
203     NotifyBufferMutex.Unlock();
204     break;
205     }
206     }
207     }
208     SubscriptionMutex.Unlock();
209     }
210    
211     extern int GetLSCPCommand( void *buf, int max_size ) {
212     String command = LSCPServer::bufferedCommands[LSCPServer::currentSocket];
213     if (command.size() == 0) { //Parser wants input but we have nothing.
214     strcpy((char*) buf, "\n"); //So give it an empty command
215     return 1; //to keep it happy.
216     }
217    
218     if (max_size < command.size()) {
219     std::cerr << "getLSCPCommand: Flex buffer too small, ignoring the command." << std::endl;
220     return 0; //This will never happen
221     }
222    
223     strcpy((char*) buf, command.c_str());
224     LSCPServer::bufferedCommands.erase(LSCPServer::currentSocket);
225     return command.size();
226     }
227    
228 schoenebeck 35 /**
229 senkov 170 * Will be called to try to read the command from the socket
230     * If command is read, it will return true. Otherwise false is returned.
231     * In any case the received portion (complete or incomplete) is saved into bufferedCommand map.
232     */
233     bool LSCPServer::GetLSCPCommand( std::vector<int>::iterator iter ) {
234     int socket = *iter;
235     char c;
236     int i = 0;
237     while (true) {
238     int result = recv(socket, (void *)&c, 1, 0); //Read one character at a time for now
239     if (result == 0) { //socket was selected, so 0 here means client has closed the connection
240     CloseConnection(iter);
241     break;
242     }
243     if (result == 1) {
244     if (c == '\r')
245     continue; //Ignore CR
246     if (c == '\n') {
247 senkov 184 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_misc, "Received \'" + bufferedCommands[socket] + "\' on socket", socket));
248 senkov 170 bufferedCommands[socket] += "\n";
249     return true; //Complete command was read
250     }
251     bufferedCommands[socket] += c;
252     }
253     if (result == -1) {
254     if (errno == EAGAIN) //Would block, try again later.
255     return false;
256     switch(errno) {
257     case EBADF:
258     dmsg(2,("LSCPScanner: The argument s is an invalid descriptor.\n"));
259     break;
260     case ECONNREFUSED:
261     dmsg(2,("LSCPScanner: A remote host refused to allow the network connection (typically because it is not running the requested service).\n"));
262     break;
263     case ENOTCONN:
264     dmsg(2,("LSCPScanner: The socket is associated with a connection-oriented protocol and has not been connected (see connect(2) and accept(2)).\n"));
265     break;
266     case ENOTSOCK:
267     dmsg(2,("LSCPScanner: The argument s does not refer to a socket.\n"));
268     break;
269     case EAGAIN:
270     dmsg(2,("LSCPScanner: The socket is marked non-blocking and the receive operation would block, or a receive timeout had been set and the timeout expired before data was received.\n"));
271     break;
272     case EINTR:
273     dmsg(2,("LSCPScanner: The receive was interrupted by delivery of a signal before any data were available.\n"));
274     break;
275     case EFAULT:
276     dmsg(2,("LSCPScanner: The receive buffer pointer(s) point outside the process's address space.\n"));
277     break;
278     case EINVAL:
279     dmsg(2,("LSCPScanner: Invalid argument passed.\n"));
280     break;
281     case ENOMEM:
282     dmsg(2,("LSCPScanner: Could not allocate memory for recvmsg.\n"));
283     break;
284     default:
285     dmsg(2,("LSCPScanner: Unknown recv() error.\n"));
286     break;
287     }
288     CloseConnection(iter);
289     break;
290     }
291     }
292     return false;
293     }
294    
295     /**
296 schoenebeck 35 * Will be called by the parser whenever it wants to send an answer to the
297     * client / frontend.
298     *
299     * @param ReturnMessage - message that will be send to the client
300     */
301     void LSCPServer::AnswerClient(String ReturnMessage) {
302     dmsg(2,("LSCPServer::AnswerClient(ReturnMessage=%s)", ReturnMessage.c_str()));
303 senkov 170 if (currentSocket != -1) {
304     NotifyMutex.Lock();
305     send(currentSocket, ReturnMessage.c_str(), ReturnMessage.size(), 0);
306     NotifyMutex.Unlock();
307     }
308 schoenebeck 35 }
309    
310 capela 143 /**
311     * Find a created audio output device index.
312     */
313     int LSCPServer::GetAudioOutputDeviceIndex ( AudioOutputDevice *pDevice )
314     {
315     // Search for the created device to get its index
316     std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
317     std::map<uint, AudioOutputDevice*>::iterator iter = devices.begin();
318     for (; iter != devices.end(); iter++) {
319     if (iter->second == pDevice)
320     return iter->first;
321     }
322     // Not found.
323     return -1;
324     }
325    
326 senkov 155 /**
327     * Find a created midi input device index.
328     */
329     int LSCPServer::GetMidiInputDeviceIndex ( MidiInputDevice *pDevice )
330     {
331     // Search for the created device to get its index
332     std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
333     std::map<uint, MidiInputDevice*>::iterator iter = devices.begin();
334     for (; iter != devices.end(); iter++) {
335     if (iter->second == pDevice)
336     return iter->first;
337     }
338     // Not found.
339     return -1;
340     }
341    
342 schoenebeck 123 String LSCPServer::CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters) {
343     dmsg(2,("LSCPServer: CreateAudioOutputDevice(Driver=%s)\n", Driver.c_str()));
344     LSCPResultSet result;
345     try {
346     AudioOutputDevice* pDevice = pSampler->CreateAudioOutputDevice(Driver, Parameters);
347     // search for the created device to get its index
348 capela 143 int index = GetAudioOutputDeviceIndex(pDevice);
349 schoenebeck 123 if (index == -1) throw LinuxSamplerException("Internal error: could not find created audio output device.");
350     result = index; // success
351     }
352     catch (LinuxSamplerException e) {
353     result.Error(e);
354     }
355     return result.Produce();
356     }
357    
358 senkov 155 String LSCPServer::CreateMidiInputDevice(String Driver, std::map<String,String> Parameters) {
359     dmsg(2,("LSCPServer: CreateMidiInputDevice(Driver=%s)\n", Driver.c_str()));
360     LSCPResultSet result;
361     try {
362     MidiInputDevice* pDevice = pSampler->CreateMidiInputDevice(Driver, Parameters);
363     // search for the created device to get its index
364     int index = GetMidiInputDeviceIndex(pDevice);
365     if (index == -1) throw LinuxSamplerException("Internal error: could not find created midi input device.");
366     result = index; // success
367     }
368     catch (LinuxSamplerException e) {
369     result.Error(e);
370     }
371     return result.Produce();
372     }
373    
374 schoenebeck 123 String LSCPServer::DestroyAudioOutputDevice(uint DeviceIndex) {
375     dmsg(2,("LSCPServer: DestroyAudioOutputDevice(DeviceIndex=%d)\n", DeviceIndex));
376     LSCPResultSet result;
377     try {
378     std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
379     if (!devices[DeviceIndex]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceIndex) + ".");
380     AudioOutputDevice* pDevice = devices[DeviceIndex];
381     pSampler->DestroyAudioOutputDevice(pDevice);
382     }
383     catch (LinuxSamplerException e) {
384     result.Error(e);
385     }
386     return result.Produce();
387     }
388    
389 senkov 155 String LSCPServer::DestroyMidiInputDevice(uint DeviceIndex) {
390     dmsg(2,("LSCPServer: DestroyMidiInputDevice(DeviceIndex=%d)\n", DeviceIndex));
391     LSCPResultSet result;
392     try {
393     std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
394     MidiInputDevice* pDevice = devices[DeviceIndex];
395     if (!pDevice) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceIndex) + ".");
396     pSampler->DestroyMidiInputDevice(pDevice);
397     }
398     catch (LinuxSamplerException e) {
399     result.Error(e);
400     }
401     return result.Produce();
402     }
403    
404 schoenebeck 35 /**
405     * Will be called by the parser to load an instrument.
406     */
407 capela 137 String LSCPServer::LoadInstrument(String Filename, uint uiInstrument, uint uiSamplerChannel, bool bBackground) {
408 schoenebeck 53 dmsg(2,("LSCPServer: LoadInstrument(Filename=%s,Instrument=%d,SamplerChannel=%d)\n", Filename.c_str(), uiInstrument, uiSamplerChannel));
409 senkov 120 LSCPResultSet result;
410 schoenebeck 53 try {
411     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
412     if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
413     Engine* pEngine = pSamplerChannel->GetEngine();
414     if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
415 capela 143 if (pSamplerChannel->GetAudioOutputDevice() == NULL)
416     throw LinuxSamplerException("No audio output device on channel");
417 capela 137 if (bBackground) {
418     LSCPLoadInstrument *pLoadInstrument = new LSCPLoadInstrument(pEngine, Filename.c_str(), uiInstrument);
419     pLoadInstrument->StartThread();
420     }
421     else pEngine->LoadInstrument(Filename.c_str(), uiInstrument);
422 schoenebeck 53 }
423     catch (LinuxSamplerException e) {
424 senkov 120 result.Error(e);
425 schoenebeck 53 }
426 senkov 120 return result.Produce();
427 schoenebeck 35 }
428    
429     /**
430     * Will be called by the parser to load and deploy an engine.
431     */
432 schoenebeck 53 String LSCPServer::LoadEngine(String EngineName, uint uiSamplerChannel) {
433     dmsg(2,("LSCPServer: LoadEngine(EngineName=%s,SamplerChannel=%d)\n", EngineName.c_str(), uiSamplerChannel));
434 senkov 120 LSCPResultSet result;
435 schoenebeck 53 try {
436 schoenebeck 64 Engine::type_t type;
437 senkov 120 if ((EngineName == "GigEngine") || (EngineName == "gig")) type = Engine::type_gig;
438 schoenebeck 53 else throw LinuxSamplerException("Unknown engine type");
439     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
440     if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
441     pSamplerChannel->LoadEngine(type);
442     }
443     catch (LinuxSamplerException e) {
444 senkov 120 result.Error(e);
445 schoenebeck 53 }
446 senkov 120 return result.Produce();
447 schoenebeck 35 }
448    
449     /**
450     * Will be called by the parser to get the amount of sampler channels.
451     */
452     String LSCPServer::GetChannels() {
453     dmsg(2,("LSCPServer: GetChannels()\n"));
454 senkov 120 LSCPResultSet result;
455     result.Add(pSampler->SamplerChannels());
456     return result.Produce();
457 schoenebeck 35 }
458    
459     /**
460     * Will be called by the parser to add a sampler channel.
461     */
462     String LSCPServer::AddChannel() {
463     dmsg(2,("LSCPServer: AddChannel()\n"));
464 schoenebeck 53 SamplerChannel* pSamplerChannel = pSampler->AddSamplerChannel();
465 senkov 120 LSCPResultSet result(pSamplerChannel->Index());
466     return result.Produce();
467 schoenebeck 35 }
468    
469     /**
470     * Will be called by the parser to remove a sampler channel.
471     */
472 schoenebeck 53 String LSCPServer::RemoveChannel(uint uiSamplerChannel) {
473     dmsg(2,("LSCPServer: RemoveChannel(SamplerChannel=%d)\n", uiSamplerChannel));
474 senkov 120 LSCPResultSet result;
475 schoenebeck 53 pSampler->RemoveSamplerChannel(uiSamplerChannel);
476 senkov 120 return result.Produce();
477 schoenebeck 35 }
478    
479     /**
480     * Will be called by the parser to get all available engines.
481     */
482     String LSCPServer::GetAvailableEngines() {
483     dmsg(2,("LSCPServer: GetAvailableEngines()\n"));
484 senkov 120 LSCPResultSet result("GigEngine");
485     return result.Produce();
486 schoenebeck 35 }
487    
488     /**
489     * Will be called by the parser to get descriptions for a particular engine.
490     */
491     String LSCPServer::GetEngineInfo(String EngineName) {
492     dmsg(2,("LSCPServer: GetEngineInfo(EngineName=%s)\n", EngineName.c_str()));
493 senkov 120 LSCPResultSet result;
494 schoenebeck 53 try {
495 senkov 120 if ((EngineName == "GigEngine") || (EngineName == "gig")) {
496 schoenebeck 53 Engine* pEngine = new LinuxSampler::gig::Engine;
497 senkov 120 result.Add(pEngine->Description());
498 schoenebeck 123 result.Add(pEngine->Version());
499 schoenebeck 53 delete pEngine;
500     }
501     else throw LinuxSamplerException("Unknown engine type");
502     }
503     catch (LinuxSamplerException e) {
504 senkov 120 result.Error(e);
505 schoenebeck 53 }
506 senkov 120 return result.Produce();
507 schoenebeck 35 }
508    
509     /**
510     * Will be called by the parser to get informations about a particular
511     * sampler channel.
512     */
513 schoenebeck 53 String LSCPServer::GetChannelInfo(uint uiSamplerChannel) {
514     dmsg(2,("LSCPServer: GetChannelInfo(SamplerChannel=%d)\n", uiSamplerChannel));
515 senkov 120 LSCPResultSet result;
516 senkov 113 try {
517     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
518     if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
519     Engine* pEngine = pSamplerChannel->GetEngine();
520 schoenebeck 123
521 senkov 117 //Defaults values
522     String EngineName = "NONE";
523     float Volume = 0;
524     String InstrumentFileName = "NONE";
525 capela 133 int InstrumentIndex = -1;
526     int InstrumentStatus = -1;
527 schoenebeck 123
528 senkov 113 if (pEngine) {
529 senkov 117 EngineName = pEngine->EngineName();
530     Volume = pEngine->Volume();
531 capela 133 InstrumentStatus = pEngine->InstrumentStatus();
532     InstrumentIndex = pEngine->InstrumentIndex();
533     if (InstrumentIndex != -1)
534 senkov 117 InstrumentFileName = pEngine->InstrumentFileName();
535 senkov 113 }
536 senkov 117
537     result.Add("ENGINE_NAME", EngineName);
538     result.Add("VOLUME", Volume);
539    
540 capela 143 //Some not-so-hardcoded stuff to make GUI look good
541     result.Add("AUDIO_OUTPUT_DEVICE", GetAudioOutputDeviceIndex(pSamplerChannel->GetAudioOutputDevice()));
542 senkov 113 result.Add("AUDIO_OUTPUT_CHANNELS", "2");
543     result.Add("AUDIO_OUTPUT_ROUTING", "0,1");
544    
545 capela 159 result.Add("MIDI_INPUT_DEVICE", GetMidiInputDeviceIndex(pSamplerChannel->GetMidiInputDevice()));
546     result.Add("MIDI_INPUT_PORT", pSamplerChannel->GetMidiInputPort());
547     result.Add("MIDI_INPUT_CHANNEL", pSamplerChannel->GetMidiInputChannel());
548    
549 senkov 117 result.Add("INSTRUMENT_FILE", InstrumentFileName);
550     result.Add("INSTRUMENT_NR", InstrumentIndex);
551 capela 133 result.Add("INSTRUMENT_STATUS", InstrumentStatus);
552 senkov 113 }
553     catch (LinuxSamplerException e) {
554 senkov 120 result.Error(e);
555 senkov 113 }
556 senkov 120 return result.Produce();
557 schoenebeck 35 }
558    
559     /**
560     * Will be called by the parser to get the amount of active voices on a
561     * particular sampler channel.
562     */
563 schoenebeck 53 String LSCPServer::GetVoiceCount(uint uiSamplerChannel) {
564     dmsg(2,("LSCPServer: GetVoiceCount(SamplerChannel=%d)\n", uiSamplerChannel));
565 senkov 120 LSCPResultSet result;
566 schoenebeck 53 try {
567     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
568     if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
569     Engine* pEngine = pSamplerChannel->GetEngine();
570     if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
571 senkov 120 result.Add(pEngine->VoiceCount());
572 schoenebeck 53 }
573     catch (LinuxSamplerException e) {
574 senkov 120 result.Error(e);
575 schoenebeck 53 }
576 senkov 120 return result.Produce();
577 schoenebeck 35 }
578    
579     /**
580     * Will be called by the parser to get the amount of active disk streams on a
581     * particular sampler channel.
582     */
583 schoenebeck 53 String LSCPServer::GetStreamCount(uint uiSamplerChannel) {
584     dmsg(2,("LSCPServer: GetStreamCount(SamplerChannel=%d)\n", uiSamplerChannel));
585 senkov 120 LSCPResultSet result;
586 schoenebeck 53 try {
587     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
588     if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
589     Engine* pEngine = pSamplerChannel->GetEngine();
590     if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
591 senkov 120 result.Add(pEngine->DiskStreamCount());
592 schoenebeck 53 }
593     catch (LinuxSamplerException e) {
594 senkov 120 result.Error(e);
595 schoenebeck 53 }
596 senkov 120 return result.Produce();
597 schoenebeck 35 }
598    
599     /**
600     * Will be called by the parser to get the buffer fill states of all disk
601     * streams on a particular sampler channel.
602     */
603 schoenebeck 53 String LSCPServer::GetBufferFill(fill_response_t ResponseType, uint uiSamplerChannel) {
604     dmsg(2,("LSCPServer: GetBufferFill(ResponseType=%d, SamplerChannel=%d)\n", ResponseType, uiSamplerChannel));
605 senkov 120 LSCPResultSet result;
606 schoenebeck 53 try {
607     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
608     if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
609     Engine* pEngine = pSamplerChannel->GetEngine();
610     if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
611 senkov 129 if (!pEngine->DiskStreamSupported())
612     result.Add("NA");
613     else {
614     switch (ResponseType) {
615     case fill_response_bytes:
616     result.Add(pEngine->DiskStreamBufferFillBytes());
617     break;
618     case fill_response_percentage:
619     result.Add(pEngine->DiskStreamBufferFillPercentage());
620     break;
621     default:
622     throw LinuxSamplerException("Unknown fill response type");
623     }
624     }
625 schoenebeck 53 }
626     catch (LinuxSamplerException e) {
627 senkov 120 result.Error(e);
628 schoenebeck 53 }
629 senkov 120 return result.Produce();
630 schoenebeck 35 }
631    
632 schoenebeck 123 String LSCPServer::GetAvailableAudioOutputDrivers() {
633     dmsg(2,("LSCPServer: GetAvailableAudioOutputDrivers()\n"));
634 senkov 120 LSCPResultSet result;
635 schoenebeck 53 try {
636 schoenebeck 123 String s = AudioOutputDeviceFactory::AvailableDriversAsString();
637     result.Add(s);
638 schoenebeck 53 }
639     catch (LinuxSamplerException e) {
640 schoenebeck 123 result.Error(e);
641 schoenebeck 53 }
642 senkov 120 return result.Produce();
643 schoenebeck 35 }
644    
645 senkov 155 String LSCPServer::GetAvailableMidiInputDrivers() {
646     dmsg(2,("LSCPServer: GetAvailableMidiInputDrivers()\n"));
647     LSCPResultSet result;
648     try {
649     String s = MidiInputDeviceFactory::AvailableDriversAsString();
650     result.Add(s);
651     }
652     catch (LinuxSamplerException e) {
653     result.Error(e);
654     }
655     return result.Produce();
656     }
657    
658     String LSCPServer::GetMidiInputDriverInfo(String Driver) {
659     dmsg(2,("LSCPServer: GetMidiInputDriverInfo(Driver=%s)\n",Driver.c_str()));
660     LSCPResultSet result;
661     try {
662     result.Add("DESCRIPTION", MidiInputDeviceFactory::GetDriverDescription(Driver));
663     result.Add("VERSION", MidiInputDeviceFactory::GetDriverVersion(Driver));
664    
665     std::map<String,DeviceCreationParameter*> parameters = MidiInputDeviceFactory::GetAvailableDriverParameters(Driver);
666     if (parameters.size()) { // if there are parameters defined for this driver
667     String s;
668     std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
669     for (;iter != parameters.end(); iter++) {
670     if (s != "") s += ",";
671     s += iter->first;
672     }
673     result.Add("PARAMETERS", s);
674     }
675     }
676     catch (LinuxSamplerException e) {
677     result.Error(e);
678     }
679     return result.Produce();
680     }
681    
682 schoenebeck 123 String LSCPServer::GetAudioOutputDriverInfo(String Driver) {
683     dmsg(2,("LSCPServer: GetAudioOutputDriverInfo(Driver=%s)\n",Driver.c_str()));
684     LSCPResultSet result;
685     try {
686     result.Add("DESCRIPTION", AudioOutputDeviceFactory::GetDriverDescription(Driver));
687     result.Add("VERSION", AudioOutputDeviceFactory::GetDriverVersion(Driver));
688    
689     std::map<String,DeviceCreationParameter*> parameters = AudioOutputDeviceFactory::GetAvailableDriverParameters(Driver);
690     if (parameters.size()) { // if there are parameters defined for this driver
691     String s;
692     std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
693     for (;iter != parameters.end(); iter++) {
694     if (s != "") s += ",";
695     s += iter->first;
696     }
697     result.Add("PARAMETERS", s);
698     }
699     }
700     catch (LinuxSamplerException e) {
701     result.Error(e);
702     }
703     return result.Produce();
704     }
705    
706 senkov 155 String LSCPServer::GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList) {
707     dmsg(2,("LSCPServer: GetMidiInputDriverParameterInfo(Driver=%s,Parameter=%s)\n",Driver.c_str(),Parameter.c_str()));
708     LSCPResultSet result;
709     try {
710     DeviceCreationParameter* pParameter = MidiInputDeviceFactory::GetDriverParameter(Driver, Parameter);
711     result.Add("TYPE", pParameter->Type());
712     result.Add("DESCRIPTION", pParameter->Description());
713     result.Add("MANDATORY", pParameter->Mandatory());
714     result.Add("FIX", pParameter->Fix());
715     result.Add("MULTIPLICITY", pParameter->Multiplicity());
716     if (pParameter->Depends()) result.Add("DEPENDS", pParameter->Depends());
717     if (pParameter->Default()) result.Add("DEFAULT", pParameter->Default());
718     if (pParameter->RangeMin()) result.Add("RANGE_MIN", pParameter->RangeMin());
719     if (pParameter->RangeMax()) result.Add("RANGE_MAX", pParameter->RangeMax());
720     if (pParameter->Possibilities()) result.Add("POSSIBILITIES", pParameter->Possibilities());
721     }
722     catch (LinuxSamplerException e) {
723     result.Error(e);
724     }
725     return result.Produce();
726     }
727    
728 schoenebeck 123 String LSCPServer::GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList) {
729     dmsg(2,("LSCPServer: GetAudioOutputDriverParameterInfo(Driver=%s,Parameter=%s)\n",Driver.c_str(),Parameter.c_str()));
730     LSCPResultSet result;
731     try {
732     DeviceCreationParameter* pParameter = AudioOutputDeviceFactory::GetDriverParameter(Driver, Parameter);
733     result.Add("TYPE", pParameter->Type());
734     result.Add("DESCRIPTION", pParameter->Description());
735     result.Add("MANDATORY", pParameter->Mandatory());
736     result.Add("FIX", pParameter->Fix());
737     result.Add("MULTIPLICITY", pParameter->Multiplicity());
738     if (pParameter->Depends()) result.Add("DEPENDS", pParameter->Depends());
739     if (pParameter->Default()) result.Add("DEFAULT", pParameter->Default());
740     if (pParameter->RangeMin()) result.Add("RANGE_MIN", pParameter->RangeMin());
741     if (pParameter->RangeMax()) result.Add("RANGE_MAX", pParameter->RangeMax());
742     if (pParameter->Possibilities()) result.Add("POSSIBILITIES", pParameter->Possibilities());
743     }
744     catch (LinuxSamplerException e) {
745     result.Error(e);
746     }
747     return result.Produce();
748     }
749    
750     String LSCPServer::GetAudioOutputDeviceCount() {
751     dmsg(2,("LSCPServer: GetAudioOutputDeviceCount()\n"));
752     LSCPResultSet result;
753     try {
754     uint count = pSampler->AudioOutputDevices();
755 senkov 138 result.Add(count); // success
756 schoenebeck 123 }
757     catch (LinuxSamplerException e) {
758     result.Error(e);
759     }
760     return result.Produce();
761     }
762    
763 senkov 155 String LSCPServer::GetMidiInputDeviceCount() {
764     dmsg(2,("LSCPServer: GetMidiInputDeviceCount()\n"));
765     LSCPResultSet result;
766     try {
767     uint count = pSampler->MidiInputDevices();
768     result.Add(count); // success
769     }
770     catch (LinuxSamplerException e) {
771     result.Error(e);
772     }
773     return result.Produce();
774     }
775    
776 schoenebeck 123 String LSCPServer::GetAudioOutputDevices() {
777     dmsg(2,("LSCPServer: GetAudioOutputDevices()\n"));
778     LSCPResultSet result;
779     try {
780     String s;
781     std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
782     std::map<uint, AudioOutputDevice*>::iterator iter = devices.begin();
783     for (; iter != devices.end(); iter++) {
784     if (s != "") s += ",";
785     s += ToString(iter->first);
786     }
787     result.Add(s);
788     }
789     catch (LinuxSamplerException e) {
790     result.Error(e);
791     }
792     return result.Produce();
793     }
794    
795 senkov 155 String LSCPServer::GetMidiInputDevices() {
796     dmsg(2,("LSCPServer: GetMidiInputDevices()\n"));
797     LSCPResultSet result;
798     try {
799     String s;
800     std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
801     std::map<uint, MidiInputDevice*>::iterator iter = devices.begin();
802     for (; iter != devices.end(); iter++) {
803     if (s != "") s += ",";
804     s += ToString(iter->first);
805     }
806     result.Add(s);
807     }
808     catch (LinuxSamplerException e) {
809     result.Error(e);
810     }
811     return result.Produce();
812     }
813    
814 schoenebeck 123 String LSCPServer::GetAudioOutputDeviceInfo(uint DeviceIndex) {
815     dmsg(2,("LSCPServer: GetAudioOutputDeviceInfo(DeviceIndex=%d)\n",DeviceIndex));
816     LSCPResultSet result;
817     try {
818     std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
819     if (!devices[DeviceIndex]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceIndex) + ".");
820     AudioOutputDevice* pDevice = devices[DeviceIndex];
821 capela 143 result.Add("driver", pDevice->Driver());
822 schoenebeck 123 std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
823     std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
824     for (; iter != parameters.end(); iter++) {
825     result.Add(iter->first, iter->second->Value());
826     }
827     }
828     catch (LinuxSamplerException e) {
829     result.Error(e);
830     }
831     return result.Produce();
832     }
833    
834 senkov 155 String LSCPServer::GetMidiInputDeviceInfo(uint DeviceIndex) {
835     dmsg(2,("LSCPServer: GetMidiInputDeviceInfo(DeviceIndex=%d)\n",DeviceIndex));
836     LSCPResultSet result;
837     try {
838     std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
839     MidiInputDevice* pDevice = devices[DeviceIndex];
840 capela 159 if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
841 senkov 155 result.Add("driver", pDevice->Driver());
842     std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
843     std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
844     for (; iter != parameters.end(); iter++) {
845     result.Add(iter->first, iter->second->Value());
846     }
847     }
848     catch (LinuxSamplerException e) {
849     result.Error(e);
850     }
851     return result.Produce();
852     }
853     String LSCPServer::GetMidiInputPortInfo(uint DeviceIndex, uint PortIndex) {
854     dmsg(2,("LSCPServer: GetMidiInputPortInfo(DeviceIndex=%d, PortIndex=%d)\n",DeviceIndex, PortIndex));
855     LSCPResultSet result;
856     try {
857     std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
858     MidiInputDevice* pDevice = devices[DeviceIndex];
859 capela 159 if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
860 senkov 155 MidiInputDevice::MidiInputPort* pMidiInputPort = pDevice->GetPort(PortIndex);
861 capela 159 if (!pMidiInputPort) throw LinuxSamplerException("There is no MIDI input port with index " + ToString(PortIndex) + ".");
862 senkov 155 std::map<String,DeviceCreationParameter*> parameters = pMidiInputPort->DeviceParameters();
863     std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
864     for (; iter != parameters.end(); iter++) {
865     result.Add(iter->first, iter->second->Value());
866     }
867     }
868     catch (LinuxSamplerException e) {
869     result.Error(e);
870     }
871     return result.Produce();
872     }
873    
874 schoenebeck 123 String LSCPServer::GetAudioOutputChannelInfo(uint DeviceId, uint ChannelId) {
875     dmsg(2,("LSCPServer: GetAudioOutputChannelInfo(DeviceId=%d,ChannelId)\n",DeviceId,ChannelId));
876     LSCPResultSet result;
877     try {
878     // get audio output device
879     std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
880     if (!devices[DeviceId]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceId) + ".");
881     AudioOutputDevice* pDevice = devices[DeviceId];
882    
883     // get audio channel
884     AudioChannel* pChannel = pDevice->Channel(ChannelId);
885     if (!pChannel) throw LinuxSamplerException("Audio ouotput device does not have channel " + ToString(ChannelId) + ".");
886    
887     // return the values of all audio channel parameters
888     std::map<String,DeviceRuntimeParameter*> parameters = pChannel->ChannelParameters();
889     std::map<String,DeviceRuntimeParameter*>::iterator iter = parameters.begin();
890     for (; iter != parameters.end(); iter++) {
891     result.Add(iter->first, iter->second->Value());
892     }
893     }
894     catch (LinuxSamplerException e) {
895     result.Error(e);
896     }
897     return result.Produce();
898     }
899    
900     String LSCPServer::GetAudioOutputChannelParameterInfo(uint DeviceId, uint ChannelId, String ParameterName) {
901     dmsg(2,("LSCPServer: GetAudioOutputChannelParameterInfo(DeviceId=%d,ChannelId=%d,ParameterName=%s)\n",DeviceId,ChannelId,ParameterName.c_str()));
902     LSCPResultSet result;
903     try {
904     // get audio output device
905     std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
906     if (!devices[DeviceId]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceId) + ".");
907     AudioOutputDevice* pDevice = devices[DeviceId];
908    
909     // get audio channel
910     AudioChannel* pChannel = pDevice->Channel(ChannelId);
911     if (!pChannel) throw LinuxSamplerException("Audio output device does not have channel " + ToString(ChannelId) + ".");
912    
913     // get desired audio channel parameter
914     std::map<String,DeviceRuntimeParameter*> parameters = pChannel->ChannelParameters();
915     if (!parameters[ParameterName]) throw LinuxSamplerException("Audio channel does not provide a parameter '" + ParameterName + "'.");
916     DeviceRuntimeParameter* pParameter = parameters[ParameterName];
917    
918     // return all fields of this audio channel parameter
919     result.Add("TYPE", pParameter->Type());
920     result.Add("DESCRIPTION", pParameter->Description());
921     result.Add("FIX", pParameter->Fix());
922     result.Add("MULTIPLICITY", pParameter->Multiplicity());
923     if (pParameter->RangeMin()) result.Add("RANGE_MIN", pParameter->RangeMin());
924     if (pParameter->RangeMax()) result.Add("RANGE_MAX", pParameter->RangeMax());
925     if (pParameter->Possibilities()) result.Add("POSSIBILITIES", pParameter->Possibilities());
926     }
927     catch (LinuxSamplerException e) {
928     result.Error(e);
929     }
930     return result.Produce();
931     }
932    
933     String LSCPServer::SetAudioOutputChannelParameter(uint DeviceId, uint ChannelId, String ParamKey, String ParamVal) {
934     dmsg(2,("LSCPServer: SetAudioOutputChannelParameter(DeviceId=%d,ChannelId=%d,ParamKey=%s,ParamVal=%s)\n",DeviceId,ChannelId,ParamKey.c_str(),ParamVal.c_str()));
935     LSCPResultSet result;
936     try {
937     // get audio output device
938     std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
939     if (!devices[DeviceId]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceId) + ".");
940     AudioOutputDevice* pDevice = devices[DeviceId];
941    
942     // get audio channel
943     AudioChannel* pChannel = pDevice->Channel(ChannelId);
944     if (!pChannel) throw LinuxSamplerException("Audio output device does not have channel " + ToString(ChannelId) + ".");
945    
946     // get desired audio channel parameter
947     std::map<String,DeviceRuntimeParameter*> parameters = pChannel->ChannelParameters();
948     if (!parameters[ParamKey]) throw LinuxSamplerException("Audio channel does not provide a parameter '" + ParamKey + "'.");
949     DeviceRuntimeParameter* pParameter = parameters[ParamKey];
950    
951     // set new channel parameter value
952     pParameter->SetValue(ParamVal);
953     }
954     catch (LinuxSamplerException e) {
955     result.Error(e);
956     }
957     return result.Produce();
958     }
959    
960     String LSCPServer::SetAudioOutputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal) {
961     dmsg(2,("LSCPServer: SetAudioOutputDeviceParameter(DeviceIndex=%d,ParamKey=%s,ParamVal=%s)\n",DeviceIndex,ParamKey.c_str(),ParamVal.c_str()));
962     LSCPResultSet result;
963     try {
964     std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
965     if (!devices[DeviceIndex]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceIndex) + ".");
966     AudioOutputDevice* pDevice = devices[DeviceIndex];
967     std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
968     if (!parameters[ParamKey]) throw LinuxSamplerException("Audio output device " + ToString(DeviceIndex) + " does not have a device parameter '" + ParamKey + "'");
969     parameters[ParamKey]->SetValue(ParamVal);
970     }
971     catch (LinuxSamplerException e) {
972     result.Error(e);
973     }
974     return result.Produce();
975     }
976    
977 senkov 155 String LSCPServer::SetMidiInputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal) {
978     dmsg(2,("LSCPServer: SetMidiOutputDeviceParameter(DeviceIndex=%d,ParamKey=%s,ParamVal=%s)\n",DeviceIndex,ParamKey.c_str(),ParamVal.c_str()));
979     LSCPResultSet result;
980     try {
981     std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
982 capela 159 if (!devices[DeviceIndex]) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
983 senkov 155 MidiInputDevice* pDevice = devices[DeviceIndex];
984     std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
985 capela 159 if (!parameters[ParamKey]) throw LinuxSamplerException("MIDI input device " + ToString(DeviceIndex) + " does not have a device parameter '" + ParamKey + "'");
986 senkov 155 parameters[ParamKey]->SetValue(ParamVal);
987     }
988     catch (LinuxSamplerException e) {
989     result.Error(e);
990     }
991     return result.Produce();
992     }
993    
994     String LSCPServer::SetMidiInputPortParameter(uint DeviceIndex, uint PortIndex, String ParamKey, String ParamVal) {
995     dmsg(2,("LSCPServer: SetMidiOutputDeviceParameter(DeviceIndex=%d,ParamKey=%s,ParamVal=%s)\n",DeviceIndex,ParamKey.c_str(),ParamVal.c_str()));
996     LSCPResultSet result;
997     try {
998     std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
999     MidiInputDevice* pDevice = devices[DeviceIndex];
1000 capela 159 if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
1001 senkov 155 MidiInputDevice::MidiInputPort* pMidiInputPort = pDevice->GetPort(PortIndex);
1002 capela 159 if (!pMidiInputPort) throw LinuxSamplerException("There is no MIDI input port with index " + ToString(PortIndex) + ".");
1003 senkov 155 std::map<String,DeviceCreationParameter*> parameters = pMidiInputPort->DeviceParameters();
1004 capela 159 if (!parameters[ParamKey]) throw LinuxSamplerException("MIDI input device " + ToString(PortIndex) + " does not have a parameter '" + ParamKey + "'");
1005 senkov 155 parameters[ParamKey]->SetValue(ParamVal);
1006     }
1007     catch (LinuxSamplerException e) {
1008     result.Error(e);
1009     }
1010     return result.Produce();
1011     }
1012    
1013 schoenebeck 35 /**
1014     * Will be called by the parser to change the audio output channel for
1015     * playback on a particular sampler channel.
1016     */
1017 schoenebeck 123 String LSCPServer::SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel) {
1018     dmsg(2,("LSCPServer: SetAudioOutputChannel(ChannelAudioOutputChannel=%d, AudioOutputDeviceInputChannel=%d, SamplerChannel=%d)\n",ChannelAudioOutputChannel,AudioOutputDeviceInputChannel,uiSamplerChannel));
1019 senkov 120 return "ERR:0:Not implemented yet.\r\n"; //FIXME: Add support for this in resultset class?
1020 schoenebeck 35 }
1021    
1022 capela 159 String LSCPServer::SetAudioOutputDevice(uint AudioDeviceId, uint uiSamplerChannel) {
1023     dmsg(2,("LSCPServer: SetAudiotOutputDevice(AudioDeviceId=%d, SamplerChannel=%d)\n",AudioDeviceId,uiSamplerChannel));
1024     LSCPResultSet result;
1025     try {
1026     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1027     if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
1028     std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1029     AudioOutputDevice* pDevice = devices[AudioDeviceId];
1030     if (!pDevice) throw LinuxSamplerException("There is no audio output device with index " + ToString(AudioDeviceId));
1031     pSamplerChannel->SetAudioOutputDevice(pDevice);
1032     }
1033     catch (LinuxSamplerException e) {
1034     result.Error(e);
1035     }
1036     return result.Produce();
1037     }
1038    
1039 capela 143 String LSCPServer::SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel) {
1040     dmsg(2,("LSCPServer: SetAudioOutputType(String AudioOutputDriver=%s, SamplerChannel=%d)\n",AudioOutputDriver.c_str(),uiSamplerChannel));
1041     LSCPResultSet result;
1042     try {
1043     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1044     if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
1045     // Driver type name aliasing...
1046     if (AudioOutputDriver == "ALSA") AudioOutputDriver = "Alsa";
1047     if (AudioOutputDriver == "JACK") AudioOutputDriver = "Jack";
1048     // Check if there's one audio output device already created
1049     // for the intended audio driver type (AudioOutputDriver)...
1050     AudioOutputDevice *pDevice = NULL;
1051     std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1052     std::map<uint, AudioOutputDevice*>::iterator iter = devices.begin();
1053     for (; iter != devices.end(); iter++) {
1054     if ((iter->second)->Driver() == AudioOutputDriver) {
1055     pDevice = iter->second;
1056     break;
1057     }
1058     }
1059     // If it doesn't exist, create a new one with default parameters...
1060     if (pDevice == NULL) {
1061     std::map<String,String> params;
1062     pDevice = pSampler->CreateAudioOutputDevice(AudioOutputDriver, params);
1063     }
1064     // Must have a device...
1065     if (pDevice == NULL)
1066     throw LinuxSamplerException("Internal error: could not create audio output device.");
1067     // Set it as the current channel device...
1068     pSamplerChannel->SetAudioOutputDevice(pDevice);
1069     }
1070     catch (LinuxSamplerException e) {
1071     result.Error(e);
1072     }
1073     return result.Produce();
1074     }
1075    
1076 capela 159 String LSCPServer::SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel) {
1077     dmsg(2,("LSCPServer: SetMIDIInputPort(MIDIPort=%d, SamplerChannel=%d)\n",MIDIPort,uiSamplerChannel));
1078 senkov 120 LSCPResultSet result;
1079 schoenebeck 53 try {
1080     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1081 capela 159 if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
1082     pSamplerChannel->SetMidiInputPort(MIDIPort);
1083 schoenebeck 53 }
1084     catch (LinuxSamplerException e) {
1085 senkov 120 result.Error(e);
1086 schoenebeck 53 }
1087 senkov 120 return result.Produce();
1088 schoenebeck 53 }
1089    
1090 capela 159 String LSCPServer::SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel) {
1091     dmsg(2,("LSCPServer: SetMIDIInputChannel(MIDIChannel=%d, SamplerChannel=%d)\n",MIDIChannel,uiSamplerChannel));
1092 senkov 120 LSCPResultSet result;
1093 senkov 68 try {
1094     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1095 senkov 155 if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
1096 capela 159 pSamplerChannel->SetMidiInputChannel((MidiInputDevice::MidiInputPort::midi_chan_t) MIDIChannel);
1097 senkov 68 }
1098     catch (LinuxSamplerException e) {
1099 senkov 120 result.Error(e);
1100 senkov 68 }
1101 senkov 120 return result.Produce();
1102 schoenebeck 35 }
1103    
1104 capela 159 String LSCPServer::SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel) {
1105     dmsg(2,("LSCPServer: SetMIDIInputDevice(MIDIDeviceId=%d, SamplerChannel=%d)\n",MIDIDeviceId,uiSamplerChannel));
1106 schoenebeck 123 LSCPResultSet result;
1107     try {
1108 capela 159 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1109     if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
1110     std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1111     MidiInputDevice* pDevice = devices[MIDIDeviceId];
1112     if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(MIDIDeviceId));
1113     pSamplerChannel->SetMidiInputDevice(pDevice);
1114 schoenebeck 123 }
1115     catch (LinuxSamplerException e) {
1116     result.Error(e);
1117     }
1118     return result.Produce();
1119     }
1120    
1121 capela 159 String LSCPServer::SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel) {
1122     dmsg(2,("LSCPServer: SetMIDIInputType(String MidiInputDriver=%s, SamplerChannel=%d)\n",MidiInputDriver.c_str(),uiSamplerChannel));
1123     LSCPResultSet result;
1124     try {
1125     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1126     if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
1127     // Driver type name aliasing...
1128     if (MidiInputDriver == "ALSA") MidiInputDriver = "Alsa";
1129     // Check if there's one MIDI input device already created
1130     // for the intended MIDI driver type (MidiInputDriver)...
1131     MidiInputDevice *pDevice = NULL;
1132     std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1133     std::map<uint, MidiInputDevice*>::iterator iter = devices.begin();
1134     for (; iter != devices.end(); iter++) {
1135     if ((iter->second)->Driver() == MidiInputDriver) {
1136     pDevice = iter->second;
1137     break;
1138     }
1139     }
1140     // If it doesn't exist, create a new one with default parameters...
1141     if (pDevice == NULL) {
1142     std::map<String,String> params;
1143     pDevice = pSampler->CreateMidiInputDevice(MidiInputDriver, params);
1144     // Make it with at least one initial port.
1145     std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
1146     parameters["ports"]->SetValue("1");
1147     }
1148     // Must have a device...
1149     if (pDevice == NULL)
1150     throw LinuxSamplerException("Internal error: could not create MIDI input device.");
1151     // Set it as the current channel device...
1152     pSamplerChannel->SetMidiInputDevice(pDevice);
1153     }
1154     catch (LinuxSamplerException e) {
1155     result.Error(e);
1156     }
1157     return result.Produce();
1158     }
1159    
1160 schoenebeck 35 /**
1161 capela 159 * Will be called by the parser to change the MIDI input device, port and channel on which
1162     * engine of a particular sampler channel should listen to.
1163     */
1164     String LSCPServer::SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel) {
1165     dmsg(2,("LSCPServer: SetMIDIInput(MIDIDeviceId=%d, MIDIPort=%d, MIDIChannel=%d, SamplerChannel=%d)\n", MIDIDeviceId, MIDIPort, MIDIChannel, uiSamplerChannel));
1166     LSCPResultSet result;
1167     try {
1168     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1169     if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
1170     std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1171     MidiInputDevice* pDevice = devices[MIDIDeviceId];
1172     if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(MIDIDeviceId));
1173     pSamplerChannel->SetMidiInput(pDevice, MIDIPort, (MidiInputDevice::MidiInputPort::midi_chan_t) MIDIChannel);
1174     }
1175     catch (LinuxSamplerException e) {
1176     result.Error(e);
1177     }
1178     return result.Produce();
1179     }
1180    
1181     /**
1182 schoenebeck 35 * Will be called by the parser to change the global volume factor on a
1183     * particular sampler channel.
1184     */
1185 schoenebeck 53 String LSCPServer::SetVolume(double Volume, uint uiSamplerChannel) {
1186     dmsg(2,("LSCPServer: SetVolume(Volume=%f, SamplerChannel=%d)\n", Volume, uiSamplerChannel));
1187 senkov 120 LSCPResultSet result;
1188 schoenebeck 53 try {
1189     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1190     if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
1191     Engine* pEngine = pSamplerChannel->GetEngine();
1192     if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
1193     pEngine->Volume(Volume);
1194     }
1195     catch (LinuxSamplerException e) {
1196 senkov 120 result.Error(e);
1197 schoenebeck 53 }
1198 senkov 120 return result.Produce();
1199 schoenebeck 35 }
1200    
1201     /**
1202     * Will be called by the parser to reset a particular sampler channel.
1203     */
1204 schoenebeck 53 String LSCPServer::ResetChannel(uint uiSamplerChannel) {
1205     dmsg(2,("LSCPServer: ResetChannel(SamplerChannel=%d)\n", uiSamplerChannel));
1206 senkov 120 LSCPResultSet result;
1207 schoenebeck 53 try {
1208     SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1209     if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
1210     Engine* pEngine = pSamplerChannel->GetEngine();
1211     if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
1212     pEngine->Reset();
1213     }
1214     catch (LinuxSamplerException e) {
1215 senkov 120 result.Error(e);
1216 schoenebeck 53 }
1217 senkov 120 return result.Produce();
1218 schoenebeck 35 }
1219    
1220     /**
1221     * Will be called by the parser to subscribe a client (frontend) on the
1222     * server for receiving event messages.
1223     */
1224 senkov 170 String LSCPServer::SubscribeNotification(LSCPEvent::event_t type) {
1225     dmsg(2,("LSCPServer: SubscribeNotification(Event=%s)\n", LSCPEvent::Name(type).c_str()));
1226     LSCPResultSet result;
1227     SubscriptionMutex.Lock();
1228     eventSubscriptions[type].push_back(currentSocket);
1229     SubscriptionMutex.Unlock();
1230     return result.Produce();
1231 schoenebeck 35 }
1232    
1233     /**
1234     * Will be called by the parser to unsubscribe a client on the server
1235     * for not receiving further event messages.
1236     */
1237 senkov 170 String LSCPServer::UnsubscribeNotification(LSCPEvent::event_t type) {
1238     dmsg(2,("LSCPServer: UnsubscribeNotification(Event=%s)\n", LSCPEvent::Name(type).c_str()));
1239     LSCPResultSet result;
1240     SubscriptionMutex.Lock();
1241     eventSubscriptions[type].remove(currentSocket);
1242     SubscriptionMutex.Unlock();
1243     return result.Produce();
1244 schoenebeck 35 }
1245 capela 133
1246    
1247     // Instrument loader constructor.
1248     LSCPLoadInstrument::LSCPLoadInstrument(Engine* pEngine, String Filename, uint uiInstrument)
1249     : Thread(false, 0, -4)
1250     {
1251     this->pEngine = pEngine;
1252     this->Filename = Filename;
1253     this->uiInstrument = uiInstrument;
1254     }
1255    
1256     // Instrument loader process.
1257     int LSCPLoadInstrument::Main()
1258     {
1259     try {
1260     pEngine->LoadInstrument(Filename.c_str(), uiInstrument);
1261     }
1262    
1263     catch (LinuxSamplerException e) {
1264     e.PrintMessage();
1265     }
1266    
1267     // Always re-enable the engine.
1268     pEngine->Enable();
1269    
1270     // FIXME: Shoot ourselves on the foot?
1271     delete this;
1272     }

  ViewVC Help
Powered by ViewVC