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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1774 - (hide annotations) (download)
Thu Sep 11 18:11:06 2008 UTC (15 years, 6 months ago) by iliev
File size: 128841 byte(s)
* don't retrieve key bindings and keyswitch bindings if
  the instrument is not loaded in the instrument manager
* notification events are now sent when sending MIDI
  messages using SEND CHANNEL MIDI_DATA lscp command
* fixed a bug in the keyswitch bindings retrieval

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

  ViewVC Help
Powered by ViewVC