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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1525 - (show annotations) (download)
Sun Nov 25 17:47:46 2007 UTC (16 years, 4 months ago) by schoenebeck
File size: 119079 byte(s)
* LSCP: added new LSCP commands: "GET FILE INSTRUMENTS <file>",
  "LIST FILE INSTRUMENTS <file>" and
  "GET FILE INSTRUMENT INFO <file> <index>" for retrieving informations
  about an arbitrary instrument file on the system where the sampler is
  running on (LSCP specs yet to be updated!)
* bumped version to 0.5.0.1cvs
* bumped LSCP compliance to LSCP version 1.3

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 library 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 library 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 library; 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 "lscpserver.h"
25 #include "lscpresultset.h"
26 #include "lscpevent.h"
27
28 #if defined(WIN32)
29 #else
30 #include <fcntl.h>
31 #endif
32
33 #if ! HAVE_SQLITE3
34 #define DOESNT_HAVE_SQLITE3 "No database support. SQLITE3 was not installed when linuxsampler was built."
35 #endif
36
37 #include "../engines/EngineFactory.h"
38 #include "../engines/EngineChannelFactory.h"
39 #include "../drivers/audio/AudioOutputDeviceFactory.h"
40 #include "../drivers/midi/MidiInputDeviceFactory.h"
41
42
43 /**
44 * Returns a copy of the given string where all special characters are
45 * replaced by LSCP escape sequences ("\xHH"). This function shall be used
46 * to escape LSCP response fields in case the respective response field is
47 * actually defined as using escape sequences in the LSCP specs.
48 *
49 * @e Caution: DO NOT use this function for escaping path based responses,
50 * use the Path class (src/common/Path.h) for this instead!
51 */
52 static String _escapeLscpResponse(String txt) {
53 for (int i = 0; i < txt.length(); i++) {
54 const char c = txt.c_str()[i];
55 if (
56 !(c >= '0' && c <= '9') &&
57 !(c >= 'a' && c <= 'z') &&
58 !(c >= 'A' && c <= 'Z') &&
59 !(c == ' ') && !(c == '!') && !(c == '#') && !(c == '$') &&
60 !(c == '%') && !(c == '&') && !(c == '(') && !(c == ')') &&
61 !(c == '*') && !(c == '+') && !(c == ',') && !(c == '-') &&
62 !(c == '.') && !(c == '/') && !(c == ':') && !(c == ';') &&
63 !(c == '<') && !(c == '=') && !(c == '>') && !(c == '?') &&
64 !(c == '@') && !(c == '[') && !(c == ']') &&
65 !(c == '^') && !(c == '_') && !(c == '`') && !(c == '{') &&
66 !(c == '|') && !(c == '}') && !(c == '~')
67 ) {
68 // convert the "special" character into a "\xHH" LSCP escape sequence
69 char buf[5];
70 snprintf(buf, sizeof(buf), "\\x%02x", static_cast<unsigned char>(c));
71 txt.replace(i, 1, buf);
72 i += 3;
73 }
74 }
75 return txt;
76 }
77
78 /**
79 * Below are a few static members of the LSCPServer class.
80 * The big assumption here is that LSCPServer is going to remain a singleton.
81 * These members are used to support client connections.
82 * Class handles multiple connections at the same time using select() and non-blocking recv()
83 * Commands are processed by a single LSCPServer thread.
84 * Notifications are delivered either by the thread that originated them
85 * or (if the resultset is currently in progress) by the LSCPServer thread
86 * after the resultset was sent out.
87 * This makes sure that resultsets can not be interrupted by notifications.
88 * This also makes sure that the thread sending notification is not blocked
89 * by the LSCPServer thread.
90 */
91 fd_set LSCPServer::fdSet;
92 int LSCPServer::currentSocket = -1;
93 std::vector<yyparse_param_t> LSCPServer::Sessions = std::vector<yyparse_param_t>();
94 std::vector<yyparse_param_t>::iterator itCurrentSession = std::vector<yyparse_param_t>::iterator();
95 std::map<int,String> LSCPServer::bufferedNotifies = std::map<int,String>();
96 std::map<int,String> LSCPServer::bufferedCommands = std::map<int,String>();
97 std::map< LSCPEvent::event_t, std::list<int> > LSCPServer::eventSubscriptions = std::map< LSCPEvent::event_t, std::list<int> >();
98 Mutex LSCPServer::NotifyMutex = Mutex();
99 Mutex LSCPServer::NotifyBufferMutex = Mutex();
100 Mutex LSCPServer::SubscriptionMutex = Mutex();
101 Mutex LSCPServer::RTNotifyMutex = Mutex();
102
103 LSCPServer::LSCPServer(Sampler* pSampler, long int addr, short int port) : Thread(true, false, 0, -4) {
104 SocketAddress.sin_family = AF_INET;
105 SocketAddress.sin_addr.s_addr = addr;
106 SocketAddress.sin_port = port;
107 this->pSampler = pSampler;
108 LSCPEvent::RegisterEvent(LSCPEvent::event_audio_device_count, "AUDIO_OUTPUT_DEVICE_COUNT");
109 LSCPEvent::RegisterEvent(LSCPEvent::event_audio_device_info, "AUDIO_OUTPUT_DEVICE_INFO");
110 LSCPEvent::RegisterEvent(LSCPEvent::event_midi_device_count, "MIDI_INPUT_DEVICE_COUNT");
111 LSCPEvent::RegisterEvent(LSCPEvent::event_midi_device_info, "MIDI_INPUT_DEVICE_INFO");
112 LSCPEvent::RegisterEvent(LSCPEvent::event_channel_count, "CHANNEL_COUNT");
113 LSCPEvent::RegisterEvent(LSCPEvent::event_voice_count, "VOICE_COUNT");
114 LSCPEvent::RegisterEvent(LSCPEvent::event_stream_count, "STREAM_COUNT");
115 LSCPEvent::RegisterEvent(LSCPEvent::event_buffer_fill, "BUFFER_FILL");
116 LSCPEvent::RegisterEvent(LSCPEvent::event_channel_info, "CHANNEL_INFO");
117 LSCPEvent::RegisterEvent(LSCPEvent::event_fx_send_count, "FX_SEND_COUNT");
118 LSCPEvent::RegisterEvent(LSCPEvent::event_fx_send_info, "FX_SEND_INFO");
119 LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_map_count, "MIDI_INSTRUMENT_MAP_COUNT");
120 LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_map_info, "MIDI_INSTRUMENT_MAP_INFO");
121 LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_count, "MIDI_INSTRUMENT_COUNT");
122 LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_info, "MIDI_INSTRUMENT_INFO");
123 LSCPEvent::RegisterEvent(LSCPEvent::event_db_instr_dir_count, "DB_INSTRUMENT_DIRECTORY_COUNT");
124 LSCPEvent::RegisterEvent(LSCPEvent::event_db_instr_dir_info, "DB_INSTRUMENT_DIRECTORY_INFO");
125 LSCPEvent::RegisterEvent(LSCPEvent::event_db_instr_count, "DB_INSTRUMENT_COUNT");
126 LSCPEvent::RegisterEvent(LSCPEvent::event_db_instr_info, "DB_INSTRUMENT_INFO");
127 LSCPEvent::RegisterEvent(LSCPEvent::event_db_instrs_job_info, "DB_INSTRUMENTS_JOB_INFO");
128 LSCPEvent::RegisterEvent(LSCPEvent::event_misc, "MISCELLANEOUS");
129 LSCPEvent::RegisterEvent(LSCPEvent::event_total_voice_count, "TOTAL_VOICE_COUNT");
130 LSCPEvent::RegisterEvent(LSCPEvent::event_global_info, "GLOBAL_INFO");
131 hSocket = -1;
132 }
133
134 LSCPServer::~LSCPServer() {
135 #if defined(WIN32)
136 if (hSocket >= 0) closesocket(hSocket);
137 #else
138 if (hSocket >= 0) close(hSocket);
139 #endif
140 }
141
142 void LSCPServer::EventHandler::ChannelCountChanged(int NewCount) {
143 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_channel_count, NewCount));
144 }
145
146 void LSCPServer::EventHandler::AudioDeviceCountChanged(int NewCount) {
147 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_audio_device_count, NewCount));
148 }
149
150 void LSCPServer::EventHandler::MidiDeviceCountChanged(int NewCount) {
151 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_device_count, NewCount));
152 }
153
154 void LSCPServer::EventHandler::MidiInstrumentCountChanged(int MapId, int NewCount) {
155 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_instr_count, MapId, NewCount));
156 }
157
158 void LSCPServer::EventHandler::MidiInstrumentInfoChanged(int MapId, int Bank, int Program) {
159 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_instr_info, MapId, Bank, Program));
160 }
161
162 void LSCPServer::EventHandler::MidiInstrumentMapCountChanged(int NewCount) {
163 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_instr_map_count, NewCount));
164 }
165
166 void LSCPServer::EventHandler::MidiInstrumentMapInfoChanged(int MapId) {
167 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_instr_map_info, MapId));
168 }
169
170 void LSCPServer::EventHandler::FxSendCountChanged(int ChannelId, int NewCount) {
171 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_count, ChannelId, NewCount));
172 }
173
174 void LSCPServer::EventHandler::VoiceCountChanged(int ChannelId, int NewCount) {
175 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_voice_count, ChannelId, NewCount));
176 }
177
178 void LSCPServer::EventHandler::StreamCountChanged(int ChannelId, int NewCount) {
179 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_stream_count, ChannelId, NewCount));
180 }
181
182 void LSCPServer::EventHandler::BufferFillChanged(int ChannelId, String FillData) {
183 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_buffer_fill, ChannelId, FillData));
184 }
185
186 void LSCPServer::EventHandler::TotalVoiceCountChanged(int NewCount) {
187 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_total_voice_count, NewCount));
188 }
189
190 #if HAVE_SQLITE3
191 void LSCPServer::DbInstrumentsEventHandler::DirectoryCountChanged(String Dir) {
192 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_dir_count, InstrumentsDb::toEscapedPath(Dir)));
193 }
194
195 void LSCPServer::DbInstrumentsEventHandler::DirectoryInfoChanged(String Dir) {
196 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_dir_info, InstrumentsDb::toEscapedPath(Dir)));
197 }
198
199 void LSCPServer::DbInstrumentsEventHandler::DirectoryNameChanged(String Dir, String NewName) {
200 Dir = "'" + InstrumentsDb::toEscapedPath(Dir) + "'";
201 NewName = "'" + InstrumentsDb::toEscapedPath(NewName) + "'";
202 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_dir_info, "NAME", Dir, NewName));
203 }
204
205 void LSCPServer::DbInstrumentsEventHandler::InstrumentCountChanged(String Dir) {
206 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_count, InstrumentsDb::toEscapedPath(Dir)));
207 }
208
209 void LSCPServer::DbInstrumentsEventHandler::InstrumentInfoChanged(String Instr) {
210 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_info, InstrumentsDb::toEscapedPath(Instr)));
211 }
212
213 void LSCPServer::DbInstrumentsEventHandler::InstrumentNameChanged(String Instr, String NewName) {
214 Instr = "'" + InstrumentsDb::toEscapedPath(Instr) + "'";
215 NewName = "'" + InstrumentsDb::toEscapedPath(NewName) + "'";
216 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_info, "NAME", Instr, NewName));
217 }
218
219 void LSCPServer::DbInstrumentsEventHandler::JobStatusChanged(int JobId) {
220 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instrs_job_info, JobId));
221 }
222 #endif // HAVE_SQLITE3
223
224
225 /**
226 * Blocks the calling thread until the LSCP Server is initialized and
227 * accepting socket connections, if the server is already initialized then
228 * this method will return immediately.
229 * @param TimeoutSeconds - optional: max. wait time in seconds
230 * (default: 0s)
231 * @param TimeoutNanoSeconds - optional: max wait time in nano seconds
232 * (default: 0ns)
233 * @returns 0 on success, a value less than 0 if timeout exceeded
234 */
235 int LSCPServer::WaitUntilInitialized(long TimeoutSeconds, long TimeoutNanoSeconds) {
236 return Initialized.WaitAndUnlockIf(false, TimeoutSeconds, TimeoutNanoSeconds);
237 }
238
239 int LSCPServer::Main() {
240 #if defined(WIN32)
241 WSADATA wsaData;
242 int iResult;
243 iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
244 if (iResult != 0) {
245 std::cerr << "LSCPServer: WSAStartup failed: " << iResult << "\n";
246 exit(EXIT_FAILURE);
247 }
248 #endif
249 hSocket = socket(AF_INET, SOCK_STREAM, 0);
250 if (hSocket < 0) {
251 std::cerr << "LSCPServer: Could not create server socket." << std::endl;
252 //return -1;
253 exit(EXIT_FAILURE);
254 }
255
256 if (bind(hSocket, (sockaddr*) &SocketAddress, sizeof(sockaddr_in)) < 0) {
257 std::cerr << "LSCPServer: Could not bind server socket, retrying for " << ToString(LSCP_SERVER_BIND_TIMEOUT) << " seconds...";
258 for (int trial = 0; true; trial++) { // retry for LSCP_SERVER_BIND_TIMEOUT seconds
259 if (bind(hSocket, (sockaddr*) &SocketAddress, sizeof(sockaddr_in)) < 0) {
260 if (trial > LSCP_SERVER_BIND_TIMEOUT) {
261 std::cerr << "gave up!" << std::endl;
262 #if defined(WIN32)
263 closesocket(hSocket);
264 #else
265 close(hSocket);
266 #endif
267 //return -1;
268 exit(EXIT_FAILURE);
269 }
270 else sleep(1); // sleep 1s
271 }
272 else break; // success
273 }
274 }
275
276 listen(hSocket, 1);
277 Initialized.Set(true);
278
279 // Registering event listeners
280 pSampler->AddChannelCountListener(&eventHandler);
281 pSampler->AddAudioDeviceCountListener(&eventHandler);
282 pSampler->AddMidiDeviceCountListener(&eventHandler);
283 pSampler->AddVoiceCountListener(&eventHandler);
284 pSampler->AddStreamCountListener(&eventHandler);
285 pSampler->AddBufferFillListener(&eventHandler);
286 pSampler->AddTotalVoiceCountListener(&eventHandler);
287 pSampler->AddFxSendCountListener(&eventHandler);
288 MidiInstrumentMapper::AddMidiInstrumentCountListener(&eventHandler);
289 MidiInstrumentMapper::AddMidiInstrumentInfoListener(&eventHandler);
290 MidiInstrumentMapper::AddMidiInstrumentMapCountListener(&eventHandler);
291 MidiInstrumentMapper::AddMidiInstrumentMapInfoListener(&eventHandler);
292 #if HAVE_SQLITE3
293 InstrumentsDb::GetInstrumentsDb()->AddInstrumentsDbListener(&dbInstrumentsEventHandler);
294 #endif
295 // now wait for client connections and handle their requests
296 sockaddr_in client;
297 int length = sizeof(client);
298 FD_ZERO(&fdSet);
299 FD_SET(hSocket, &fdSet);
300 int maxSessions = hSocket;
301
302 timeval timeout;
303
304 while (true) {
305 // check if some engine channel's parameter / status changed, if so notify the respective LSCP event subscribers
306 {
307 std::set<EngineChannel*> engineChannels = EngineChannelFactory::EngineChannelInstances();
308 std::set<EngineChannel*>::iterator itEngineChannel = engineChannels.begin();
309 std::set<EngineChannel*>::iterator itEnd = engineChannels.end();
310 for (; itEngineChannel != itEnd; ++itEngineChannel) {
311 if ((*itEngineChannel)->StatusChanged()) {
312 SendLSCPNotify(LSCPEvent(LSCPEvent::event_channel_info, (*itEngineChannel)->iSamplerChannelIndex));
313 }
314
315 for (int i = 0; i < (*itEngineChannel)->GetFxSendCount(); i++) {
316 FxSend* fxs = (*itEngineChannel)->GetFxSend(i);
317 if(fxs != NULL && fxs->IsInfoChanged()) {
318 int chn = (*itEngineChannel)->iSamplerChannelIndex;
319 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, chn, fxs->Id()));
320 fxs->SetInfoChanged(false);
321 }
322 }
323 }
324 }
325
326 //Now let's deliver late notifies (if any)
327 NotifyBufferMutex.Lock();
328 for (std::map<int,String>::iterator iterNotify = bufferedNotifies.begin(); iterNotify != bufferedNotifies.end(); iterNotify++) {
329 #ifdef MSG_NOSIGNAL
330 send(iterNotify->first, iterNotify->second.c_str(), iterNotify->second.size(), MSG_NOSIGNAL);
331 #else
332 send(iterNotify->first, iterNotify->second.c_str(), iterNotify->second.size(), 0);
333 #endif
334 }
335 bufferedNotifies.clear();
336 NotifyBufferMutex.Unlock();
337
338 fd_set selectSet = fdSet;
339 timeout.tv_sec = 0;
340 timeout.tv_usec = 100000;
341
342 int retval = select(maxSessions+1, &selectSet, NULL, NULL, &timeout);
343
344 if (retval == 0)
345 continue; //Nothing try again
346 if (retval == -1) {
347 std::cerr << "LSCPServer: Socket select error." << std::endl;
348 #if defined(WIN32)
349 closesocket(hSocket);
350 #else
351 close(hSocket);
352 #endif
353 exit(EXIT_FAILURE);
354 }
355
356 //Accept new connections now (if any)
357 if (FD_ISSET(hSocket, &selectSet)) {
358 int socket = accept(hSocket, (sockaddr*) &client, (socklen_t*) &length);
359 if (socket < 0) {
360 std::cerr << "LSCPServer: Client connection failed." << std::endl;
361 exit(EXIT_FAILURE);
362 }
363
364 #if defined(WIN32)
365 u_long nonblock_io = 1;
366 if( ioctlsocket(socket, FIONBIO, &nonblock_io) ) {
367 std::cerr << "LSCPServer: ioctlsocket: set FIONBIO failed. Error " << WSAGetLastError() << std::endl;
368 exit(EXIT_FAILURE);
369 }
370 #else
371 if (fcntl(socket, F_SETFL, O_NONBLOCK)) {
372 std::cerr << "LSCPServer: F_SETFL O_NONBLOCK failed." << std::endl;
373 exit(EXIT_FAILURE);
374 }
375 #endif
376
377 // Parser initialization
378 yyparse_param_t yyparse_param;
379 yyparse_param.pServer = this;
380 yyparse_param.hSession = socket;
381
382 Sessions.push_back(yyparse_param);
383 FD_SET(socket, &fdSet);
384 if (socket > maxSessions)
385 maxSessions = socket;
386 dmsg(1,("LSCPServer: Client connection established on socket:%d.\n", socket));
387 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_misc, "Client connection established on socket", socket));
388 continue; //Maybe this was the only selected socket, better select again
389 }
390
391 //Something was selected and it was not the hSocket, so it must be some command(s) coming.
392 for (std::vector<yyparse_param_t>::iterator iter = Sessions.begin(); iter != Sessions.end(); iter++) {
393 if (FD_ISSET((*iter).hSession, &selectSet)) { //Was it this socket?
394 if (GetLSCPCommand(iter)) { //Have we read the entire command?
395 dmsg(3,("LSCPServer: Got command on socket %d, calling parser.\n", currentSocket));
396 int dummy; // just a temporary hack to fulfill the restart() function prototype
397 restart(NULL, dummy); // restart the 'scanner'
398 currentSocket = (*iter).hSession; //a hack
399 itCurrentSession = iter; // another hack
400 dmsg(2,("LSCPServer: [%s]\n",bufferedCommands[currentSocket].c_str()));
401 if ((*iter).bVerbose) { // if echo mode enabled
402 AnswerClient(bufferedCommands[currentSocket]);
403 }
404 int result = yyparse(&(*iter));
405 currentSocket = -1; //continuation of a hack
406 itCurrentSession = Sessions.end(); // hack as well
407 dmsg(3,("LSCPServer: Done parsing on socket %d.\n", currentSocket));
408 if (result == LSCP_QUIT) { //Was it a quit command by any chance?
409 CloseConnection(iter);
410 }
411 }
412 //socket may have been closed, iter may be invalid, get out of the loop for now.
413 //we'll be back if there is data.
414 break;
415 }
416 }
417 }
418 }
419
420 void LSCPServer::CloseConnection( std::vector<yyparse_param_t>::iterator iter ) {
421 int socket = (*iter).hSession;
422 dmsg(1,("LSCPServer: Client connection terminated on socket:%d.\n",socket));
423 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_misc, "Client connection terminated on socket", socket));
424 Sessions.erase(iter);
425 FD_CLR(socket, &fdSet);
426 SubscriptionMutex.Lock(); //Must unsubscribe this socket from all events (if any)
427 for (std::map< LSCPEvent::event_t, std::list<int> >::iterator iter = eventSubscriptions.begin(); iter != eventSubscriptions.end(); iter++) {
428 iter->second.remove(socket);
429 }
430 SubscriptionMutex.Unlock();
431 NotifyMutex.Lock();
432 bufferedCommands.erase(socket);
433 bufferedNotifies.erase(socket);
434 #if defined(WIN32)
435 closesocket(socket);
436 #else
437 close(socket);
438 #endif
439 NotifyMutex.Unlock();
440 }
441
442 int LSCPServer::EventSubscribers( std::list<LSCPEvent::event_t> events ) {
443 int subs = 0;
444 SubscriptionMutex.Lock();
445 for( std::list<LSCPEvent::event_t>::iterator iter = events.begin();
446 iter != events.end(); iter++)
447 {
448 subs += eventSubscriptions.count(*iter);
449 }
450 SubscriptionMutex.Unlock();
451 return subs;
452 }
453
454 void LSCPServer::SendLSCPNotify( LSCPEvent event ) {
455 SubscriptionMutex.Lock();
456 if (eventSubscriptions.count(event.GetType()) == 0) {
457 SubscriptionMutex.Unlock(); //Nobody is subscribed to this event
458 return;
459 }
460 std::list<int>::iterator iter = eventSubscriptions[event.GetType()].begin();
461 std::list<int>::iterator end = eventSubscriptions[event.GetType()].end();
462 String notify = event.Produce();
463
464 while (true) {
465 if (NotifyMutex.Trylock()) {
466 for(;iter != end; iter++)
467 #ifdef MSG_NOSIGNAL
468 send(*iter, notify.c_str(), notify.size(), MSG_NOSIGNAL);
469 #else
470 send(*iter, notify.c_str(), notify.size(), 0);
471 #endif
472 NotifyMutex.Unlock();
473 break;
474 } else {
475 if (NotifyBufferMutex.Trylock()) {
476 for(;iter != end; iter++)
477 bufferedNotifies[*iter] += notify;
478 NotifyBufferMutex.Unlock();
479 break;
480 }
481 }
482 }
483 SubscriptionMutex.Unlock();
484 }
485
486 extern int GetLSCPCommand( void *buf, int max_size ) {
487 String command = LSCPServer::bufferedCommands[LSCPServer::currentSocket];
488 if (command.size() == 0) { //Parser wants input but we have nothing.
489 strcpy((char*) buf, "\n"); //So give it an empty command
490 return 1; //to keep it happy.
491 }
492
493 if (max_size < command.size()) {
494 std::cerr << "getLSCPCommand: Flex buffer too small, ignoring the command." << std::endl;
495 return 0; //This will never happen
496 }
497
498 strcpy((char*) buf, command.c_str());
499 LSCPServer::bufferedCommands.erase(LSCPServer::currentSocket);
500 return command.size();
501 }
502
503 extern yyparse_param_t* GetCurrentYaccSession() {
504 return &(*itCurrentSession);
505 }
506
507 /**
508 * Will be called to try to read the command from the socket
509 * If command is read, it will return true. Otherwise false is returned.
510 * In any case the received portion (complete or incomplete) is saved into bufferedCommand map.
511 */
512 bool LSCPServer::GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter ) {
513 int socket = (*iter).hSession;
514 char c;
515 int i = 0;
516 while (true) {
517 #if defined(WIN32)
518 int result = recv(socket, (char *)&c, 1, 0); //Read one character at a time for now
519 #else
520 int result = recv(socket, (void *)&c, 1, 0); //Read one character at a time for now
521 #endif
522 if (result == 0) { //socket was selected, so 0 here means client has closed the connection
523 CloseConnection(iter);
524 break;
525 }
526 if (result == 1) {
527 if (c == '\r')
528 continue; //Ignore CR
529 if (c == '\n') {
530 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_misc, "Received \'" + bufferedCommands[socket] + "\' on socket", socket));
531 bufferedCommands[socket] += "\r\n";
532 return true; //Complete command was read
533 }
534 bufferedCommands[socket] += c;
535 }
536 #if defined(WIN32)
537 if (result == SOCKET_ERROR) {
538 int wsa_lasterror = WSAGetLastError();
539 if (wsa_lasterror == WSAEWOULDBLOCK) //Would block, try again later.
540 return false;
541 dmsg(2,("LSCPScanner: Socket error after recv() Error %d.\n", wsa_lasterror));
542 CloseConnection(iter);
543 break;
544 }
545 #else
546 if (result == -1) {
547 if (errno == EAGAIN) //Would block, try again later.
548 return false;
549 switch(errno) {
550 case EBADF:
551 dmsg(2,("LSCPScanner: The argument s is an invalid descriptor.\n"));
552 break;
553 case ECONNREFUSED:
554 dmsg(2,("LSCPScanner: A remote host refused to allow the network connection (typically because it is not running the requested service).\n"));
555 break;
556 case ENOTCONN:
557 dmsg(2,("LSCPScanner: The socket is associated with a connection-oriented protocol and has not been connected (see connect(2) and accept(2)).\n"));
558 break;
559 case ENOTSOCK:
560 dmsg(2,("LSCPScanner: The argument s does not refer to a socket.\n"));
561 break;
562 case EAGAIN:
563 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"));
564 break;
565 case EINTR:
566 dmsg(2,("LSCPScanner: The receive was interrupted by delivery of a signal before any data were available.\n"));
567 break;
568 case EFAULT:
569 dmsg(2,("LSCPScanner: The receive buffer pointer(s) point outside the process's address space.\n"));
570 break;
571 case EINVAL:
572 dmsg(2,("LSCPScanner: Invalid argument passed.\n"));
573 break;
574 case ENOMEM:
575 dmsg(2,("LSCPScanner: Could not allocate memory for recvmsg.\n"));
576 break;
577 default:
578 dmsg(2,("LSCPScanner: Unknown recv() error.\n"));
579 break;
580 }
581 CloseConnection(iter);
582 break;
583 }
584 #endif
585 }
586 return false;
587 }
588
589 /**
590 * Will be called by the parser whenever it wants to send an answer to the
591 * client / frontend.
592 *
593 * @param ReturnMessage - message that will be send to the client
594 */
595 void LSCPServer::AnswerClient(String ReturnMessage) {
596 dmsg(2,("LSCPServer::AnswerClient(ReturnMessage=%s)", ReturnMessage.c_str()));
597 if (currentSocket != -1) {
598 NotifyMutex.Lock();
599 #ifdef MSG_NOSIGNAL
600 send(currentSocket, ReturnMessage.c_str(), ReturnMessage.size(), MSG_NOSIGNAL);
601 #else
602 send(currentSocket, ReturnMessage.c_str(), ReturnMessage.size(), 0);
603 #endif
604 NotifyMutex.Unlock();
605 }
606 }
607
608 /**
609 * Find a created audio output device index.
610 */
611 int LSCPServer::GetAudioOutputDeviceIndex ( AudioOutputDevice *pDevice )
612 {
613 // Search for the created device to get its index
614 std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
615 std::map<uint, AudioOutputDevice*>::iterator iter = devices.begin();
616 for (; iter != devices.end(); iter++) {
617 if (iter->second == pDevice)
618 return iter->first;
619 }
620 // Not found.
621 return -1;
622 }
623
624 /**
625 * Find a created midi input device index.
626 */
627 int LSCPServer::GetMidiInputDeviceIndex ( MidiInputDevice *pDevice )
628 {
629 // Search for the created device to get its index
630 std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
631 std::map<uint, MidiInputDevice*>::iterator iter = devices.begin();
632 for (; iter != devices.end(); iter++) {
633 if (iter->second == pDevice)
634 return iter->first;
635 }
636 // Not found.
637 return -1;
638 }
639
640 String LSCPServer::CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters) {
641 dmsg(2,("LSCPServer: CreateAudioOutputDevice(Driver=%s)\n", Driver.c_str()));
642 LSCPResultSet result;
643 try {
644 AudioOutputDevice* pDevice = pSampler->CreateAudioOutputDevice(Driver, Parameters);
645 // search for the created device to get its index
646 int index = GetAudioOutputDeviceIndex(pDevice);
647 if (index == -1) throw Exception("Internal error: could not find created audio output device.");
648 result = index; // success
649 }
650 catch (Exception e) {
651 result.Error(e);
652 }
653 return result.Produce();
654 }
655
656 String LSCPServer::CreateMidiInputDevice(String Driver, std::map<String,String> Parameters) {
657 dmsg(2,("LSCPServer: CreateMidiInputDevice(Driver=%s)\n", Driver.c_str()));
658 LSCPResultSet result;
659 try {
660 MidiInputDevice* pDevice = pSampler->CreateMidiInputDevice(Driver, Parameters);
661 // search for the created device to get its index
662 int index = GetMidiInputDeviceIndex(pDevice);
663 if (index == -1) throw Exception("Internal error: could not find created midi input device.");
664 result = index; // success
665 }
666 catch (Exception e) {
667 result.Error(e);
668 }
669 return result.Produce();
670 }
671
672 String LSCPServer::DestroyAudioOutputDevice(uint DeviceIndex) {
673 dmsg(2,("LSCPServer: DestroyAudioOutputDevice(DeviceIndex=%d)\n", DeviceIndex));
674 LSCPResultSet result;
675 try {
676 std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
677 if (!devices.count(DeviceIndex)) throw Exception("There is no audio output device with index " + ToString(DeviceIndex) + ".");
678 AudioOutputDevice* pDevice = devices[DeviceIndex];
679 pSampler->DestroyAudioOutputDevice(pDevice);
680 }
681 catch (Exception e) {
682 result.Error(e);
683 }
684 return result.Produce();
685 }
686
687 String LSCPServer::DestroyMidiInputDevice(uint DeviceIndex) {
688 dmsg(2,("LSCPServer: DestroyMidiInputDevice(DeviceIndex=%d)\n", DeviceIndex));
689 LSCPResultSet result;
690 try {
691 std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
692 if (!devices.count(DeviceIndex)) throw Exception("There is no audio output device with index " + ToString(DeviceIndex) + ".");
693 MidiInputDevice* pDevice = devices[DeviceIndex];
694 pSampler->DestroyMidiInputDevice(pDevice);
695 }
696 catch (Exception e) {
697 result.Error(e);
698 }
699 return result.Produce();
700 }
701
702 EngineChannel* LSCPServer::GetEngineChannel(uint uiSamplerChannel) {
703 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
704 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
705
706 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
707 if (!pEngineChannel) throw Exception("There is no engine deployed on this sampler channel yet");
708
709 return pEngineChannel;
710 }
711
712 /**
713 * Will be called by the parser to load an instrument.
714 */
715 String LSCPServer::LoadInstrument(String Filename, uint uiInstrument, uint uiSamplerChannel, bool bBackground) {
716 dmsg(2,("LSCPServer: LoadInstrument(Filename=%s,Instrument=%d,SamplerChannel=%d)\n", Filename.c_str(), uiInstrument, uiSamplerChannel));
717 LSCPResultSet result;
718 try {
719 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
720 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
721 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
722 if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel yet");
723 if (!pSamplerChannel->GetAudioOutputDevice())
724 throw Exception("No audio output device connected to sampler channel");
725 if (bBackground) {
726 InstrumentManager::instrument_id_t id;
727 id.FileName = Filename;
728 id.Index = uiInstrument;
729 InstrumentManager::LoadInstrumentInBackground(id, pEngineChannel);
730 }
731 else {
732 // tell the engine channel which instrument to load
733 pEngineChannel->PrepareLoadInstrument(Filename.c_str(), uiInstrument);
734 // actually start to load the instrument (blocks until completed)
735 pEngineChannel->LoadInstrument();
736 }
737 }
738 catch (Exception e) {
739 result.Error(e);
740 }
741 return result.Produce();
742 }
743
744 /**
745 * Will be called by the parser to assign a sampler engine type to a
746 * sampler channel.
747 */
748 String LSCPServer::SetEngineType(String EngineName, uint uiSamplerChannel) {
749 dmsg(2,("LSCPServer: SetEngineType(EngineName=%s,uiSamplerChannel=%d)\n", EngineName.c_str(), uiSamplerChannel));
750 LSCPResultSet result;
751 try {
752 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
753 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
754 LockRTNotify();
755 pSamplerChannel->SetEngineType(EngineName);
756 if(HasSoloChannel()) pSamplerChannel->GetEngineChannel()->SetMute(-1);
757 UnlockRTNotify();
758 }
759 catch (Exception e) {
760 result.Error(e);
761 }
762 return result.Produce();
763 }
764
765 /**
766 * Will be called by the parser to get the amount of sampler channels.
767 */
768 String LSCPServer::GetChannels() {
769 dmsg(2,("LSCPServer: GetChannels()\n"));
770 LSCPResultSet result;
771 result.Add(pSampler->SamplerChannels());
772 return result.Produce();
773 }
774
775 /**
776 * Will be called by the parser to get the list of sampler channels.
777 */
778 String LSCPServer::ListChannels() {
779 dmsg(2,("LSCPServer: ListChannels()\n"));
780 String list;
781 std::map<uint,SamplerChannel*> channels = pSampler->GetSamplerChannels();
782 std::map<uint,SamplerChannel*>::iterator iter = channels.begin();
783 for (; iter != channels.end(); iter++) {
784 if (list != "") list += ",";
785 list += ToString(iter->first);
786 }
787 LSCPResultSet result;
788 result.Add(list);
789 return result.Produce();
790 }
791
792 /**
793 * Will be called by the parser to add a sampler channel.
794 */
795 String LSCPServer::AddChannel() {
796 dmsg(2,("LSCPServer: AddChannel()\n"));
797 LockRTNotify();
798 SamplerChannel* pSamplerChannel = pSampler->AddSamplerChannel();
799 UnlockRTNotify();
800 LSCPResultSet result(pSamplerChannel->Index());
801 return result.Produce();
802 }
803
804 /**
805 * Will be called by the parser to remove a sampler channel.
806 */
807 String LSCPServer::RemoveChannel(uint uiSamplerChannel) {
808 dmsg(2,("LSCPServer: RemoveChannel(SamplerChannel=%d)\n", uiSamplerChannel));
809 LSCPResultSet result;
810 LockRTNotify();
811 pSampler->RemoveSamplerChannel(uiSamplerChannel);
812 UnlockRTNotify();
813 return result.Produce();
814 }
815
816 /**
817 * Will be called by the parser to get the amount of all available engines.
818 */
819 String LSCPServer::GetAvailableEngines() {
820 dmsg(2,("LSCPServer: GetAvailableEngines()\n"));
821 LSCPResultSet result;
822 try {
823 int n = EngineFactory::AvailableEngineTypes().size();
824 result.Add(n);
825 }
826 catch (Exception e) {
827 result.Error(e);
828 }
829 return result.Produce();
830 }
831
832 /**
833 * Will be called by the parser to get a list of all available engines.
834 */
835 String LSCPServer::ListAvailableEngines() {
836 dmsg(2,("LSCPServer: ListAvailableEngines()\n"));
837 LSCPResultSet result;
838 try {
839 String s = EngineFactory::AvailableEngineTypesAsString();
840 result.Add(s);
841 }
842 catch (Exception e) {
843 result.Error(e);
844 }
845 return result.Produce();
846 }
847
848 /**
849 * Will be called by the parser to get descriptions for a particular
850 * sampler engine.
851 */
852 String LSCPServer::GetEngineInfo(String EngineName) {
853 dmsg(2,("LSCPServer: GetEngineInfo(EngineName=%s)\n", EngineName.c_str()));
854 LSCPResultSet result;
855 LockRTNotify();
856 try {
857 Engine* pEngine = EngineFactory::Create(EngineName);
858 result.Add("DESCRIPTION", _escapeLscpResponse(pEngine->Description()));
859 result.Add("VERSION", pEngine->Version());
860 EngineFactory::Destroy(pEngine);
861 }
862 catch (Exception e) {
863 result.Error(e);
864 }
865 UnlockRTNotify();
866 return result.Produce();
867 }
868
869 /**
870 * Will be called by the parser to get informations about a particular
871 * sampler channel.
872 */
873 String LSCPServer::GetChannelInfo(uint uiSamplerChannel) {
874 dmsg(2,("LSCPServer: GetChannelInfo(SamplerChannel=%d)\n", uiSamplerChannel));
875 LSCPResultSet result;
876 try {
877 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
878 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
879 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
880
881 //Defaults values
882 String EngineName = "NONE";
883 float Volume = 0.0f;
884 String InstrumentFileName = "NONE";
885 String InstrumentName = "NONE";
886 int InstrumentIndex = -1;
887 int InstrumentStatus = -1;
888 int AudioOutputChannels = 0;
889 String AudioRouting;
890 int Mute = 0;
891 bool Solo = false;
892 String MidiInstrumentMap = "NONE";
893
894 if (pEngineChannel) {
895 EngineName = pEngineChannel->EngineName();
896 AudioOutputChannels = pEngineChannel->Channels();
897 Volume = pEngineChannel->Volume();
898 InstrumentStatus = pEngineChannel->InstrumentStatus();
899 InstrumentIndex = pEngineChannel->InstrumentIndex();
900 if (InstrumentIndex != -1) {
901 InstrumentFileName = pEngineChannel->InstrumentFileName();
902 InstrumentName = pEngineChannel->InstrumentName();
903 }
904 for (int chan = 0; chan < pEngineChannel->Channels(); chan++) {
905 if (AudioRouting != "") AudioRouting += ",";
906 AudioRouting += ToString(pEngineChannel->OutputChannel(chan));
907 }
908 Mute = pEngineChannel->GetMute();
909 Solo = pEngineChannel->GetSolo();
910 if (pEngineChannel->UsesNoMidiInstrumentMap())
911 MidiInstrumentMap = "NONE";
912 else if (pEngineChannel->UsesDefaultMidiInstrumentMap())
913 MidiInstrumentMap = "DEFAULT";
914 else
915 MidiInstrumentMap = ToString(pEngineChannel->GetMidiInstrumentMap());
916 }
917
918 result.Add("ENGINE_NAME", EngineName);
919 result.Add("VOLUME", Volume);
920
921 //Some not-so-hardcoded stuff to make GUI look good
922 result.Add("AUDIO_OUTPUT_DEVICE", GetAudioOutputDeviceIndex(pSamplerChannel->GetAudioOutputDevice()));
923 result.Add("AUDIO_OUTPUT_CHANNELS", AudioOutputChannels);
924 result.Add("AUDIO_OUTPUT_ROUTING", AudioRouting);
925
926 result.Add("MIDI_INPUT_DEVICE", GetMidiInputDeviceIndex(pSamplerChannel->GetMidiInputDevice()));
927 result.Add("MIDI_INPUT_PORT", pSamplerChannel->GetMidiInputPort());
928 if (pSamplerChannel->GetMidiInputChannel() == midi_chan_all) result.Add("MIDI_INPUT_CHANNEL", "ALL");
929 else result.Add("MIDI_INPUT_CHANNEL", pSamplerChannel->GetMidiInputChannel());
930
931 // convert the filename into the correct encoding as defined for LSCP
932 // (especially in terms of special characters -> escape sequences)
933 if (InstrumentFileName != "NONE" && InstrumentFileName != "") {
934 #if WIN32
935 InstrumentFileName = Path::fromWindows(InstrumentFileName).toLscp();
936 #else
937 // assuming POSIX
938 InstrumentFileName = Path::fromPosix(InstrumentFileName).toLscp();
939 #endif
940 }
941
942 result.Add("INSTRUMENT_FILE", InstrumentFileName);
943 result.Add("INSTRUMENT_NR", InstrumentIndex);
944 result.Add("INSTRUMENT_NAME", _escapeLscpResponse(InstrumentName));
945 result.Add("INSTRUMENT_STATUS", InstrumentStatus);
946 result.Add("MUTE", Mute == -1 ? "MUTED_BY_SOLO" : (Mute ? "true" : "false"));
947 result.Add("SOLO", Solo);
948 result.Add("MIDI_INSTRUMENT_MAP", MidiInstrumentMap);
949 }
950 catch (Exception e) {
951 result.Error(e);
952 }
953 return result.Produce();
954 }
955
956 /**
957 * Will be called by the parser to get the amount of active voices on a
958 * particular sampler channel.
959 */
960 String LSCPServer::GetVoiceCount(uint uiSamplerChannel) {
961 dmsg(2,("LSCPServer: GetVoiceCount(SamplerChannel=%d)\n", uiSamplerChannel));
962 LSCPResultSet result;
963 try {
964 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
965 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
966 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
967 if (!pEngineChannel) throw Exception("No engine loaded on sampler channel");
968 if (!pEngineChannel->GetEngine()) throw Exception("No audio output device connected to sampler channel");
969 result.Add(pEngineChannel->GetEngine()->VoiceCount());
970 }
971 catch (Exception e) {
972 result.Error(e);
973 }
974 return result.Produce();
975 }
976
977 /**
978 * Will be called by the parser to get the amount of active disk streams on a
979 * particular sampler channel.
980 */
981 String LSCPServer::GetStreamCount(uint uiSamplerChannel) {
982 dmsg(2,("LSCPServer: GetStreamCount(SamplerChannel=%d)\n", uiSamplerChannel));
983 LSCPResultSet result;
984 try {
985 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
986 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
987 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
988 if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
989 if (!pEngineChannel->GetEngine()) throw Exception("No audio output device connected to sampler channel");
990 result.Add(pEngineChannel->GetEngine()->DiskStreamCount());
991 }
992 catch (Exception e) {
993 result.Error(e);
994 }
995 return result.Produce();
996 }
997
998 /**
999 * Will be called by the parser to get the buffer fill states of all disk
1000 * streams on a particular sampler channel.
1001 */
1002 String LSCPServer::GetBufferFill(fill_response_t ResponseType, uint uiSamplerChannel) {
1003 dmsg(2,("LSCPServer: GetBufferFill(ResponseType=%d, SamplerChannel=%d)\n", ResponseType, uiSamplerChannel));
1004 LSCPResultSet result;
1005 try {
1006 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1007 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1008 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
1009 if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
1010 if (!pEngineChannel->GetEngine()) throw Exception("No audio output device connected to sampler channel");
1011 if (!pEngineChannel->GetEngine()->DiskStreamSupported()) result.Add("NA");
1012 else {
1013 switch (ResponseType) {
1014 case fill_response_bytes:
1015 result.Add(pEngineChannel->GetEngine()->DiskStreamBufferFillBytes());
1016 break;
1017 case fill_response_percentage:
1018 result.Add(pEngineChannel->GetEngine()->DiskStreamBufferFillPercentage());
1019 break;
1020 default:
1021 throw Exception("Unknown fill response type");
1022 }
1023 }
1024 }
1025 catch (Exception e) {
1026 result.Error(e);
1027 }
1028 return result.Produce();
1029 }
1030
1031 String LSCPServer::GetAvailableAudioOutputDrivers() {
1032 dmsg(2,("LSCPServer: GetAvailableAudioOutputDrivers()\n"));
1033 LSCPResultSet result;
1034 try {
1035 int n = AudioOutputDeviceFactory::AvailableDrivers().size();
1036 result.Add(n);
1037 }
1038 catch (Exception e) {
1039 result.Error(e);
1040 }
1041 return result.Produce();
1042 }
1043
1044 String LSCPServer::ListAvailableAudioOutputDrivers() {
1045 dmsg(2,("LSCPServer: ListAvailableAudioOutputDrivers()\n"));
1046 LSCPResultSet result;
1047 try {
1048 String s = AudioOutputDeviceFactory::AvailableDriversAsString();
1049 result.Add(s);
1050 }
1051 catch (Exception e) {
1052 result.Error(e);
1053 }
1054 return result.Produce();
1055 }
1056
1057 String LSCPServer::GetAvailableMidiInputDrivers() {
1058 dmsg(2,("LSCPServer: GetAvailableMidiInputDrivers()\n"));
1059 LSCPResultSet result;
1060 try {
1061 int n = MidiInputDeviceFactory::AvailableDrivers().size();
1062 result.Add(n);
1063 }
1064 catch (Exception e) {
1065 result.Error(e);
1066 }
1067 return result.Produce();
1068 }
1069
1070 String LSCPServer::ListAvailableMidiInputDrivers() {
1071 dmsg(2,("LSCPServer: ListAvailableMidiInputDrivers()\n"));
1072 LSCPResultSet result;
1073 try {
1074 String s = MidiInputDeviceFactory::AvailableDriversAsString();
1075 result.Add(s);
1076 }
1077 catch (Exception e) {
1078 result.Error(e);
1079 }
1080 return result.Produce();
1081 }
1082
1083 String LSCPServer::GetMidiInputDriverInfo(String Driver) {
1084 dmsg(2,("LSCPServer: GetMidiInputDriverInfo(Driver=%s)\n",Driver.c_str()));
1085 LSCPResultSet result;
1086 try {
1087 result.Add("DESCRIPTION", MidiInputDeviceFactory::GetDriverDescription(Driver));
1088 result.Add("VERSION", MidiInputDeviceFactory::GetDriverVersion(Driver));
1089
1090 std::map<String,DeviceCreationParameter*> parameters = MidiInputDeviceFactory::GetAvailableDriverParameters(Driver);
1091 if (parameters.size()) { // if there are parameters defined for this driver
1092 String s;
1093 std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
1094 for (;iter != parameters.end(); iter++) {
1095 if (s != "") s += ",";
1096 s += iter->first;
1097 }
1098 result.Add("PARAMETERS", s);
1099 }
1100 }
1101 catch (Exception e) {
1102 result.Error(e);
1103 }
1104 return result.Produce();
1105 }
1106
1107 String LSCPServer::GetAudioOutputDriverInfo(String Driver) {
1108 dmsg(2,("LSCPServer: GetAudioOutputDriverInfo(Driver=%s)\n",Driver.c_str()));
1109 LSCPResultSet result;
1110 try {
1111 result.Add("DESCRIPTION", AudioOutputDeviceFactory::GetDriverDescription(Driver));
1112 result.Add("VERSION", AudioOutputDeviceFactory::GetDriverVersion(Driver));
1113
1114 std::map<String,DeviceCreationParameter*> parameters = AudioOutputDeviceFactory::GetAvailableDriverParameters(Driver);
1115 if (parameters.size()) { // if there are parameters defined for this driver
1116 String s;
1117 std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
1118 for (;iter != parameters.end(); iter++) {
1119 if (s != "") s += ",";
1120 s += iter->first;
1121 }
1122 result.Add("PARAMETERS", s);
1123 }
1124 }
1125 catch (Exception e) {
1126 result.Error(e);
1127 }
1128 return result.Produce();
1129 }
1130
1131 String LSCPServer::GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList) {
1132 dmsg(2,("LSCPServer: GetMidiInputDriverParameterInfo(Driver=%s,Parameter=%s,DependencyListSize=%d)\n",Driver.c_str(),Parameter.c_str(),DependencyList.size()));
1133 LSCPResultSet result;
1134 try {
1135 DeviceCreationParameter* pParameter = MidiInputDeviceFactory::GetDriverParameter(Driver, Parameter);
1136 result.Add("TYPE", pParameter->Type());
1137 result.Add("DESCRIPTION", pParameter->Description());
1138 result.Add("MANDATORY", pParameter->Mandatory());
1139 result.Add("FIX", pParameter->Fix());
1140 result.Add("MULTIPLICITY", pParameter->Multiplicity());
1141 optional<String> oDepends = pParameter->Depends();
1142 optional<String> oDefault = pParameter->Default(DependencyList);
1143 optional<String> oRangeMin = pParameter->RangeMin(DependencyList);
1144 optional<String> oRangeMax = pParameter->RangeMax(DependencyList);
1145 optional<String> oPossibilities = pParameter->Possibilities(DependencyList);
1146 if (oDepends) result.Add("DEPENDS", *oDepends);
1147 if (oDefault) result.Add("DEFAULT", *oDefault);
1148 if (oRangeMin) result.Add("RANGE_MIN", *oRangeMin);
1149 if (oRangeMax) result.Add("RANGE_MAX", *oRangeMax);
1150 if (oPossibilities) result.Add("POSSIBILITIES", *oPossibilities);
1151 }
1152 catch (Exception e) {
1153 result.Error(e);
1154 }
1155 return result.Produce();
1156 }
1157
1158 String LSCPServer::GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList) {
1159 dmsg(2,("LSCPServer: GetAudioOutputDriverParameterInfo(Driver=%s,Parameter=%s,DependencyListSize=%d)\n",Driver.c_str(),Parameter.c_str(),DependencyList.size()));
1160 LSCPResultSet result;
1161 try {
1162 DeviceCreationParameter* pParameter = AudioOutputDeviceFactory::GetDriverParameter(Driver, Parameter);
1163 result.Add("TYPE", pParameter->Type());
1164 result.Add("DESCRIPTION", pParameter->Description());
1165 result.Add("MANDATORY", pParameter->Mandatory());
1166 result.Add("FIX", pParameter->Fix());
1167 result.Add("MULTIPLICITY", pParameter->Multiplicity());
1168 optional<String> oDepends = pParameter->Depends();
1169 optional<String> oDefault = pParameter->Default(DependencyList);
1170 optional<String> oRangeMin = pParameter->RangeMin(DependencyList);
1171 optional<String> oRangeMax = pParameter->RangeMax(DependencyList);
1172 optional<String> oPossibilities = pParameter->Possibilities(DependencyList);
1173 if (oDepends) result.Add("DEPENDS", *oDepends);
1174 if (oDefault) result.Add("DEFAULT", *oDefault);
1175 if (oRangeMin) result.Add("RANGE_MIN", *oRangeMin);
1176 if (oRangeMax) result.Add("RANGE_MAX", *oRangeMax);
1177 if (oPossibilities) result.Add("POSSIBILITIES", *oPossibilities);
1178 }
1179 catch (Exception e) {
1180 result.Error(e);
1181 }
1182 return result.Produce();
1183 }
1184
1185 String LSCPServer::GetAudioOutputDeviceCount() {
1186 dmsg(2,("LSCPServer: GetAudioOutputDeviceCount()\n"));
1187 LSCPResultSet result;
1188 try {
1189 uint count = pSampler->AudioOutputDevices();
1190 result.Add(count); // success
1191 }
1192 catch (Exception e) {
1193 result.Error(e);
1194 }
1195 return result.Produce();
1196 }
1197
1198 String LSCPServer::GetMidiInputDeviceCount() {
1199 dmsg(2,("LSCPServer: GetMidiInputDeviceCount()\n"));
1200 LSCPResultSet result;
1201 try {
1202 uint count = pSampler->MidiInputDevices();
1203 result.Add(count); // success
1204 }
1205 catch (Exception e) {
1206 result.Error(e);
1207 }
1208 return result.Produce();
1209 }
1210
1211 String LSCPServer::GetAudioOutputDevices() {
1212 dmsg(2,("LSCPServer: GetAudioOutputDevices()\n"));
1213 LSCPResultSet result;
1214 try {
1215 String s;
1216 std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1217 std::map<uint, AudioOutputDevice*>::iterator iter = devices.begin();
1218 for (; iter != devices.end(); iter++) {
1219 if (s != "") s += ",";
1220 s += ToString(iter->first);
1221 }
1222 result.Add(s);
1223 }
1224 catch (Exception e) {
1225 result.Error(e);
1226 }
1227 return result.Produce();
1228 }
1229
1230 String LSCPServer::GetMidiInputDevices() {
1231 dmsg(2,("LSCPServer: GetMidiInputDevices()\n"));
1232 LSCPResultSet result;
1233 try {
1234 String s;
1235 std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1236 std::map<uint, MidiInputDevice*>::iterator iter = devices.begin();
1237 for (; iter != devices.end(); iter++) {
1238 if (s != "") s += ",";
1239 s += ToString(iter->first);
1240 }
1241 result.Add(s);
1242 }
1243 catch (Exception e) {
1244 result.Error(e);
1245 }
1246 return result.Produce();
1247 }
1248
1249 String LSCPServer::GetAudioOutputDeviceInfo(uint DeviceIndex) {
1250 dmsg(2,("LSCPServer: GetAudioOutputDeviceInfo(DeviceIndex=%d)\n",DeviceIndex));
1251 LSCPResultSet result;
1252 try {
1253 std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1254 if (!devices.count(DeviceIndex)) throw Exception("There is no audio output device with index " + ToString(DeviceIndex) + ".");
1255 AudioOutputDevice* pDevice = devices[DeviceIndex];
1256 result.Add("DRIVER", pDevice->Driver());
1257 std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
1258 std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
1259 for (; iter != parameters.end(); iter++) {
1260 result.Add(iter->first, iter->second->Value());
1261 }
1262 }
1263 catch (Exception e) {
1264 result.Error(e);
1265 }
1266 return result.Produce();
1267 }
1268
1269 String LSCPServer::GetMidiInputDeviceInfo(uint DeviceIndex) {
1270 dmsg(2,("LSCPServer: GetMidiInputDeviceInfo(DeviceIndex=%d)\n",DeviceIndex));
1271 LSCPResultSet result;
1272 try {
1273 std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1274 if (!devices.count(DeviceIndex)) throw Exception("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
1275 MidiInputDevice* pDevice = devices[DeviceIndex];
1276 result.Add("DRIVER", pDevice->Driver());
1277 std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
1278 std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
1279 for (; iter != parameters.end(); iter++) {
1280 result.Add(iter->first, iter->second->Value());
1281 }
1282 }
1283 catch (Exception e) {
1284 result.Error(e);
1285 }
1286 return result.Produce();
1287 }
1288 String LSCPServer::GetMidiInputPortInfo(uint DeviceIndex, uint PortIndex) {
1289 dmsg(2,("LSCPServer: GetMidiInputPortInfo(DeviceIndex=%d, PortIndex=%d)\n",DeviceIndex, PortIndex));
1290 LSCPResultSet result;
1291 try {
1292 // get MIDI input device
1293 std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1294 if (!devices.count(DeviceIndex)) throw Exception("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
1295 MidiInputDevice* pDevice = devices[DeviceIndex];
1296
1297 // get MIDI port
1298 MidiInputPort* pMidiInputPort = pDevice->GetPort(PortIndex);
1299 if (!pMidiInputPort) throw Exception("There is no MIDI input port with index " + ToString(PortIndex) + ".");
1300
1301 // return the values of all MIDI port parameters
1302 std::map<String,DeviceRuntimeParameter*> parameters = pMidiInputPort->PortParameters();
1303 std::map<String,DeviceRuntimeParameter*>::iterator iter = parameters.begin();
1304 for (; iter != parameters.end(); iter++) {
1305 result.Add(iter->first, iter->second->Value());
1306 }
1307 }
1308 catch (Exception e) {
1309 result.Error(e);
1310 }
1311 return result.Produce();
1312 }
1313
1314 String LSCPServer::GetAudioOutputChannelInfo(uint DeviceId, uint ChannelId) {
1315 dmsg(2,("LSCPServer: GetAudioOutputChannelInfo(DeviceId=%d,ChannelId)\n",DeviceId,ChannelId));
1316 LSCPResultSet result;
1317 try {
1318 // get audio output device
1319 std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1320 if (!devices.count(DeviceId)) throw Exception("There is no audio output device with index " + ToString(DeviceId) + ".");
1321 AudioOutputDevice* pDevice = devices[DeviceId];
1322
1323 // get audio channel
1324 AudioChannel* pChannel = pDevice->Channel(ChannelId);
1325 if (!pChannel) throw Exception("Audio output device does not have audio channel " + ToString(ChannelId) + ".");
1326
1327 // return the values of all audio channel parameters
1328 std::map<String,DeviceRuntimeParameter*> parameters = pChannel->ChannelParameters();
1329 std::map<String,DeviceRuntimeParameter*>::iterator iter = parameters.begin();
1330 for (; iter != parameters.end(); iter++) {
1331 result.Add(iter->first, iter->second->Value());
1332 }
1333 }
1334 catch (Exception e) {
1335 result.Error(e);
1336 }
1337 return result.Produce();
1338 }
1339
1340 String LSCPServer::GetMidiInputPortParameterInfo(uint DeviceId, uint PortId, String ParameterName) {
1341 dmsg(2,("LSCPServer: GetMidiInputPortParameterInfo(DeviceId=%d,PortId=%d,ParameterName=%s)\n",DeviceId,PortId,ParameterName.c_str()));
1342 LSCPResultSet result;
1343 try {
1344 // get MIDI input device
1345 std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1346 if (!devices.count(DeviceId)) throw Exception("There is no midi input device with index " + ToString(DeviceId) + ".");
1347 MidiInputDevice* pDevice = devices[DeviceId];
1348
1349 // get midi port
1350 MidiInputPort* pPort = pDevice->GetPort(PortId);
1351 if (!pPort) throw Exception("Midi input device does not have port " + ToString(PortId) + ".");
1352
1353 // get desired port parameter
1354 std::map<String,DeviceRuntimeParameter*> parameters = pPort->PortParameters();
1355 if (!parameters.count(ParameterName)) throw Exception("Midi port does not provide a parameter '" + ParameterName + "'.");
1356 DeviceRuntimeParameter* pParameter = parameters[ParameterName];
1357
1358 // return all fields of this audio channel parameter
1359 result.Add("TYPE", pParameter->Type());
1360 result.Add("DESCRIPTION", pParameter->Description());
1361 result.Add("FIX", pParameter->Fix());
1362 result.Add("MULTIPLICITY", pParameter->Multiplicity());
1363 if (pParameter->RangeMin()) result.Add("RANGE_MIN", *pParameter->RangeMin());
1364 if (pParameter->RangeMax()) result.Add("RANGE_MAX", *pParameter->RangeMax());
1365 if (pParameter->Possibilities()) result.Add("POSSIBILITIES", *pParameter->Possibilities());
1366 }
1367 catch (Exception e) {
1368 result.Error(e);
1369 }
1370 return result.Produce();
1371 }
1372
1373 String LSCPServer::GetAudioOutputChannelParameterInfo(uint DeviceId, uint ChannelId, String ParameterName) {
1374 dmsg(2,("LSCPServer: GetAudioOutputChannelParameterInfo(DeviceId=%d,ChannelId=%d,ParameterName=%s)\n",DeviceId,ChannelId,ParameterName.c_str()));
1375 LSCPResultSet result;
1376 try {
1377 // get audio output device
1378 std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1379 if (!devices.count(DeviceId)) throw Exception("There is no audio output device with index " + ToString(DeviceId) + ".");
1380 AudioOutputDevice* pDevice = devices[DeviceId];
1381
1382 // get audio channel
1383 AudioChannel* pChannel = pDevice->Channel(ChannelId);
1384 if (!pChannel) throw Exception("Audio output device does not have audio channel " + ToString(ChannelId) + ".");
1385
1386 // get desired audio channel parameter
1387 std::map<String,DeviceRuntimeParameter*> parameters = pChannel->ChannelParameters();
1388 if (!parameters.count(ParameterName)) throw Exception("Audio channel does not provide a parameter '" + ParameterName + "'.");
1389 DeviceRuntimeParameter* pParameter = parameters[ParameterName];
1390
1391 // return all fields of this audio channel parameter
1392 result.Add("TYPE", pParameter->Type());
1393 result.Add("DESCRIPTION", pParameter->Description());
1394 result.Add("FIX", pParameter->Fix());
1395 result.Add("MULTIPLICITY", pParameter->Multiplicity());
1396 if (pParameter->RangeMin()) result.Add("RANGE_MIN", *pParameter->RangeMin());
1397 if (pParameter->RangeMax()) result.Add("RANGE_MAX", *pParameter->RangeMax());
1398 if (pParameter->Possibilities()) result.Add("POSSIBILITIES", *pParameter->Possibilities());
1399 }
1400 catch (Exception e) {
1401 result.Error(e);
1402 }
1403 return result.Produce();
1404 }
1405
1406 String LSCPServer::SetAudioOutputChannelParameter(uint DeviceId, uint ChannelId, String ParamKey, String ParamVal) {
1407 dmsg(2,("LSCPServer: SetAudioOutputChannelParameter(DeviceId=%d,ChannelId=%d,ParamKey=%s,ParamVal=%s)\n",DeviceId,ChannelId,ParamKey.c_str(),ParamVal.c_str()));
1408 LSCPResultSet result;
1409 try {
1410 // get audio output device
1411 std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1412 if (!devices.count(DeviceId)) throw Exception("There is no audio output device with index " + ToString(DeviceId) + ".");
1413 AudioOutputDevice* pDevice = devices[DeviceId];
1414
1415 // get audio channel
1416 AudioChannel* pChannel = pDevice->Channel(ChannelId);
1417 if (!pChannel) throw Exception("Audio output device does not have audio channel " + ToString(ChannelId) + ".");
1418
1419 // get desired audio channel parameter
1420 std::map<String,DeviceRuntimeParameter*> parameters = pChannel->ChannelParameters();
1421 if (!parameters.count(ParamKey)) throw Exception("Audio channel does not provide a parameter '" + ParamKey + "'.");
1422 DeviceRuntimeParameter* pParameter = parameters[ParamKey];
1423
1424 // set new channel parameter value
1425 pParameter->SetValue(ParamVal);
1426 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_audio_device_info, DeviceId));
1427 }
1428 catch (Exception e) {
1429 result.Error(e);
1430 }
1431 return result.Produce();
1432 }
1433
1434 String LSCPServer::SetAudioOutputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal) {
1435 dmsg(2,("LSCPServer: SetAudioOutputDeviceParameter(DeviceIndex=%d,ParamKey=%s,ParamVal=%s)\n",DeviceIndex,ParamKey.c_str(),ParamVal.c_str()));
1436 LSCPResultSet result;
1437 try {
1438 std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1439 if (!devices.count(DeviceIndex)) throw Exception("There is no audio output device with index " + ToString(DeviceIndex) + ".");
1440 AudioOutputDevice* pDevice = devices[DeviceIndex];
1441 std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
1442 if (!parameters.count(ParamKey)) throw Exception("Audio output device " + ToString(DeviceIndex) + " does not have a device parameter '" + ParamKey + "'");
1443 parameters[ParamKey]->SetValue(ParamVal);
1444 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_audio_device_info, DeviceIndex));
1445 }
1446 catch (Exception e) {
1447 result.Error(e);
1448 }
1449 return result.Produce();
1450 }
1451
1452 String LSCPServer::SetMidiInputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal) {
1453 dmsg(2,("LSCPServer: SetMidiOutputDeviceParameter(DeviceIndex=%d,ParamKey=%s,ParamVal=%s)\n",DeviceIndex,ParamKey.c_str(),ParamVal.c_str()));
1454 LSCPResultSet result;
1455 try {
1456 std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1457 if (!devices.count(DeviceIndex)) throw Exception("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
1458 MidiInputDevice* pDevice = devices[DeviceIndex];
1459 std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
1460 if (!parameters.count(ParamKey)) throw Exception("MIDI input device " + ToString(DeviceIndex) + " does not have a device parameter '" + ParamKey + "'");
1461 parameters[ParamKey]->SetValue(ParamVal);
1462 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_device_info, DeviceIndex));
1463 }
1464 catch (Exception e) {
1465 result.Error(e);
1466 }
1467 return result.Produce();
1468 }
1469
1470 String LSCPServer::SetMidiInputPortParameter(uint DeviceIndex, uint PortIndex, String ParamKey, String ParamVal) {
1471 dmsg(2,("LSCPServer: SetMidiOutputDeviceParameter(DeviceIndex=%d,ParamKey=%s,ParamVal=%s)\n",DeviceIndex,ParamKey.c_str(),ParamVal.c_str()));
1472 LSCPResultSet result;
1473 try {
1474 // get MIDI input device
1475 std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1476 if (!devices.count(DeviceIndex)) throw Exception("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
1477 MidiInputDevice* pDevice = devices[DeviceIndex];
1478
1479 // get MIDI port
1480 MidiInputPort* pMidiInputPort = pDevice->GetPort(PortIndex);
1481 if (!pMidiInputPort) throw Exception("There is no MIDI input port with index " + ToString(PortIndex) + ".");
1482
1483 // set port parameter value
1484 std::map<String,DeviceRuntimeParameter*> parameters = pMidiInputPort->PortParameters();
1485 if (!parameters.count(ParamKey)) throw Exception("MIDI input device " + ToString(PortIndex) + " does not have a parameter '" + ParamKey + "'");
1486 parameters[ParamKey]->SetValue(ParamVal);
1487 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_device_info, DeviceIndex));
1488 }
1489 catch (Exception e) {
1490 result.Error(e);
1491 }
1492 return result.Produce();
1493 }
1494
1495 /**
1496 * Will be called by the parser to change the audio output channel for
1497 * playback on a particular sampler channel.
1498 */
1499 String LSCPServer::SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel) {
1500 dmsg(2,("LSCPServer: SetAudioOutputChannel(ChannelAudioOutputChannel=%d, AudioOutputDeviceInputChannel=%d, SamplerChannel=%d)\n",ChannelAudioOutputChannel,AudioOutputDeviceInputChannel,uiSamplerChannel));
1501 LSCPResultSet result;
1502 try {
1503 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1504 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1505 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
1506 if (!pEngineChannel) throw Exception("No engine type yet assigned to sampler channel " + ToString(uiSamplerChannel));
1507 if (!pSamplerChannel->GetAudioOutputDevice()) throw Exception("No audio output device connected to sampler channel " + ToString(uiSamplerChannel));
1508 pEngineChannel->SetOutputChannel(ChannelAudioOutputChannel, AudioOutputDeviceInputChannel);
1509 }
1510 catch (Exception e) {
1511 result.Error(e);
1512 }
1513 return result.Produce();
1514 }
1515
1516 String LSCPServer::SetAudioOutputDevice(uint AudioDeviceId, uint uiSamplerChannel) {
1517 dmsg(2,("LSCPServer: SetAudiotOutputDevice(AudioDeviceId=%d, SamplerChannel=%d)\n",AudioDeviceId,uiSamplerChannel));
1518 LSCPResultSet result;
1519 LockRTNotify();
1520 try {
1521 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1522 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1523 std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1524 if (!devices.count(AudioDeviceId)) throw Exception("There is no audio output device with index " + ToString(AudioDeviceId));
1525 AudioOutputDevice* pDevice = devices[AudioDeviceId];
1526 pSamplerChannel->SetAudioOutputDevice(pDevice);
1527 }
1528 catch (Exception e) {
1529 result.Error(e);
1530 }
1531 UnlockRTNotify();
1532 return result.Produce();
1533 }
1534
1535 String LSCPServer::SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel) {
1536 dmsg(2,("LSCPServer: SetAudioOutputType(String AudioOutputDriver=%s, SamplerChannel=%d)\n",AudioOutputDriver.c_str(),uiSamplerChannel));
1537 LSCPResultSet result;
1538 LockRTNotify();
1539 try {
1540 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1541 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1542 // Driver type name aliasing...
1543 if (AudioOutputDriver == "Alsa") AudioOutputDriver = "ALSA";
1544 if (AudioOutputDriver == "Jack") AudioOutputDriver = "JACK";
1545 // Check if there's one audio output device already created
1546 // for the intended audio driver type (AudioOutputDriver)...
1547 AudioOutputDevice *pDevice = NULL;
1548 std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
1549 std::map<uint, AudioOutputDevice*>::iterator iter = devices.begin();
1550 for (; iter != devices.end(); iter++) {
1551 if ((iter->second)->Driver() == AudioOutputDriver) {
1552 pDevice = iter->second;
1553 break;
1554 }
1555 }
1556 // If it doesn't exist, create a new one with default parameters...
1557 if (pDevice == NULL) {
1558 std::map<String,String> params;
1559 pDevice = pSampler->CreateAudioOutputDevice(AudioOutputDriver, params);
1560 }
1561 // Must have a device...
1562 if (pDevice == NULL)
1563 throw Exception("Internal error: could not create audio output device.");
1564 // Set it as the current channel device...
1565 pSamplerChannel->SetAudioOutputDevice(pDevice);
1566 }
1567 catch (Exception e) {
1568 result.Error(e);
1569 }
1570 UnlockRTNotify();
1571 return result.Produce();
1572 }
1573
1574 String LSCPServer::SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel) {
1575 dmsg(2,("LSCPServer: SetMIDIInputPort(MIDIPort=%d, SamplerChannel=%d)\n",MIDIPort,uiSamplerChannel));
1576 LSCPResultSet result;
1577 try {
1578 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1579 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1580 pSamplerChannel->SetMidiInputPort(MIDIPort);
1581 }
1582 catch (Exception e) {
1583 result.Error(e);
1584 }
1585 return result.Produce();
1586 }
1587
1588 String LSCPServer::SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel) {
1589 dmsg(2,("LSCPServer: SetMIDIInputChannel(MIDIChannel=%d, SamplerChannel=%d)\n",MIDIChannel,uiSamplerChannel));
1590 LSCPResultSet result;
1591 try {
1592 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1593 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1594 pSamplerChannel->SetMidiInputChannel((midi_chan_t) MIDIChannel);
1595 }
1596 catch (Exception e) {
1597 result.Error(e);
1598 }
1599 return result.Produce();
1600 }
1601
1602 String LSCPServer::SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel) {
1603 dmsg(2,("LSCPServer: SetMIDIInputDevice(MIDIDeviceId=%d, SamplerChannel=%d)\n",MIDIDeviceId,uiSamplerChannel));
1604 LSCPResultSet result;
1605 try {
1606 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1607 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1608 std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1609 if (!devices.count(MIDIDeviceId)) throw Exception("There is no MIDI input device with index " + ToString(MIDIDeviceId));
1610 MidiInputDevice* pDevice = devices[MIDIDeviceId];
1611 pSamplerChannel->SetMidiInputDevice(pDevice);
1612 }
1613 catch (Exception e) {
1614 result.Error(e);
1615 }
1616 return result.Produce();
1617 }
1618
1619 String LSCPServer::SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel) {
1620 dmsg(2,("LSCPServer: SetMIDIInputType(String MidiInputDriver=%s, SamplerChannel=%d)\n",MidiInputDriver.c_str(),uiSamplerChannel));
1621 LSCPResultSet result;
1622 try {
1623 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1624 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1625 // Driver type name aliasing...
1626 if (MidiInputDriver == "Alsa") MidiInputDriver = "ALSA";
1627 // Check if there's one MIDI input device already created
1628 // for the intended MIDI driver type (MidiInputDriver)...
1629 MidiInputDevice *pDevice = NULL;
1630 std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1631 std::map<uint, MidiInputDevice*>::iterator iter = devices.begin();
1632 for (; iter != devices.end(); iter++) {
1633 if ((iter->second)->Driver() == MidiInputDriver) {
1634 pDevice = iter->second;
1635 break;
1636 }
1637 }
1638 // If it doesn't exist, create a new one with default parameters...
1639 if (pDevice == NULL) {
1640 std::map<String,String> params;
1641 pDevice = pSampler->CreateMidiInputDevice(MidiInputDriver, params);
1642 // Make it with at least one initial port.
1643 std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
1644 parameters["PORTS"]->SetValue("1");
1645 }
1646 // Must have a device...
1647 if (pDevice == NULL)
1648 throw Exception("Internal error: could not create MIDI input device.");
1649 // Set it as the current channel device...
1650 pSamplerChannel->SetMidiInputDevice(pDevice);
1651 }
1652 catch (Exception e) {
1653 result.Error(e);
1654 }
1655 return result.Produce();
1656 }
1657
1658 /**
1659 * Will be called by the parser to change the MIDI input device, port and channel on which
1660 * engine of a particular sampler channel should listen to.
1661 */
1662 String LSCPServer::SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel) {
1663 dmsg(2,("LSCPServer: SetMIDIInput(MIDIDeviceId=%d, MIDIPort=%d, MIDIChannel=%d, SamplerChannel=%d)\n", MIDIDeviceId, MIDIPort, MIDIChannel, uiSamplerChannel));
1664 LSCPResultSet result;
1665 try {
1666 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1667 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1668 std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
1669 if (!devices.count(MIDIDeviceId)) throw Exception("There is no MIDI input device with index " + ToString(MIDIDeviceId));
1670 MidiInputDevice* pDevice = devices[MIDIDeviceId];
1671 pSamplerChannel->SetMidiInput(pDevice, MIDIPort, (midi_chan_t) MIDIChannel);
1672 }
1673 catch (Exception e) {
1674 result.Error(e);
1675 }
1676 return result.Produce();
1677 }
1678
1679 /**
1680 * Will be called by the parser to change the global volume factor on a
1681 * particular sampler channel.
1682 */
1683 String LSCPServer::SetVolume(double dVolume, uint uiSamplerChannel) {
1684 dmsg(2,("LSCPServer: SetVolume(Volume=%f, SamplerChannel=%d)\n", dVolume, uiSamplerChannel));
1685 LSCPResultSet result;
1686 try {
1687 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1688 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1689 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
1690 if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
1691 pEngineChannel->Volume(dVolume);
1692 }
1693 catch (Exception e) {
1694 result.Error(e);
1695 }
1696 return result.Produce();
1697 }
1698
1699 /**
1700 * Will be called by the parser to mute/unmute particular sampler channel.
1701 */
1702 String LSCPServer::SetChannelMute(bool bMute, uint uiSamplerChannel) {
1703 dmsg(2,("LSCPServer: SetChannelMute(bMute=%d,uiSamplerChannel=%d)\n",bMute,uiSamplerChannel));
1704 LSCPResultSet result;
1705 try {
1706 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1707 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1708
1709 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
1710 if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
1711
1712 if(!bMute) pEngineChannel->SetMute((HasSoloChannel() && !pEngineChannel->GetSolo()) ? -1 : 0);
1713 else pEngineChannel->SetMute(1);
1714 } catch (Exception e) {
1715 result.Error(e);
1716 }
1717 return result.Produce();
1718 }
1719
1720 /**
1721 * Will be called by the parser to solo particular sampler channel.
1722 */
1723 String LSCPServer::SetChannelSolo(bool bSolo, uint uiSamplerChannel) {
1724 dmsg(2,("LSCPServer: SetChannelSolo(bSolo=%d,uiSamplerChannel=%d)\n",bSolo,uiSamplerChannel));
1725 LSCPResultSet result;
1726 try {
1727 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
1728 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
1729
1730 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
1731 if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
1732
1733 bool oldSolo = pEngineChannel->GetSolo();
1734 bool hadSoloChannel = HasSoloChannel();
1735
1736 pEngineChannel->SetSolo(bSolo);
1737
1738 if(!oldSolo && bSolo) {
1739 if(pEngineChannel->GetMute() == -1) pEngineChannel->SetMute(0);
1740 if(!hadSoloChannel) MuteNonSoloChannels();
1741 }
1742
1743 if(oldSolo && !bSolo) {
1744 if(!HasSoloChannel()) UnmuteChannels();
1745 else if(!pEngineChannel->GetMute()) pEngineChannel->SetMute(-1);
1746 }
1747 } catch (Exception e) {
1748 result.Error(e);
1749 }
1750 return result.Produce();
1751 }
1752
1753 /**
1754 * Determines whether there is at least one solo channel in the channel list.
1755 *
1756 * @returns true if there is at least one solo channel in the channel list,
1757 * false otherwise.
1758 */
1759 bool LSCPServer::HasSoloChannel() {
1760 std::map<uint,SamplerChannel*> channels = pSampler->GetSamplerChannels();
1761 std::map<uint,SamplerChannel*>::iterator iter = channels.begin();
1762 for (; iter != channels.end(); iter++) {
1763 EngineChannel* c = iter->second->GetEngineChannel();
1764 if(c && c->GetSolo()) return true;
1765 }
1766
1767 return false;
1768 }
1769
1770 /**
1771 * Mutes all unmuted non-solo channels. Notice that the channels are muted
1772 * with -1 which indicates that they are muted because of the presence
1773 * of a solo channel(s). Channels muted with -1 will be automatically unmuted
1774 * when there are no solo channels left.
1775 */
1776 void LSCPServer::MuteNonSoloChannels() {
1777 dmsg(2,("LSCPServer: MuteNonSoloChannels()\n"));
1778 std::map<uint,SamplerChannel*> channels = pSampler->GetSamplerChannels();
1779 std::map<uint,SamplerChannel*>::iterator iter = channels.begin();
1780 for (; iter != channels.end(); iter++) {
1781 EngineChannel* c = iter->second->GetEngineChannel();
1782 if(c && !c->GetSolo() && !c->GetMute()) c->SetMute(-1);
1783 }
1784 }
1785
1786 /**
1787 * Unmutes all channels that are muted because of the presence
1788 * of a solo channel(s).
1789 */
1790 void LSCPServer::UnmuteChannels() {
1791 dmsg(2,("LSCPServer: UnmuteChannels()\n"));
1792 std::map<uint,SamplerChannel*> channels = pSampler->GetSamplerChannels();
1793 std::map<uint,SamplerChannel*>::iterator iter = channels.begin();
1794 for (; iter != channels.end(); iter++) {
1795 EngineChannel* c = iter->second->GetEngineChannel();
1796 if(c && c->GetMute() == -1) c->SetMute(0);
1797 }
1798 }
1799
1800 String LSCPServer::AddOrReplaceMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg, String EngineType, String InstrumentFile, uint InstrumentIndex, float Volume, MidiInstrumentMapper::mode_t LoadMode, String Name, bool bModal) {
1801 dmsg(2,("LSCPServer: AddOrReplaceMIDIInstrumentMapping()\n"));
1802
1803 midi_prog_index_t idx;
1804 idx.midi_bank_msb = (MidiBank >> 7) & 0x7f;
1805 idx.midi_bank_lsb = MidiBank & 0x7f;
1806 idx.midi_prog = MidiProg;
1807
1808 MidiInstrumentMapper::entry_t entry;
1809 entry.EngineName = EngineType;
1810 entry.InstrumentFile = InstrumentFile;
1811 entry.InstrumentIndex = InstrumentIndex;
1812 entry.LoadMode = LoadMode;
1813 entry.Volume = Volume;
1814 entry.Name = Name;
1815
1816 LSCPResultSet result;
1817 try {
1818 // PERSISTENT mapping commands might block for a long time, so in
1819 // that case we add/replace the mapping in another thread in case
1820 // the NON_MODAL argument was supplied, non persistent mappings
1821 // should return immediately, so we don't need to do that for them
1822 bool bInBackground = (entry.LoadMode == MidiInstrumentMapper::PERSISTENT && !bModal);
1823 MidiInstrumentMapper::AddOrReplaceEntry(MidiMapID, idx, entry, bInBackground);
1824 } catch (Exception e) {
1825 result.Error(e);
1826 }
1827 return result.Produce();
1828 }
1829
1830 String LSCPServer::RemoveMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg) {
1831 dmsg(2,("LSCPServer: RemoveMIDIInstrumentMapping()\n"));
1832
1833 midi_prog_index_t idx;
1834 idx.midi_bank_msb = (MidiBank >> 7) & 0x7f;
1835 idx.midi_bank_lsb = MidiBank & 0x7f;
1836 idx.midi_prog = MidiProg;
1837
1838 LSCPResultSet result;
1839 try {
1840 MidiInstrumentMapper::RemoveEntry(MidiMapID, idx);
1841 } catch (Exception e) {
1842 result.Error(e);
1843 }
1844 return result.Produce();
1845 }
1846
1847 String LSCPServer::GetMidiInstrumentMappings(uint MidiMapID) {
1848 dmsg(2,("LSCPServer: GetMidiInstrumentMappings()\n"));
1849 LSCPResultSet result;
1850 try {
1851 result.Add(MidiInstrumentMapper::Entries(MidiMapID).size());
1852 } catch (Exception e) {
1853 result.Error(e);
1854 }
1855 return result.Produce();
1856 }
1857
1858
1859 String LSCPServer::GetAllMidiInstrumentMappings() {
1860 dmsg(2,("LSCPServer: GetAllMidiInstrumentMappings()\n"));
1861 LSCPResultSet result;
1862 std::vector<int> maps = MidiInstrumentMapper::Maps();
1863 int totalMappings = 0;
1864 for (int i = 0; i < maps.size(); i++) {
1865 try {
1866 totalMappings += MidiInstrumentMapper::Entries(maps[i]).size();
1867 } catch (Exception e) { /*NOOP*/ }
1868 }
1869 result.Add(totalMappings);
1870 return result.Produce();
1871 }
1872
1873 String LSCPServer::GetMidiInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg) {
1874 dmsg(2,("LSCPServer: GetMidiIstrumentMapping()\n"));
1875 LSCPResultSet result;
1876 try {
1877 midi_prog_index_t idx;
1878 idx.midi_bank_msb = (MidiBank >> 7) & 0x7f;
1879 idx.midi_bank_lsb = MidiBank & 0x7f;
1880 idx.midi_prog = MidiProg;
1881
1882 std::map<midi_prog_index_t,MidiInstrumentMapper::entry_t> mappings = MidiInstrumentMapper::Entries(MidiMapID);
1883 std::map<midi_prog_index_t,MidiInstrumentMapper::entry_t>::iterator iter = mappings.find(idx);
1884 if (iter == mappings.end()) result.Error("there is no map entry with that index");
1885 else { // found
1886
1887 // convert the filename into the correct encoding as defined for LSCP
1888 // (especially in terms of special characters -> escape sequences)
1889 #if WIN32
1890 const String instrumentFileName = Path::fromWindows(iter->second.InstrumentFile).toLscp();
1891 #else
1892 // assuming POSIX
1893 const String instrumentFileName = Path::fromPosix(iter->second.InstrumentFile).toLscp();
1894 #endif
1895
1896 result.Add("NAME", _escapeLscpResponse(iter->second.Name));
1897 result.Add("ENGINE_NAME", iter->second.EngineName);
1898 result.Add("INSTRUMENT_FILE", instrumentFileName);
1899 result.Add("INSTRUMENT_NR", (int) iter->second.InstrumentIndex);
1900 String instrumentName;
1901 Engine* pEngine = EngineFactory::Create(iter->second.EngineName);
1902 if (pEngine) {
1903 if (pEngine->GetInstrumentManager()) {
1904 InstrumentManager::instrument_id_t instrID;
1905 instrID.FileName = iter->second.InstrumentFile;
1906 instrID.Index = iter->second.InstrumentIndex;
1907 instrumentName = pEngine->GetInstrumentManager()->GetInstrumentName(instrID);
1908 }
1909 EngineFactory::Destroy(pEngine);
1910 }
1911 result.Add("INSTRUMENT_NAME", _escapeLscpResponse(instrumentName));
1912 switch (iter->second.LoadMode) {
1913 case MidiInstrumentMapper::ON_DEMAND:
1914 result.Add("LOAD_MODE", "ON_DEMAND");
1915 break;
1916 case MidiInstrumentMapper::ON_DEMAND_HOLD:
1917 result.Add("LOAD_MODE", "ON_DEMAND_HOLD");
1918 break;
1919 case MidiInstrumentMapper::PERSISTENT:
1920 result.Add("LOAD_MODE", "PERSISTENT");
1921 break;
1922 default:
1923 throw Exception("entry reflects invalid LOAD_MODE, consider this as a bug!");
1924 }
1925 result.Add("VOLUME", iter->second.Volume);
1926 }
1927 } catch (Exception e) {
1928 result.Error(e);
1929 }
1930 return result.Produce();
1931 }
1932
1933 String LSCPServer::ListMidiInstrumentMappings(uint MidiMapID) {
1934 dmsg(2,("LSCPServer: ListMidiInstrumentMappings()\n"));
1935 LSCPResultSet result;
1936 try {
1937 String s;
1938 std::map<midi_prog_index_t,MidiInstrumentMapper::entry_t> mappings = MidiInstrumentMapper::Entries(MidiMapID);
1939 std::map<midi_prog_index_t,MidiInstrumentMapper::entry_t>::iterator iter = mappings.begin();
1940 for (; iter != mappings.end(); iter++) {
1941 if (s.size()) s += ",";
1942 s += "{" + ToString(MidiMapID) + ","
1943 + ToString((int(iter->first.midi_bank_msb) << 7) | int(iter->first.midi_bank_lsb)) + ","
1944 + ToString(int(iter->first.midi_prog)) + "}";
1945 }
1946 result.Add(s);
1947 } catch (Exception e) {
1948 result.Error(e);
1949 }
1950 return result.Produce();
1951 }
1952
1953 String LSCPServer::ListAllMidiInstrumentMappings() {
1954 dmsg(2,("LSCPServer: ListAllMidiInstrumentMappings()\n"));
1955 LSCPResultSet result;
1956 try {
1957 std::vector<int> maps = MidiInstrumentMapper::Maps();
1958 String s;
1959 for (int i = 0; i < maps.size(); i++) {
1960 std::map<midi_prog_index_t,MidiInstrumentMapper::entry_t> mappings = MidiInstrumentMapper::Entries(maps[i]);
1961 std::map<midi_prog_index_t,MidiInstrumentMapper::entry_t>::iterator iter = mappings.begin();
1962 for (; iter != mappings.end(); iter++) {
1963 if (s.size()) s += ",";
1964 s += "{" + ToString(maps[i]) + ","
1965 + ToString((int(iter->first.midi_bank_msb) << 7) | int(iter->first.midi_bank_lsb)) + ","
1966 + ToString(int(iter->first.midi_prog)) + "}";
1967 }
1968 }
1969 result.Add(s);
1970 } catch (Exception e) {
1971 result.Error(e);
1972 }
1973 return result.Produce();
1974 }
1975
1976 String LSCPServer::ClearMidiInstrumentMappings(uint MidiMapID) {
1977 dmsg(2,("LSCPServer: ClearMidiInstrumentMappings()\n"));
1978 LSCPResultSet result;
1979 try {
1980 MidiInstrumentMapper::RemoveAllEntries(MidiMapID);
1981 } catch (Exception e) {
1982 result.Error(e);
1983 }
1984 return result.Produce();
1985 }
1986
1987 String LSCPServer::ClearAllMidiInstrumentMappings() {
1988 dmsg(2,("LSCPServer: ClearAllMidiInstrumentMappings()\n"));
1989 LSCPResultSet result;
1990 try {
1991 std::vector<int> maps = MidiInstrumentMapper::Maps();
1992 for (int i = 0; i < maps.size(); i++)
1993 MidiInstrumentMapper::RemoveAllEntries(maps[i]);
1994 } catch (Exception e) {
1995 result.Error(e);
1996 }
1997 return result.Produce();
1998 }
1999
2000 String LSCPServer::AddMidiInstrumentMap(String MapName) {
2001 dmsg(2,("LSCPServer: AddMidiInstrumentMap()\n"));
2002 LSCPResultSet result;
2003 try {
2004 int MapID = MidiInstrumentMapper::AddMap(MapName);
2005 result = LSCPResultSet(MapID);
2006 } catch (Exception e) {
2007 result.Error(e);
2008 }
2009 return result.Produce();
2010 }
2011
2012 String LSCPServer::RemoveMidiInstrumentMap(uint MidiMapID) {
2013 dmsg(2,("LSCPServer: RemoveMidiInstrumentMap()\n"));
2014 LSCPResultSet result;
2015 try {
2016 MidiInstrumentMapper::RemoveMap(MidiMapID);
2017 } catch (Exception e) {
2018 result.Error(e);
2019 }
2020 return result.Produce();
2021 }
2022
2023 String LSCPServer::RemoveAllMidiInstrumentMaps() {
2024 dmsg(2,("LSCPServer: RemoveAllMidiInstrumentMaps()\n"));
2025 LSCPResultSet result;
2026 try {
2027 MidiInstrumentMapper::RemoveAllMaps();
2028 } catch (Exception e) {
2029 result.Error(e);
2030 }
2031 return result.Produce();
2032 }
2033
2034 String LSCPServer::GetMidiInstrumentMaps() {
2035 dmsg(2,("LSCPServer: GetMidiInstrumentMaps()\n"));
2036 LSCPResultSet result;
2037 try {
2038 result.Add(MidiInstrumentMapper::Maps().size());
2039 } catch (Exception e) {
2040 result.Error(e);
2041 }
2042 return result.Produce();
2043 }
2044
2045 String LSCPServer::ListMidiInstrumentMaps() {
2046 dmsg(2,("LSCPServer: ListMidiInstrumentMaps()\n"));
2047 LSCPResultSet result;
2048 try {
2049 std::vector<int> maps = MidiInstrumentMapper::Maps();
2050 String sList;
2051 for (int i = 0; i < maps.size(); i++) {
2052 if (sList != "") sList += ",";
2053 sList += ToString(maps[i]);
2054 }
2055 result.Add(sList);
2056 } catch (Exception e) {
2057 result.Error(e);
2058 }
2059 return result.Produce();
2060 }
2061
2062 String LSCPServer::GetMidiInstrumentMap(uint MidiMapID) {
2063 dmsg(2,("LSCPServer: GetMidiInstrumentMap()\n"));
2064 LSCPResultSet result;
2065 try {
2066 result.Add("NAME", _escapeLscpResponse(MidiInstrumentMapper::MapName(MidiMapID)));
2067 result.Add("DEFAULT", MidiInstrumentMapper::GetDefaultMap() == MidiMapID);
2068 } catch (Exception e) {
2069 result.Error(e);
2070 }
2071 return result.Produce();
2072 }
2073
2074 String LSCPServer::SetMidiInstrumentMapName(uint MidiMapID, String NewName) {
2075 dmsg(2,("LSCPServer: SetMidiInstrumentMapName()\n"));
2076 LSCPResultSet result;
2077 try {
2078 MidiInstrumentMapper::RenameMap(MidiMapID, NewName);
2079 } catch (Exception e) {
2080 result.Error(e);
2081 }
2082 return result.Produce();
2083 }
2084
2085 /**
2086 * Set the MIDI instrument map the given sampler channel shall use for
2087 * handling MIDI program change messages. There are the following two
2088 * special (negative) values:
2089 *
2090 * - (-1) : set to NONE (ignore program changes)
2091 * - (-2) : set to DEFAULT map
2092 */
2093 String LSCPServer::SetChannelMap(uint uiSamplerChannel, int MidiMapID) {
2094 dmsg(2,("LSCPServer: SetChannelMap()\n"));
2095 LSCPResultSet result;
2096 try {
2097 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
2098 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
2099
2100 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
2101 if (!pEngineChannel) throw Exception("There is no engine deployed on this sampler channel yet");
2102
2103 if (MidiMapID == -1) pEngineChannel->SetMidiInstrumentMapToNone();
2104 else if (MidiMapID == -2) pEngineChannel->SetMidiInstrumentMapToDefault();
2105 else pEngineChannel->SetMidiInstrumentMap(MidiMapID);
2106 } catch (Exception e) {
2107 result.Error(e);
2108 }
2109 return result.Produce();
2110 }
2111
2112 String LSCPServer::CreateFxSend(uint uiSamplerChannel, uint MidiCtrl, String Name) {
2113 dmsg(2,("LSCPServer: CreateFxSend()\n"));
2114 LSCPResultSet result;
2115 try {
2116 EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
2117
2118 FxSend* pFxSend = pEngineChannel->AddFxSend(MidiCtrl, Name);
2119 if (!pFxSend) throw Exception("Could not add FxSend, don't ask, I don't know why (probably a bug)");
2120
2121 result = LSCPResultSet(pFxSend->Id()); // success
2122 } catch (Exception e) {
2123 result.Error(e);
2124 }
2125 return result.Produce();
2126 }
2127
2128 String LSCPServer::DestroyFxSend(uint uiSamplerChannel, uint FxSendID) {
2129 dmsg(2,("LSCPServer: DestroyFxSend()\n"));
2130 LSCPResultSet result;
2131 try {
2132 EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
2133
2134 FxSend* pFxSend = NULL;
2135 for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {
2136 if (pEngineChannel->GetFxSend(i)->Id() == FxSendID) {
2137 pFxSend = pEngineChannel->GetFxSend(i);
2138 break;
2139 }
2140 }
2141 if (!pFxSend) throw Exception("There is no FxSend with that ID on the given sampler channel");
2142 pEngineChannel->RemoveFxSend(pFxSend);
2143 } catch (Exception e) {
2144 result.Error(e);
2145 }
2146 return result.Produce();
2147 }
2148
2149 String LSCPServer::GetFxSends(uint uiSamplerChannel) {
2150 dmsg(2,("LSCPServer: GetFxSends()\n"));
2151 LSCPResultSet result;
2152 try {
2153 EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
2154
2155 result.Add(pEngineChannel->GetFxSendCount());
2156 } catch (Exception e) {
2157 result.Error(e);
2158 }
2159 return result.Produce();
2160 }
2161
2162 String LSCPServer::ListFxSends(uint uiSamplerChannel) {
2163 dmsg(2,("LSCPServer: ListFxSends()\n"));
2164 LSCPResultSet result;
2165 String list;
2166 try {
2167 EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
2168
2169 for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {
2170 FxSend* pFxSend = pEngineChannel->GetFxSend(i);
2171 if (list != "") list += ",";
2172 list += ToString(pFxSend->Id());
2173 }
2174 result.Add(list);
2175 } catch (Exception e) {
2176 result.Error(e);
2177 }
2178 return result.Produce();
2179 }
2180
2181 FxSend* LSCPServer::GetFxSend(uint uiSamplerChannel, uint FxSendID) {
2182 EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
2183
2184 FxSend* pFxSend = NULL;
2185 for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {
2186 if (pEngineChannel->GetFxSend(i)->Id() == FxSendID) {
2187 pFxSend = pEngineChannel->GetFxSend(i);
2188 break;
2189 }
2190 }
2191 if (!pFxSend) throw Exception("There is no FxSend with that ID on the given sampler channel");
2192 return pFxSend;
2193 }
2194
2195 String LSCPServer::GetFxSendInfo(uint uiSamplerChannel, uint FxSendID) {
2196 dmsg(2,("LSCPServer: GetFxSendInfo()\n"));
2197 LSCPResultSet result;
2198 try {
2199 EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
2200 FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
2201
2202 // gather audio routing informations
2203 String AudioRouting;
2204 for (int chan = 0; chan < pEngineChannel->Channels(); chan++) {
2205 if (AudioRouting != "") AudioRouting += ",";
2206 AudioRouting += ToString(pFxSend->DestinationChannel(chan));
2207 }
2208
2209 // success
2210 result.Add("NAME", _escapeLscpResponse(pFxSend->Name()));
2211 result.Add("MIDI_CONTROLLER", pFxSend->MidiController());
2212 result.Add("LEVEL", ToString(pFxSend->Level()));
2213 result.Add("AUDIO_OUTPUT_ROUTING", AudioRouting);
2214 } catch (Exception e) {
2215 result.Error(e);
2216 }
2217 return result.Produce();
2218 }
2219
2220 String LSCPServer::SetFxSendName(uint uiSamplerChannel, uint FxSendID, String Name) {
2221 dmsg(2,("LSCPServer: SetFxSendName()\n"));
2222 LSCPResultSet result;
2223 try {
2224 FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
2225
2226 pFxSend->SetName(Name);
2227 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, uiSamplerChannel, FxSendID));
2228 } catch (Exception e) {
2229 result.Error(e);
2230 }
2231 return result.Produce();
2232 }
2233
2234 String LSCPServer::SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel) {
2235 dmsg(2,("LSCPServer: SetFxSendAudioOutputChannel()\n"));
2236 LSCPResultSet result;
2237 try {
2238 FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
2239
2240 pFxSend->SetDestinationChannel(FxSendChannel, DeviceChannel);
2241 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, uiSamplerChannel, FxSendID));
2242 } catch (Exception e) {
2243 result.Error(e);
2244 }
2245 return result.Produce();
2246 }
2247
2248 String LSCPServer::SetFxSendMidiController(uint uiSamplerChannel, uint FxSendID, uint MidiController) {
2249 dmsg(2,("LSCPServer: SetFxSendMidiController()\n"));
2250 LSCPResultSet result;
2251 try {
2252 FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
2253
2254 pFxSend->SetMidiController(MidiController);
2255 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, uiSamplerChannel, FxSendID));
2256 } catch (Exception e) {
2257 result.Error(e);
2258 }
2259 return result.Produce();
2260 }
2261
2262 String LSCPServer::SetFxSendLevel(uint uiSamplerChannel, uint FxSendID, double dLevel) {
2263 dmsg(2,("LSCPServer: SetFxSendLevel()\n"));
2264 LSCPResultSet result;
2265 try {
2266 FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
2267
2268 pFxSend->SetLevel((float)dLevel);
2269 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, uiSamplerChannel, FxSendID));
2270 } catch (Exception e) {
2271 result.Error(e);
2272 }
2273 return result.Produce();
2274 }
2275
2276 String LSCPServer::EditSamplerChannelInstrument(uint uiSamplerChannel) {
2277 dmsg(2,("LSCPServer: EditSamplerChannelInstrument(SamplerChannel=%d)\n", uiSamplerChannel));
2278 LSCPResultSet result;
2279 try {
2280 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
2281 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
2282 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
2283 if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
2284 if (pEngineChannel->InstrumentStatus() < 0) throw Exception("No instrument loaded to sampler channel");
2285 Engine* pEngine = pEngineChannel->GetEngine();
2286 InstrumentManager* pInstrumentManager = pEngine->GetInstrumentManager();
2287 if (!pInstrumentManager) throw Exception("Engine does not provide an instrument manager");
2288 InstrumentManager::instrument_id_t instrumentID;
2289 instrumentID.FileName = pEngineChannel->InstrumentFileName();
2290 instrumentID.Index = pEngineChannel->InstrumentIndex();
2291 pInstrumentManager->LaunchInstrumentEditor(instrumentID);
2292 } catch (Exception e) {
2293 result.Error(e);
2294 }
2295 return result.Produce();
2296 }
2297
2298 /**
2299 * Will be called by the parser to reset a particular sampler channel.
2300 */
2301 String LSCPServer::ResetChannel(uint uiSamplerChannel) {
2302 dmsg(2,("LSCPServer: ResetChannel(SamplerChannel=%d)\n", uiSamplerChannel));
2303 LSCPResultSet result;
2304 try {
2305 SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
2306 if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
2307 EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
2308 if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
2309 pEngineChannel->Reset();
2310 }
2311 catch (Exception e) {
2312 result.Error(e);
2313 }
2314 return result.Produce();
2315 }
2316
2317 /**
2318 * Will be called by the parser to reset the whole sampler.
2319 */
2320 String LSCPServer::ResetSampler() {
2321 dmsg(2,("LSCPServer: ResetSampler()\n"));
2322 pSampler->Reset();
2323 LSCPResultSet result;
2324 return result.Produce();
2325 }
2326
2327 /**
2328 * Will be called by the parser to return general informations about this
2329 * sampler.
2330 */
2331 String LSCPServer::GetServerInfo() {
2332 dmsg(2,("LSCPServer: GetServerInfo()\n"));
2333 const std::string description =
2334 _escapeLscpResponse("LinuxSampler - modular, streaming capable sampler");
2335 LSCPResultSet result;
2336 result.Add("DESCRIPTION", description);
2337 result.Add("VERSION", VERSION);
2338 result.Add("PROTOCOL_VERSION", ToString(LSCP_RELEASE_MAJOR) + "." + ToString(LSCP_RELEASE_MINOR));
2339 #if HAVE_SQLITE3
2340 result.Add("INSTRUMENTS_DB_SUPPORT", "yes");
2341 #else
2342 result.Add("INSTRUMENTS_DB_SUPPORT", "no");
2343 #endif
2344
2345 return result.Produce();
2346 }
2347
2348 /**
2349 * Will be called by the parser to return the current number of all active voices.
2350 */
2351 String LSCPServer::GetTotalVoiceCount() {
2352 dmsg(2,("LSCPServer: GetTotalVoiceCount()\n"));
2353 LSCPResultSet result;
2354 result.Add(pSampler->GetVoiceCount());
2355 return result.Produce();
2356 }
2357
2358 /**
2359 * Will be called by the parser to return the maximum number of voices.
2360 */
2361 String LSCPServer::GetTotalVoiceCountMax() {
2362 dmsg(2,("LSCPServer: GetTotalVoiceCountMax()\n"));
2363 LSCPResultSet result;
2364 result.Add(EngineFactory::EngineInstances().size() * CONFIG_MAX_VOICES);
2365 return result.Produce();
2366 }
2367
2368 String LSCPServer::GetGlobalVolume() {
2369 LSCPResultSet result;
2370 result.Add(ToString(GLOBAL_VOLUME)); // see common/global.cpp
2371 return result.Produce();
2372 }
2373
2374 String LSCPServer::SetGlobalVolume(double dVolume) {
2375 LSCPResultSet result;
2376 try {
2377 if (dVolume < 0) throw Exception("Volume may not be negative");
2378 GLOBAL_VOLUME = dVolume; // see common/global.cpp
2379 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_global_info, "VOLUME", GLOBAL_VOLUME));
2380 } catch (Exception e) {
2381 result.Error(e);
2382 }
2383 return result.Produce();
2384 }
2385
2386 String LSCPServer::GetFileInstruments(String Filename) {
2387 LSCPResultSet result;
2388 // try to find a sampler engine that can handle the file
2389 bool bFound = false;
2390 std::vector<String> engineTypes = EngineFactory::AvailableEngineTypes();
2391 for (int i = 0; !bFound && i < engineTypes.size(); i++) {
2392 Engine* pEngine = NULL;
2393 try {
2394 pEngine = EngineFactory::Create(engineTypes[i]);
2395 if (!pEngine) throw Exception("Internal error: could not create '" + engineTypes[i] + "' engine");
2396 InstrumentManager* pManager = pEngine->GetInstrumentManager();
2397 if (pManager) {
2398 std::vector<InstrumentManager::instrument_id_t> IDs =
2399 pManager->GetInstrumentFileContent(Filename);
2400 // return the amount of instruments in the file
2401 result.Add(IDs.size());
2402 // no more need to ask other engine types
2403 bFound = true;
2404 } else dmsg(1,("Warning: engine '%s' does not provide an instrument manager\n", engineTypes[i].c_str()));
2405 } catch (Exception e) {
2406 // NOOP, as exception is thrown if engine doesn't support file
2407 }
2408 if (pEngine) EngineFactory::Destroy(pEngine);
2409 }
2410 return result.Produce();
2411 }
2412
2413 String LSCPServer::ListFileInstruments(String Filename) {
2414 LSCPResultSet result;
2415 // try to find a sampler engine that can handle the file
2416 bool bFound = false;
2417 std::vector<String> engineTypes = EngineFactory::AvailableEngineTypes();
2418 for (int i = 0; !bFound && i < engineTypes.size(); i++) {
2419 Engine* pEngine = NULL;
2420 try {
2421 pEngine = EngineFactory::Create(engineTypes[i]);
2422 if (!pEngine) throw Exception("Internal error: could not create '" + engineTypes[i] + "' engine");
2423 InstrumentManager* pManager = pEngine->GetInstrumentManager();
2424 if (pManager) {
2425 std::vector<InstrumentManager::instrument_id_t> IDs =
2426 pManager->GetInstrumentFileContent(Filename);
2427 // return a list of IDs of the instruments in the file
2428 String s;
2429 for (int j = 0; j < IDs.size(); j++) {
2430 if (s.size()) s += ",";
2431 s += ToString(IDs[j].Index);
2432 }
2433 result.Add(s);
2434 // no more need to ask other engine types
2435 bFound = true;
2436 } else dmsg(1,("Warning: engine '%s' does not provide an instrument manager\n", engineTypes[i].c_str()));
2437 } catch (Exception e) {
2438 // NOOP, as exception is thrown if engine doesn't support file
2439 }
2440 if (pEngine) EngineFactory::Destroy(pEngine);
2441 }
2442 return result.Produce();
2443 }
2444
2445 String LSCPServer::GetFileInstrumentInfo(String Filename, uint InstrumentID) {
2446 LSCPResultSet result;
2447 InstrumentManager::instrument_id_t id;
2448 id.FileName = Filename;
2449 id.Index = InstrumentID;
2450 // try to find a sampler engine that can handle the file
2451 bool bFound = false;
2452 std::vector<String> engineTypes = EngineFactory::AvailableEngineTypes();
2453 for (int i = 0; !bFound && i < engineTypes.size(); i++) {
2454 Engine* pEngine = NULL;
2455 try {
2456 pEngine = EngineFactory::Create(engineTypes[i]);
2457 if (!pEngine) throw Exception("Internal error: could not create '" + engineTypes[i] + "' engine");
2458 InstrumentManager* pManager = pEngine->GetInstrumentManager();
2459 if (pManager) {
2460 InstrumentManager::instrument_info_t info =
2461 pManager->GetInstrumentInfo(id);
2462 // return detailed informations about the file
2463 result.Add("NAME", info.InstrumentName);
2464 result.Add("FORMAT_NAME", engineTypes[i]);
2465 result.Add("FORMAT_VERSION", info.FormatVersion);
2466 result.Add("PRODUCT", info.Product);
2467 result.Add("ARTISTS", info.Artists);
2468 // no more need to ask other engine types
2469 bFound = true;
2470 } else dmsg(1,("Warning: engine '%s' does not provide an instrument manager\n", engineTypes[i].c_str()));
2471 } catch (Exception e) {
2472 // NOOP, as exception is thrown if engine doesn't support file
2473 }
2474 if (pEngine) EngineFactory::Destroy(pEngine);
2475 }
2476 return result.Produce();
2477 }
2478
2479 /**
2480 * Will be called by the parser to subscribe a client (frontend) on the
2481 * server for receiving event messages.
2482 */
2483 String LSCPServer::SubscribeNotification(LSCPEvent::event_t type) {
2484 dmsg(2,("LSCPServer: SubscribeNotification(Event=%s)\n", LSCPEvent::Name(type).c_str()));
2485 LSCPResultSet result;
2486 SubscriptionMutex.Lock();
2487 eventSubscriptions[type].push_back(currentSocket);
2488 SubscriptionMutex.Unlock();
2489 return result.Produce();
2490 }
2491
2492 /**
2493 * Will be called by the parser to unsubscribe a client on the server
2494 * for not receiving further event messages.
2495 */
2496 String LSCPServer::UnsubscribeNotification(LSCPEvent::event_t type) {
2497 dmsg(2,("LSCPServer: UnsubscribeNotification(Event=%s)\n", LSCPEvent::Name(type).c_str()));
2498 LSCPResultSet result;
2499 SubscriptionMutex.Lock();
2500 eventSubscriptions[type].remove(currentSocket);
2501 SubscriptionMutex.Unlock();
2502 return result.Produce();
2503 }
2504
2505 String LSCPServer::AddDbInstrumentDirectory(String Dir) {
2506 dmsg(2,("LSCPServer: AddDbInstrumentDirectory(Dir=%s)\n", Dir.c_str()));
2507 LSCPResultSet result;
2508 #if HAVE_SQLITE3
2509 try {
2510 InstrumentsDb::GetInstrumentsDb()->AddDirectory(Dir);
2511 } catch (Exception e) {
2512 result.Error(e);
2513 }
2514 #else
2515 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2516 #endif
2517 return result.Produce();
2518 }
2519
2520 String LSCPServer::RemoveDbInstrumentDirectory(String Dir, bool Force) {
2521 dmsg(2,("LSCPServer: RemoveDbInstrumentDirectory(Dir=%s,Force=%d)\n", Dir.c_str(), Force));
2522 LSCPResultSet result;
2523 #if HAVE_SQLITE3
2524 try {
2525 InstrumentsDb::GetInstrumentsDb()->RemoveDirectory(Dir, Force);
2526 } catch (Exception e) {
2527 result.Error(e);
2528 }
2529 #else
2530 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2531 #endif
2532 return result.Produce();
2533 }
2534
2535 String LSCPServer::GetDbInstrumentDirectoryCount(String Dir, bool Recursive) {
2536 dmsg(2,("LSCPServer: GetDbInstrumentDirectoryCount(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
2537 LSCPResultSet result;
2538 #if HAVE_SQLITE3
2539 try {
2540 result.Add(InstrumentsDb::GetInstrumentsDb()->GetDirectoryCount(Dir, Recursive));
2541 } catch (Exception e) {
2542 result.Error(e);
2543 }
2544 #else
2545 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2546 #endif
2547 return result.Produce();
2548 }
2549
2550 String LSCPServer::GetDbInstrumentDirectories(String Dir, bool Recursive) {
2551 dmsg(2,("LSCPServer: GetDbInstrumentDirectories(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
2552 LSCPResultSet result;
2553 #if HAVE_SQLITE3
2554 try {
2555 String list;
2556 StringListPtr dirs = InstrumentsDb::GetInstrumentsDb()->GetDirectories(Dir, Recursive);
2557
2558 for (int i = 0; i < dirs->size(); i++) {
2559 if (list != "") list += ",";
2560 list += "'" + InstrumentsDb::toEscapedPath(dirs->at(i)) + "'";
2561 }
2562
2563 result.Add(list);
2564 } catch (Exception e) {
2565 result.Error(e);
2566 }
2567 #else
2568 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2569 #endif
2570 return result.Produce();
2571 }
2572
2573 String LSCPServer::GetDbInstrumentDirectoryInfo(String Dir) {
2574 dmsg(2,("LSCPServer: GetDbInstrumentDirectoryInfo(Dir=%s)\n", Dir.c_str()));
2575 LSCPResultSet result;
2576 #if HAVE_SQLITE3
2577 try {
2578 DbDirectory info = InstrumentsDb::GetInstrumentsDb()->GetDirectoryInfo(Dir);
2579
2580 result.Add("DESCRIPTION", _escapeLscpResponse(info.Description));
2581 result.Add("CREATED", info.Created);
2582 result.Add("MODIFIED", info.Modified);
2583 } catch (Exception e) {
2584 result.Error(e);
2585 }
2586 #else
2587 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2588 #endif
2589 return result.Produce();
2590 }
2591
2592 String LSCPServer::SetDbInstrumentDirectoryName(String Dir, String Name) {
2593 dmsg(2,("LSCPServer: SetDbInstrumentDirectoryName(Dir=%s,Name=%s)\n", Dir.c_str(), Name.c_str()));
2594 LSCPResultSet result;
2595 #if HAVE_SQLITE3
2596 try {
2597 InstrumentsDb::GetInstrumentsDb()->RenameDirectory(Dir, Name);
2598 } catch (Exception e) {
2599 result.Error(e);
2600 }
2601 #else
2602 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2603 #endif
2604 return result.Produce();
2605 }
2606
2607 String LSCPServer::MoveDbInstrumentDirectory(String Dir, String Dst) {
2608 dmsg(2,("LSCPServer: MoveDbInstrumentDirectory(Dir=%s,Dst=%s)\n", Dir.c_str(), Dst.c_str()));
2609 LSCPResultSet result;
2610 #if HAVE_SQLITE3
2611 try {
2612 InstrumentsDb::GetInstrumentsDb()->MoveDirectory(Dir, Dst);
2613 } catch (Exception e) {
2614 result.Error(e);
2615 }
2616 #else
2617 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2618 #endif
2619 return result.Produce();
2620 }
2621
2622 String LSCPServer::CopyDbInstrumentDirectory(String Dir, String Dst) {
2623 dmsg(2,("LSCPServer: CopyDbInstrumentDirectory(Dir=%s,Dst=%s)\n", Dir.c_str(), Dst.c_str()));
2624 LSCPResultSet result;
2625 #if HAVE_SQLITE3
2626 try {
2627 InstrumentsDb::GetInstrumentsDb()->CopyDirectory(Dir, Dst);
2628 } catch (Exception e) {
2629 result.Error(e);
2630 }
2631 #else
2632 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2633 #endif
2634 return result.Produce();
2635 }
2636
2637 String LSCPServer::SetDbInstrumentDirectoryDescription(String Dir, String Desc) {
2638 dmsg(2,("LSCPServer: SetDbInstrumentDirectoryDescription(Dir=%s,Desc=%s)\n", Dir.c_str(), Desc.c_str()));
2639 LSCPResultSet result;
2640 #if HAVE_SQLITE3
2641 try {
2642 InstrumentsDb::GetInstrumentsDb()->SetDirectoryDescription(Dir, Desc);
2643 } catch (Exception e) {
2644 result.Error(e);
2645 }
2646 #else
2647 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2648 #endif
2649 return result.Produce();
2650 }
2651
2652 String LSCPServer::AddDbInstruments(String DbDir, String FilePath, int Index, bool bBackground) {
2653 dmsg(2,("LSCPServer: AddDbInstruments(DbDir=%s,FilePath=%s,Index=%d,bBackground=%d)\n", DbDir.c_str(), FilePath.c_str(), Index, bBackground));
2654 LSCPResultSet result;
2655 #if HAVE_SQLITE3
2656 try {
2657 int id;
2658 InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
2659 id = db->AddInstruments(DbDir, FilePath, Index, bBackground);
2660 if (bBackground) result = id;
2661 } catch (Exception e) {
2662 result.Error(e);
2663 }
2664 #else
2665 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2666 #endif
2667 return result.Produce();
2668 }
2669
2670 String LSCPServer::AddDbInstruments(String ScanMode, String DbDir, String FsDir, bool bBackground) {
2671 dmsg(2,("LSCPServer: AddDbInstruments(ScanMode=%s,DbDir=%s,FsDir=%s,bBackground=%d)\n", ScanMode.c_str(), DbDir.c_str(), FsDir.c_str(), bBackground));
2672 LSCPResultSet result;
2673 #if HAVE_SQLITE3
2674 try {
2675 int id;
2676 InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
2677 if (ScanMode.compare("RECURSIVE") == 0) {
2678 id = db->AddInstruments(RECURSIVE, DbDir, FsDir, bBackground);
2679 } else if (ScanMode.compare("NON_RECURSIVE") == 0) {
2680 id = db->AddInstruments(NON_RECURSIVE, DbDir, FsDir, bBackground);
2681 } else if (ScanMode.compare("FLAT") == 0) {
2682 id = db->AddInstruments(FLAT, DbDir, FsDir, bBackground);
2683 } else {
2684 throw Exception("Unknown scan mode: " + ScanMode);
2685 }
2686
2687 if (bBackground) result = id;
2688 } catch (Exception e) {
2689 result.Error(e);
2690 }
2691 #else
2692 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2693 #endif
2694 return result.Produce();
2695 }
2696
2697 String LSCPServer::RemoveDbInstrument(String Instr) {
2698 dmsg(2,("LSCPServer: RemoveDbInstrument(Instr=%s)\n", Instr.c_str()));
2699 LSCPResultSet result;
2700 #if HAVE_SQLITE3
2701 try {
2702 InstrumentsDb::GetInstrumentsDb()->RemoveInstrument(Instr);
2703 } catch (Exception e) {
2704 result.Error(e);
2705 }
2706 #else
2707 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2708 #endif
2709 return result.Produce();
2710 }
2711
2712 String LSCPServer::GetDbInstrumentCount(String Dir, bool Recursive) {
2713 dmsg(2,("LSCPServer: GetDbInstrumentCount(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
2714 LSCPResultSet result;
2715 #if HAVE_SQLITE3
2716 try {
2717 result.Add(InstrumentsDb::GetInstrumentsDb()->GetInstrumentCount(Dir, Recursive));
2718 } catch (Exception e) {
2719 result.Error(e);
2720 }
2721 #else
2722 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2723 #endif
2724 return result.Produce();
2725 }
2726
2727 String LSCPServer::GetDbInstruments(String Dir, bool Recursive) {
2728 dmsg(2,("LSCPServer: GetDbInstruments(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
2729 LSCPResultSet result;
2730 #if HAVE_SQLITE3
2731 try {
2732 String list;
2733 StringListPtr instrs = InstrumentsDb::GetInstrumentsDb()->GetInstruments(Dir, Recursive);
2734
2735 for (int i = 0; i < instrs->size(); i++) {
2736 if (list != "") list += ",";
2737 list += "'" + InstrumentsDb::toEscapedPath(instrs->at(i)) + "'";
2738 }
2739
2740 result.Add(list);
2741 } catch (Exception e) {
2742 result.Error(e);
2743 }
2744 #else
2745 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2746 #endif
2747 return result.Produce();
2748 }
2749
2750 String LSCPServer::GetDbInstrumentInfo(String Instr) {
2751 dmsg(2,("LSCPServer: GetDbInstrumentInfo(Instr=%s)\n", Instr.c_str()));
2752 LSCPResultSet result;
2753 #if HAVE_SQLITE3
2754 try {
2755 DbInstrument info = InstrumentsDb::GetInstrumentsDb()->GetInstrumentInfo(Instr);
2756
2757 result.Add("INSTRUMENT_FILE", info.InstrFile);
2758 result.Add("INSTRUMENT_NR", info.InstrNr);
2759 result.Add("FORMAT_FAMILY", info.FormatFamily);
2760 result.Add("FORMAT_VERSION", info.FormatVersion);
2761 result.Add("SIZE", (int)info.Size);
2762 result.Add("CREATED", info.Created);
2763 result.Add("MODIFIED", info.Modified);
2764 result.Add("DESCRIPTION", _escapeLscpResponse(info.Description));
2765 result.Add("IS_DRUM", info.IsDrum);
2766 result.Add("PRODUCT", _escapeLscpResponse(info.Product));
2767 result.Add("ARTISTS", _escapeLscpResponse(info.Artists));
2768 result.Add("KEYWORDS", _escapeLscpResponse(info.Keywords));
2769 } catch (Exception e) {
2770 result.Error(e);
2771 }
2772 #else
2773 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2774 #endif
2775 return result.Produce();
2776 }
2777
2778 String LSCPServer::GetDbInstrumentsJobInfo(int JobId) {
2779 dmsg(2,("LSCPServer: GetDbInstrumentsJobInfo(JobId=%d)\n", JobId));
2780 LSCPResultSet result;
2781 #if HAVE_SQLITE3
2782 try {
2783 ScanJob job = InstrumentsDb::GetInstrumentsDb()->Jobs.GetJobById(JobId);
2784
2785 result.Add("FILES_TOTAL", job.FilesTotal);
2786 result.Add("FILES_SCANNED", job.FilesScanned);
2787 result.Add("SCANNING", job.Scanning);
2788 result.Add("STATUS", job.Status);
2789 } catch (Exception e) {
2790 result.Error(e);
2791 }
2792 #else
2793 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2794 #endif
2795 return result.Produce();
2796 }
2797
2798 String LSCPServer::SetDbInstrumentName(String Instr, String Name) {
2799 dmsg(2,("LSCPServer: SetDbInstrumentName(Instr=%s,Name=%s)\n", Instr.c_str(), Name.c_str()));
2800 LSCPResultSet result;
2801 #if HAVE_SQLITE3
2802 try {
2803 InstrumentsDb::GetInstrumentsDb()->RenameInstrument(Instr, Name);
2804 } catch (Exception e) {
2805 result.Error(e);
2806 }
2807 #else
2808 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2809 #endif
2810 return result.Produce();
2811 }
2812
2813 String LSCPServer::MoveDbInstrument(String Instr, String Dst) {
2814 dmsg(2,("LSCPServer: MoveDbInstrument(Instr=%s,Dst=%s)\n", Instr.c_str(), Dst.c_str()));
2815 LSCPResultSet result;
2816 #if HAVE_SQLITE3
2817 try {
2818 InstrumentsDb::GetInstrumentsDb()->MoveInstrument(Instr, Dst);
2819 } catch (Exception e) {
2820 result.Error(e);
2821 }
2822 #else
2823 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2824 #endif
2825 return result.Produce();
2826 }
2827
2828 String LSCPServer::CopyDbInstrument(String Instr, String Dst) {
2829 dmsg(2,("LSCPServer: CopyDbInstrument(Instr=%s,Dst=%s)\n", Instr.c_str(), Dst.c_str()));
2830 LSCPResultSet result;
2831 #if HAVE_SQLITE3
2832 try {
2833 InstrumentsDb::GetInstrumentsDb()->CopyInstrument(Instr, Dst);
2834 } catch (Exception e) {
2835 result.Error(e);
2836 }
2837 #else
2838 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2839 #endif
2840 return result.Produce();
2841 }
2842
2843 String LSCPServer::SetDbInstrumentDescription(String Instr, String Desc) {
2844 dmsg(2,("LSCPServer: SetDbInstrumentDescription(Instr=%s,Desc=%s)\n", Instr.c_str(), Desc.c_str()));
2845 LSCPResultSet result;
2846 #if HAVE_SQLITE3
2847 try {
2848 InstrumentsDb::GetInstrumentsDb()->SetInstrumentDescription(Instr, Desc);
2849 } catch (Exception e) {
2850 result.Error(e);
2851 }
2852 #else
2853 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2854 #endif
2855 return result.Produce();
2856 }
2857
2858 String LSCPServer::FindDbInstrumentDirectories(String Dir, std::map<String,String> Parameters, bool Recursive) {
2859 dmsg(2,("LSCPServer: FindDbInstrumentDirectories(Dir=%s)\n", Dir.c_str()));
2860 LSCPResultSet result;
2861 #if HAVE_SQLITE3
2862 try {
2863 SearchQuery Query;
2864 std::map<String,String>::iterator iter;
2865 for (iter = Parameters.begin(); iter != Parameters.end(); iter++) {
2866 if (iter->first.compare("NAME") == 0) {
2867 Query.Name = iter->second;
2868 } else if (iter->first.compare("CREATED") == 0) {
2869 Query.SetCreated(iter->second);
2870 } else if (iter->first.compare("MODIFIED") == 0) {
2871 Query.SetModified(iter->second);
2872 } else if (iter->first.compare("DESCRIPTION") == 0) {
2873 Query.Description = iter->second;
2874 } else {
2875 throw Exception("Unknown search criteria: " + iter->first);
2876 }
2877 }
2878
2879 String list;
2880 StringListPtr pDirectories =
2881 InstrumentsDb::GetInstrumentsDb()->FindDirectories(Dir, &Query, Recursive);
2882
2883 for (int i = 0; i < pDirectories->size(); i++) {
2884 if (list != "") list += ",";
2885 list += "'" + InstrumentsDb::toEscapedPath(pDirectories->at(i)) + "'";
2886 }
2887
2888 result.Add(list);
2889 } catch (Exception e) {
2890 result.Error(e);
2891 }
2892 #else
2893 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2894 #endif
2895 return result.Produce();
2896 }
2897
2898 String LSCPServer::FindDbInstruments(String Dir, std::map<String,String> Parameters, bool Recursive) {
2899 dmsg(2,("LSCPServer: FindDbInstruments(Dir=%s)\n", Dir.c_str()));
2900 LSCPResultSet result;
2901 #if HAVE_SQLITE3
2902 try {
2903 SearchQuery Query;
2904 std::map<String,String>::iterator iter;
2905 for (iter = Parameters.begin(); iter != Parameters.end(); iter++) {
2906 if (iter->first.compare("NAME") == 0) {
2907 Query.Name = iter->second;
2908 } else if (iter->first.compare("FORMAT_FAMILIES") == 0) {
2909 Query.SetFormatFamilies(iter->second);
2910 } else if (iter->first.compare("SIZE") == 0) {
2911 Query.SetSize(iter->second);
2912 } else if (iter->first.compare("CREATED") == 0) {
2913 Query.SetCreated(iter->second);
2914 } else if (iter->first.compare("MODIFIED") == 0) {
2915 Query.SetModified(iter->second);
2916 } else if (iter->first.compare("DESCRIPTION") == 0) {
2917 Query.Description = iter->second;
2918 } else if (iter->first.compare("IS_DRUM") == 0) {
2919 if (!strcasecmp(iter->second.c_str(), "true")) {
2920 Query.InstrType = SearchQuery::DRUM;
2921 } else {
2922 Query.InstrType = SearchQuery::CHROMATIC;
2923 }
2924 } else if (iter->first.compare("PRODUCT") == 0) {
2925 Query.Product = iter->second;
2926 } else if (iter->first.compare("ARTISTS") == 0) {
2927 Query.Artists = iter->second;
2928 } else if (iter->first.compare("KEYWORDS") == 0) {
2929 Query.Keywords = iter->second;
2930 } else {
2931 throw Exception("Unknown search criteria: " + iter->first);
2932 }
2933 }
2934
2935 String list;
2936 StringListPtr pInstruments =
2937 InstrumentsDb::GetInstrumentsDb()->FindInstruments(Dir, &Query, Recursive);
2938
2939 for (int i = 0; i < pInstruments->size(); i++) {
2940 if (list != "") list += ",";
2941 list += "'" + InstrumentsDb::toEscapedPath(pInstruments->at(i)) + "'";
2942 }
2943
2944 result.Add(list);
2945 } catch (Exception e) {
2946 result.Error(e);
2947 }
2948 #else
2949 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2950 #endif
2951 return result.Produce();
2952 }
2953
2954 String LSCPServer::FormatInstrumentsDb() {
2955 dmsg(2,("LSCPServer: FormatInstrumentsDb()\n"));
2956 LSCPResultSet result;
2957 #if HAVE_SQLITE3
2958 try {
2959 InstrumentsDb::GetInstrumentsDb()->Format();
2960 } catch (Exception e) {
2961 result.Error(e);
2962 }
2963 #else
2964 result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2965 #endif
2966 return result.Produce();
2967 }
2968
2969
2970 /**
2971 * Will be called by the parser to enable or disable echo mode; if echo
2972 * mode is enabled, all commands from the client will (immediately) be
2973 * echoed back to the client.
2974 */
2975 String LSCPServer::SetEcho(yyparse_param_t* pSession, double boolean_value) {
2976 dmsg(2,("LSCPServer: SetEcho(val=%f)\n", boolean_value));
2977 LSCPResultSet result;
2978 try {
2979 if (boolean_value == 0) pSession->bVerbose = false;
2980 else if (boolean_value == 1) pSession->bVerbose = true;
2981 else throw Exception("Not a boolean value, must either be 0 or 1");
2982 }
2983 catch (Exception e) {
2984 result.Error(e);
2985 }
2986 return result.Produce();
2987 }

  ViewVC Help
Powered by ViewVC