/[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 1761 - (hide annotations) (download)
Fri Aug 29 15:42:06 2008 UTC (15 years, 7 months ago) by iliev
File size: 129811 byte(s)
* fixed a crash which occurs when removing a sampler channel waiting
  to start instrument loading after another channel

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

  ViewVC Help
Powered by ViewVC