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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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