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

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

Parent Directory | Revision Log | View Patch Patch

-revision 211 by schoenebeck,
Sun Jul 25 23:27:41 2004 UTC
+revision 905 by schoenebeck,
Sun Jul 23 16:23:13 2006 UTC
 Line 3
   *   LinuxSampler - modular, streaming capable sampler                     *
   *                                                                         *
   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
+  *   Copyright (C) 2005, 2006 Christian Schoenebeck                        *
   *                                                                         *
-  *   This program is free software; you can redistribute it and/or modify  *
+  *   This library is free software; you can redistribute it and/or modify  *
   *   it under the terms of the GNU General Public License as published by  *
   *   the Free Software Foundation; either version 2 of the License, or     *
   *   (at your option) any later version.                                   *
   *                                                                         *
-  *   This program is distributed in the hope that it will be useful,       *
+  *   This library is distributed in the hope that it will be useful,       *
   *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
   *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
   *   GNU General Public License for more details.                          *
   *                                                                         *
   *   You should have received a copy of the GNU General Public License     *
-  *   along with this program; if not, write to the Free Software           *
+  *   along with this library; if not, write to the Free Software           *
   *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
   *   MA  02111-1307  USA                                                   *
   ***************************************************************************/
-Line 23
+Line 24
  #include "lscpserver.h"
  #include "lscpresultset.h"
  #include "lscpevent.h"
+ //#include "../common/global.h"
- #include "../engines/gig/Engine.h"
+ #include <fcntl.h>
+ #if HAVE_SQLITE3
+ # include "sqlite3.h"
+ #endif
+ #include "../engines/EngineFactory.h"
+ #include "../engines/EngineChannelFactory.h"
  #include "../drivers/audio/AudioOutputDeviceFactory.h"
  #include "../drivers/midi/MidiInputDeviceFactory.h"
-Line 50 
 std::map< LSCPEvent::event_t, std::list<
+Line 59 
 std::map< LSCPEvent::event_t, std::list<
  Mutex LSCPServer::NotifyMutex = Mutex();
  Mutex LSCPServer::NotifyBufferMutex = Mutex();
  Mutex LSCPServer::SubscriptionMutex = Mutex();
+ Mutex LSCPServer::RTNotifyMutex = Mutex();
- LSCPServer::LSCPServer(Sampler* pSampler) : Thread(false, 0, -4) {
+ LSCPServer::LSCPServer(Sampler* pSampler, long int addr, short int port) : Thread(true, false, 0, -4) {
+     SocketAddress.sin_family      = AF_INET;
+     SocketAddress.sin_addr.s_addr = addr;
+     SocketAddress.sin_port        = port;
      this->pSampler = pSampler;
-     LSCPEvent::RegisterEvent(LSCPEvent::event_channels, "CHANNELS");
+     LSCPEvent::RegisterEvent(LSCPEvent::event_channel_count, "CHANNEL_COUNT");
      LSCPEvent::RegisterEvent(LSCPEvent::event_voice_count, "VOICE_COUNT");
      LSCPEvent::RegisterEvent(LSCPEvent::event_stream_count, "STREAM_COUNT");
      LSCPEvent::RegisterEvent(LSCPEvent::event_buffer_fill, "BUFFER_FILL");
-     LSCPEvent::RegisterEvent(LSCPEvent::event_info, "INFO");
+     LSCPEvent::RegisterEvent(LSCPEvent::event_channel_info, "CHANNEL_INFO");
      LSCPEvent::RegisterEvent(LSCPEvent::event_misc, "MISCELLANEOUS");
+     LSCPEvent::RegisterEvent(LSCPEvent::event_total_voice_count, "TOTAL_VOICE_COUNT");
+     hSocket = -1;
+ }
+ LSCPServer::~LSCPServer() {
+     if (hSocket >= 0) close(hSocket);
  }
  /**
-Line 76 
 int LSCPServer::WaitUntilInitialized(lon
+Line 95 
 int LSCPServer::WaitUntilInitialized(lon
  }
  int LSCPServer::Main() {
-     int hSocket = socket(AF_INET, SOCK_STREAM, 0);
+     hSocket = socket(AF_INET, SOCK_STREAM, 0);
      if (hSocket < 0) {
          std::cerr << "LSCPServer: Could not create server socket." << std::endl;
          //return -1;
          exit(EXIT_FAILURE);
      }
-     SocketAddress.sin_family      = AF_INET;
-     SocketAddress.sin_port        = htons(LSCP_PORT);
-     SocketAddress.sin_addr.s_addr = htonl(INADDR_ANY);
      if (bind(hSocket, (sockaddr*) &SocketAddress, sizeof(sockaddr_in)) < 0) {
-         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...";
-         close(hSocket);
+         for (int trial = 0; true; trial++) { // retry for LSCP_SERVER_BIND_TIMEOUT seconds
-         //return -1;
+             if (bind(hSocket, (sockaddr*) &SocketAddress, sizeof(sockaddr_in)) < 0) {
-         exit(EXIT_FAILURE);
+                 if (trial > LSCP_SERVER_BIND_TIMEOUT) {
+                     std::cerr << "gave up!" << std::endl;
+                     close(hSocket);
+                     //return -1;
+                     exit(EXIT_FAILURE);
+                 }
+                 else sleep(1); // sleep 1s
+             }
+             else break; // success
+         }
      }
      listen(hSocket, 1);
-Line 104 
 int LSCPServer::Main() {
+Line 128 
 int LSCPServer::Main() {
      FD_SET(hSocket, &fdSet);
      int maxSessions = hSocket;
+     timeval timeout;
      while (true) {
-         fd_set selectSet = fdSet;
+         // check if some engine channel's parameter / status changed, if so notify the respective LSCP event subscribers
-         int retval = select(maxSessions+1, &selectSet, NULL, NULL, NULL);
+         {
+             std::set<EngineChannel*> engineChannels = EngineChannelFactory::EngineChannelInstances();
+             std::set<EngineChannel*>::iterator itEngineChannel = engineChannels.begin();
+             std::set<EngineChannel*>::iterator itEnd           = engineChannels.end();
+             for (; itEngineChannel != itEnd; ++itEngineChannel) {
+                 if ((*itEngineChannel)->StatusChanged()) {
+                     SendLSCPNotify(LSCPEvent(LSCPEvent::event_channel_info, (*itEngineChannel)->iSamplerChannelIndex));
+                 }
+             }
+         }
+         //Now let's deliver late notifies (if any)
+         NotifyBufferMutex.Lock();
+         for (std::map<int,String>::iterator iterNotify = bufferedNotifies.begin(); iterNotify != bufferedNotifies.end(); iterNotify++) {
+ #ifdef MSG_NOSIGNAL
+                 send(iterNotify->first, iterNotify->second.c_str(), iterNotify->second.size(), MSG_NOSIGNAL);
+ #else
+                 send(iterNotify->first, iterNotify->second.c_str(), iterNotify->second.size(), 0);
+ #endif
+         }
+         bufferedNotifies.clear();
+         NotifyBufferMutex.Unlock();
+         fd_set selectSet = fdSet;
+         timeout.tv_sec  = 0;
+         timeout.tv_usec = 100000;
+         int retval = select(maxSessions+1, &selectSet, NULL, NULL, &timeout);
          if (retval == 0)
                  continue; //Nothing try again
          if (retval == -1) {
-Line 147 
 int LSCPServer::Main() {
+Line 201 
 int LSCPServer::Main() {
                  if (FD_ISSET((*iter).hSession, &selectSet)) {   //Was it this socket?
                          if (GetLSCPCommand(iter)) {     //Have we read the entire command?
                                  dmsg(3,("LSCPServer: Got command on socket %d, calling parser.\n", currentSocket));
-                                 yylex_init(&((*iter).pScanner)); //FIXME: should me moved out of this loop and initialized only when a new session is created
+                                 int dummy; // just a temporary hack to fulfill the restart() function prototype
+                                 restart(NULL, dummy); // restart the 'scanner'
                                  currentSocket = (*iter).hSession;  //a hack
+                                 dmsg(2,("LSCPServer: [%s]\n",bufferedCommands[currentSocket].c_str()));
                                  if ((*iter).bVerbose) { // if echo mode enabled
                                      AnswerClient(bufferedCommands[currentSocket]);
                                  }
-Line 164 
 int LSCPServer::Main() {
+Line 220 
 int LSCPServer::Main() {
                          break;
                  }
          }
-         //Now let's deliver late notifies (if any)
-         NotifyBufferMutex.Lock();
-         for (std::map<int,String>::iterator iterNotify = bufferedNotifies.begin(); iterNotify != bufferedNotifies.end(); iterNotify++) {
-                 send(iterNotify->first, iterNotify->second.c_str(), iterNotify->second.size(), 0);
-                 bufferedNotifies.erase(iterNotify);
-         }
-         NotifyBufferMutex.Unlock();
      }
-     //It will never get here anyway
-     //yylex_destroy(yyparse_param.pScanner);
  }
  void LSCPServer::CloseConnection( std::vector<yyparse_param_t>::iterator iter ) {
-Line 193 
 void LSCPServer::CloseConnection( std::v
+Line 239 
 void LSCPServer::CloseConnection( std::v
          bufferedNotifies.erase(socket);
          close(socket);
          NotifyMutex.Unlock();
-         //yylex_destroy((*iter).pScanner);
+ }
+ int LSCPServer::EventSubscribers( std::list<LSCPEvent::event_t> events ) {
+         int subs = 0;
+         SubscriptionMutex.Lock();
+         for( std::list<LSCPEvent::event_t>::iterator iter = events.begin();
+                         iter != events.end(); iter++)
+         {
+                 subs += eventSubscriptions.count(*iter);
+         }
+         SubscriptionMutex.Unlock();
+         return subs;
  }
  void LSCPServer::SendLSCPNotify( LSCPEvent event ) {
-Line 209 
 void LSCPServer::SendLSCPNotify( LSCPEve
+Line 266 
 void LSCPServer::SendLSCPNotify( LSCPEve
          while (true) {
                  if (NotifyMutex.Trylock()) {
                          for(;iter != end; iter++)
+ #ifdef MSG_NOSIGNAL
+                                 send(*iter, notify.c_str(), notify.size(), MSG_NOSIGNAL);
+ #else
                                  send(*iter, notify.c_str(), notify.size(), 0);
+ #endif
                          NotifyMutex.Unlock();
                          break;
                  } else {
-Line 318 
 void LSCPServer::AnswerClient(String Ret
+Line 379 
 void LSCPServer::AnswerClient(String Ret
      dmsg(2,("LSCPServer::AnswerClient(ReturnMessage=%s)", ReturnMessage.c_str()));
      if (currentSocket != -1) {
              NotifyMutex.Lock();
+ #ifdef MSG_NOSIGNAL
+             send(currentSocket, ReturnMessage.c_str(), ReturnMessage.size(), MSG_NOSIGNAL);
+ #else
              send(currentSocket, ReturnMessage.c_str(), ReturnMessage.size(), 0);
+ #endif
              NotifyMutex.Unlock();
      }
  }
-Line 362 
 String LSCPServer::CreateAudioOutputDevi
+Line 427 
 String LSCPServer::CreateAudioOutputDevi
          AudioOutputDevice* pDevice = pSampler->CreateAudioOutputDevice(Driver, Parameters);
          // search for the created device to get its index
          int index = GetAudioOutputDeviceIndex(pDevice);
-         if (index == -1) throw LinuxSamplerException("Internal error: could not find created audio output device.");
+         if (index == -1) throw Exception("Internal error: could not find created audio output device.");
          result = index; // success
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 378 
 String LSCPServer::CreateMidiInputDevice
+Line 443 
 String LSCPServer::CreateMidiInputDevice
          MidiInputDevice* pDevice = pSampler->CreateMidiInputDevice(Driver, Parameters);
          // search for the created device to get its index
          int index = GetMidiInputDeviceIndex(pDevice);
-         if (index == -1) throw LinuxSamplerException("Internal error: could not find created midi input device.");
+         if (index == -1) throw Exception("Internal error: could not find created midi input device.");
          result = index; // success
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 392 
 String LSCPServer::DestroyAudioOutputDev
+Line 457 
 String LSCPServer::DestroyAudioOutputDev
      LSCPResultSet result;
      try {
          std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
-         if (!devices[DeviceIndex]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceIndex) + ".");
+         if (!devices.count(DeviceIndex)) throw Exception("There is no audio output device with index " + ToString(DeviceIndex) + ".");
          AudioOutputDevice* pDevice = devices[DeviceIndex];
          pSampler->DestroyAudioOutputDevice(pDevice);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 407 
 String LSCPServer::DestroyMidiInputDevic
+Line 472 
 String LSCPServer::DestroyMidiInputDevic
      LSCPResultSet result;
      try {
          std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
+         if (!devices.count(DeviceIndex)) throw Exception("There is no audio output device with index " + ToString(DeviceIndex) + ".");
          MidiInputDevice* pDevice = devices[DeviceIndex];
-         if (!pDevice) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceIndex) + ".");
          pSampler->DestroyMidiInputDevice(pDevice);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 425 
 String LSCPServer::LoadInstrument(String
+Line 490 
 String LSCPServer::LoadInstrument(String
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
-         Engine* pEngine = pSamplerChannel->GetEngine();
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
-         if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
+         if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel yet");
-         if (pSamplerChannel->GetAudioOutputDevice() == NULL)
+         if (!pSamplerChannel->GetAudioOutputDevice())
-             throw LinuxSamplerException("No audio output device on channel");
+             throw Exception("No audio output device connected to sampler channel");
          if (bBackground) {
-             LSCPLoadInstrument *pLoadInstrument = new LSCPLoadInstrument(pEngine, Filename.c_str(), uiInstrument);
+             InstrumentLoader.StartNewLoad(Filename, uiInstrument, pEngineChannel);
-             pLoadInstrument->StartThread();
+         }
+         else {
+             // tell the engine channel which instrument to load
+             pEngineChannel->PrepareLoadInstrument(Filename.c_str(), uiInstrument);
+             // actually start to load the instrument (blocks until completed)
+             pEngineChannel->LoadInstrument();
          }
-         else pEngine->LoadInstrument(Filename.c_str(), uiInstrument);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
  }
  /**
-  * 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
+  * sampler channel.
   */
- String LSCPServer::LoadEngine(String EngineName, uint uiSamplerChannel) {
+ String LSCPServer::SetEngineType(String EngineName, uint uiSamplerChannel) {
-     dmsg(2,("LSCPServer: LoadEngine(EngineName=%s,SamplerChannel=%d)\n", EngineName.c_str(), uiSamplerChannel));
+     dmsg(2,("LSCPServer: SetEngineType(EngineName=%s,uiSamplerChannel=%d)\n", EngineName.c_str(), uiSamplerChannel));
      LSCPResultSet result;
      try {
-         Engine::type_t type;
-         if ((EngineName == "GigEngine") || (EngineName == "gig")) type = Engine::type_gig;
-         else throw LinuxSamplerException("Unknown engine type");
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
-         pSamplerChannel->LoadEngine(type);
+         LockRTNotify();
+         pSamplerChannel->SetEngineType(EngineName);
+         if(HasSoloChannel()) pSamplerChannel->GetEngineChannel()->SetMute(-1);
+         UnlockRTNotify();
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 494 
 String LSCPServer::ListChannels() {
+Line 564 
 String LSCPServer::ListChannels() {
   */
  String LSCPServer::AddChannel() {
      dmsg(2,("LSCPServer: AddChannel()\n"));
+     LockRTNotify();
      SamplerChannel* pSamplerChannel = pSampler->AddSamplerChannel();
+     UnlockRTNotify();
      LSCPResultSet result(pSamplerChannel->Index());
      return result.Produce();
  }
-Line 505 
 String LSCPServer::AddChannel() {
+Line 577 
 String LSCPServer::AddChannel() {
  String LSCPServer::RemoveChannel(uint uiSamplerChannel) {
      dmsg(2,("LSCPServer: RemoveChannel(SamplerChannel=%d)\n", uiSamplerChannel));
      LSCPResultSet result;
+     LockRTNotify();
      pSampler->RemoveSamplerChannel(uiSamplerChannel);
+     UnlockRTNotify();
      return result.Produce();
  }
  /**
-  * 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.
   */
  String LSCPServer::GetAvailableEngines() {
      dmsg(2,("LSCPServer: GetAvailableEngines()\n"));
-     LSCPResultSet result("GigEngine");
+     LSCPResultSet result;
+     try {
+         int n = EngineFactory::AvailableEngineTypes().size();
+         result.Add(n);
+     }
+     catch (Exception e) {
+         result.Error(e);
+     }
+     return result.Produce();
+ }
+ /**
+  * Will be called by the parser to get a list of all available engines.
+  */
+ String LSCPServer::ListAvailableEngines() {
+     dmsg(2,("LSCPServer: ListAvailableEngines()\n"));
+     LSCPResultSet result;
+     try {
+         String s = EngineFactory::AvailableEngineTypesAsString();
+         result.Add(s);
+     }
+     catch (Exception e) {
+         result.Error(e);
+     }
      return result.Produce();
  }
  /**
-  * 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
+  * sampler engine.
   */
  String LSCPServer::GetEngineInfo(String EngineName) {
      dmsg(2,("LSCPServer: GetEngineInfo(EngineName=%s)\n", EngineName.c_str()));
      LSCPResultSet result;
+     LockRTNotify();
      try {
-         if ((EngineName == "GigEngine") || (EngineName == "gig")) {
+         Engine* pEngine = EngineFactory::Create(EngineName);
-             Engine* pEngine = new LinuxSampler::gig::Engine;
+         result.Add("DESCRIPTION", pEngine->Description());
-             result.Add(pEngine->Description());
+         result.Add("VERSION",     pEngine->Version());
-             result.Add(pEngine->Version());
+         EngineFactory::Destroy(pEngine);
-             delete pEngine;
-         }
-         else throw LinuxSamplerException("Unknown engine type");
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
+     UnlockRTNotify();
      return result.Produce();
  }
-Line 548 
 String LSCPServer::GetChannelInfo(uint u
+Line 645 
 String LSCPServer::GetChannelInfo(uint u
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
-         Engine* pEngine = pSamplerChannel->GetEngine();
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
          //Defaults values
          String EngineName = "NONE";
-         float Volume = 0;
+         float Volume = 0.0f;
          String InstrumentFileName = "NONE";
+         String InstrumentName = "NONE";
          int InstrumentIndex = -1;
          int InstrumentStatus = -1;
+         int AudioOutputChannels = 0;
-         if (pEngine) {
+         String AudioRouting;
-             EngineName =  pEngine->EngineName();
+         int Mute = 0;
-             Volume = pEngine->Volume();
+         bool Solo = false;
-             InstrumentStatus = pEngine->InstrumentStatus();
-             InstrumentIndex = pEngine->InstrumentIndex();
+         if (pEngineChannel) {
-             if (InstrumentIndex != -1)
+             EngineName          = pEngineChannel->EngineName();
-                 InstrumentFileName = pEngine->InstrumentFileName();
+             AudioOutputChannels = pEngineChannel->Channels();
+             Volume              = pEngineChannel->Volume();
+             InstrumentStatus    = pEngineChannel->InstrumentStatus();
+             InstrumentIndex     = pEngineChannel->InstrumentIndex();
+             if (InstrumentIndex != -1) {
+                 InstrumentFileName = pEngineChannel->InstrumentFileName();
+                 InstrumentName     = pEngineChannel->InstrumentName();
+             }
+             for (int chan = 0; chan < pEngineChannel->Channels(); chan++) {
+                 if (AudioRouting != "") AudioRouting += ",";
+                 AudioRouting += ToString(pEngineChannel->OutputChannel(chan));
+             }
+             Mute = pEngineChannel->GetMute();
+             Solo = pEngineChannel->GetSolo();
          }
          result.Add("ENGINE_NAME", EngineName);
-Line 572 
 String LSCPServer::GetChannelInfo(uint u
+Line 683 
 String LSCPServer::GetChannelInfo(uint u
          //Some not-so-hardcoded stuff to make GUI look good
          result.Add("AUDIO_OUTPUT_DEVICE", GetAudioOutputDeviceIndex(pSamplerChannel->GetAudioOutputDevice()));
-         result.Add("AUDIO_OUTPUT_CHANNELS", "2");
+         result.Add("AUDIO_OUTPUT_CHANNELS", AudioOutputChannels);
-         result.Add("AUDIO_OUTPUT_ROUTING", "0,1");
+         result.Add("AUDIO_OUTPUT_ROUTING", AudioRouting);
          result.Add("MIDI_INPUT_DEVICE", GetMidiInputDeviceIndex(pSamplerChannel->GetMidiInputDevice()));
          result.Add("MIDI_INPUT_PORT", pSamplerChannel->GetMidiInputPort());
-         result.Add("MIDI_INPUT_CHANNEL", pSamplerChannel->GetMidiInputChannel());
+         if (pSamplerChannel->GetMidiInputChannel() == midi_chan_all) result.Add("MIDI_INPUT_CHANNEL", "ALL");
+         else result.Add("MIDI_INPUT_CHANNEL", pSamplerChannel->GetMidiInputChannel());
          result.Add("INSTRUMENT_FILE", InstrumentFileName);
          result.Add("INSTRUMENT_NR", InstrumentIndex);
+         result.Add("INSTRUMENT_NAME", InstrumentName);
          result.Add("INSTRUMENT_STATUS", InstrumentStatus);
+         result.Add("MUTE", Mute == -1 ? "MUTED_BY_SOLO" : (Mute ? "true" : "false"));
+         result.Add("SOLO", Solo);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 598 
 String LSCPServer::GetVoiceCount(uint ui
+Line 713 
 String LSCPServer::GetVoiceCount(uint ui
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
-         Engine* pEngine = pSamplerChannel->GetEngine();
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
-         if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
+         if (!pEngineChannel) throw Exception("No engine loaded on sampler channel");
-         result.Add(pEngine->VoiceCount());
+         if (!pEngineChannel->GetEngine()) throw Exception("No audio output device connected to sampler channel");
+         result.Add(pEngineChannel->GetEngine()->VoiceCount());
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 618 
 String LSCPServer::GetStreamCount(uint u
+Line 734 
 String LSCPServer::GetStreamCount(uint u
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
-         Engine* pEngine = pSamplerChannel->GetEngine();
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
-         if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
+         if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
-         result.Add(pEngine->DiskStreamCount());
+         if (!pEngineChannel->GetEngine()) throw Exception("No audio output device connected to sampler channel");
+         result.Add(pEngineChannel->GetEngine()->DiskStreamCount());
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 638 
 String LSCPServer::GetBufferFill(fill_re
+Line 755 
 String LSCPServer::GetBufferFill(fill_re
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
-         Engine* pEngine = pSamplerChannel->GetEngine();
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
-         if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
+         if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
-         if (!pEngine->DiskStreamSupported())
+         if (!pEngineChannel->GetEngine()) throw Exception("No audio output device connected to sampler channel");
-             result.Add("NA");
+         if (!pEngineChannel->GetEngine()->DiskStreamSupported()) result.Add("NA");
          else {
              switch (ResponseType) {
                  case fill_response_bytes:
-                     result.Add(pEngine->DiskStreamBufferFillBytes());
+                     result.Add(pEngineChannel->GetEngine()->DiskStreamBufferFillBytes());
                      break;
                  case fill_response_percentage:
-                     result.Add(pEngine->DiskStreamBufferFillPercentage());
+                     result.Add(pEngineChannel->GetEngine()->DiskStreamBufferFillPercentage());
                      break;
                  default:
-                     throw LinuxSamplerException("Unknown fill response type");
+                     throw Exception("Unknown fill response type");
              }
          }
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 666 
 String LSCPServer::GetAvailableAudioOutp
+Line 783 
 String LSCPServer::GetAvailableAudioOutp
      dmsg(2,("LSCPServer: GetAvailableAudioOutputDrivers()\n"));
      LSCPResultSet result;
      try {
+         int n = AudioOutputDeviceFactory::AvailableDrivers().size();
+         result.Add(n);
+     }
+     catch (Exception e) {
+         result.Error(e);
+     }
+     return result.Produce();
+ }
+ String LSCPServer::ListAvailableAudioOutputDrivers() {
+     dmsg(2,("LSCPServer: ListAvailableAudioOutputDrivers()\n"));
+     LSCPResultSet result;
+     try {
          String s = AudioOutputDeviceFactory::AvailableDriversAsString();
          result.Add(s);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 679 
 String LSCPServer::GetAvailableMidiInput
+Line 809 
 String LSCPServer::GetAvailableMidiInput
      dmsg(2,("LSCPServer: GetAvailableMidiInputDrivers()\n"));
      LSCPResultSet result;
      try {
+         int n = MidiInputDeviceFactory::AvailableDrivers().size();
+         result.Add(n);
+     }
+     catch (Exception e) {
+         result.Error(e);
+     }
+     return result.Produce();
+ }
+ String LSCPServer::ListAvailableMidiInputDrivers() {
+     dmsg(2,("LSCPServer: ListAvailableMidiInputDrivers()\n"));
+     LSCPResultSet result;
+     try {
          String s = MidiInputDeviceFactory::AvailableDriversAsString();
          result.Add(s);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 706 
 String LSCPServer::GetMidiInputDriverInf
+Line 849 
 String LSCPServer::GetMidiInputDriverInf
              result.Add("PARAMETERS", s);
          }
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 730 
 String LSCPServer::GetAudioOutputDriverI
+Line 873 
 String LSCPServer::GetAudioOutputDriverI
              result.Add("PARAMETERS", s);
          }
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
  }
  String LSCPServer::GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList) {
-     dmsg(2,("LSCPServer: GetMidiInputDriverParameterInfo(Driver=%s,Parameter=%s)\n",Driver.c_str(),Parameter.c_str()));
+     dmsg(2,("LSCPServer: GetMidiInputDriverParameterInfo(Driver=%s,Parameter=%s,DependencyListSize=%d)\n",Driver.c_str(),Parameter.c_str(),DependencyList.size()));
      LSCPResultSet result;
      try {
          DeviceCreationParameter* pParameter = MidiInputDeviceFactory::GetDriverParameter(Driver, Parameter);
-Line 746 
 String LSCPServer::GetMidiInputDriverPar
+Line 889 
 String LSCPServer::GetMidiInputDriverPar
          result.Add("MANDATORY",    pParameter->Mandatory());
          result.Add("FIX",          pParameter->Fix());
          result.Add("MULTIPLICITY", pParameter->Multiplicity());
-         if (pParameter->Depends())       result.Add("DEPENDS",       pParameter->Depends());
+         optional<String> oDepends       = pParameter->Depends();
-         if (pParameter->Default())       result.Add("DEFAULT",       pParameter->Default());
+         optional<String> oDefault       = pParameter->Default(DependencyList);
-         if (pParameter->RangeMin())      result.Add("RANGE_MIN",     pParameter->RangeMin());
+         optional<String> oRangeMin      = pParameter->RangeMin(DependencyList);
-         if (pParameter->RangeMax())      result.Add("RANGE_MAX",     pParameter->RangeMax());
+         optional<String> oRangeMax      = pParameter->RangeMax(DependencyList);
-         if (pParameter->Possibilities()) result.Add("POSSIBILITIES", pParameter->Possibilities());
+         optional<String> oPossibilities = pParameter->Possibilities(DependencyList);
+         if (oDepends)       result.Add("DEPENDS",       *oDepends);
+         if (oDefault)       result.Add("DEFAULT",       *oDefault);
+         if (oRangeMin)      result.Add("RANGE_MIN",     *oRangeMin);
+         if (oRangeMax)      result.Add("RANGE_MAX",     *oRangeMax);
+         if (oPossibilities) result.Add("POSSIBILITIES", *oPossibilities);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
  }
  String LSCPServer::GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList) {
-     dmsg(2,("LSCPServer: GetAudioOutputDriverParameterInfo(Driver=%s,Parameter=%s)\n",Driver.c_str(),Parameter.c_str()));
+     dmsg(2,("LSCPServer: GetAudioOutputDriverParameterInfo(Driver=%s,Parameter=%s,DependencyListSize=%d)\n",Driver.c_str(),Parameter.c_str(),DependencyList.size()));
      LSCPResultSet result;
      try {
          DeviceCreationParameter* pParameter = AudioOutputDeviceFactory::GetDriverParameter(Driver, Parameter);
-Line 768 
 String LSCPServer::GetAudioOutputDriverP
+Line 916 
 String LSCPServer::GetAudioOutputDriverP
          result.Add("MANDATORY",    pParameter->Mandatory());
          result.Add("FIX",          pParameter->Fix());
          result.Add("MULTIPLICITY", pParameter->Multiplicity());
-         if (pParameter->Depends())       result.Add("DEPENDS",       pParameter->Depends());
+         optional<String> oDepends       = pParameter->Depends();
-         if (pParameter->Default())       result.Add("DEFAULT",       pParameter->Default());
+         optional<String> oDefault       = pParameter->Default(DependencyList);
-         if (pParameter->RangeMin())      result.Add("RANGE_MIN",     pParameter->RangeMin());
+         optional<String> oRangeMin      = pParameter->RangeMin(DependencyList);
-         if (pParameter->RangeMax())      result.Add("RANGE_MAX",     pParameter->RangeMax());
+         optional<String> oRangeMax      = pParameter->RangeMax(DependencyList);
-         if (pParameter->Possibilities()) result.Add("POSSIBILITIES", pParameter->Possibilities());
+         optional<String> oPossibilities = pParameter->Possibilities(DependencyList);
+         if (oDepends)       result.Add("DEPENDS",       *oDepends);
+         if (oDefault)       result.Add("DEFAULT",       *oDefault);
+         if (oRangeMin)      result.Add("RANGE_MIN",     *oRangeMin);
+         if (oRangeMax)      result.Add("RANGE_MAX",     *oRangeMax);
+         if (oPossibilities) result.Add("POSSIBILITIES", *oPossibilities);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 787 
 String LSCPServer::GetAudioOutputDeviceC
+Line 940 
 String LSCPServer::GetAudioOutputDeviceC
          uint count = pSampler->AudioOutputDevices();
          result.Add(count); // success
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 800 
 String LSCPServer::GetMidiInputDeviceCou
+Line 953 
 String LSCPServer::GetMidiInputDeviceCou
          uint count = pSampler->MidiInputDevices();
          result.Add(count); // success
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 819 
 String LSCPServer::GetAudioOutputDevices
+Line 972 
 String LSCPServer::GetAudioOutputDevices
          }
          result.Add(s);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 838 
 String LSCPServer::GetMidiInputDevices()
+Line 991 
 String LSCPServer::GetMidiInputDevices()
          }
          result.Add(s);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 849 
 String LSCPServer::GetAudioOutputDeviceI
+Line 1002 
 String LSCPServer::GetAudioOutputDeviceI
      LSCPResultSet result;
      try {
          std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
-         if (!devices[DeviceIndex]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceIndex) + ".");
+         if (!devices.count(DeviceIndex)) throw Exception("There is no audio output device with index " + ToString(DeviceIndex) + ".");
          AudioOutputDevice* pDevice = devices[DeviceIndex];
-         result.Add("driver", pDevice->Driver());
+         result.Add("DRIVER", pDevice->Driver());
          std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
          std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
          for (; iter != parameters.end(); iter++) {
              result.Add(iter->first, iter->second->Value());
          }
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 869 
 String LSCPServer::GetMidiInputDeviceInf
+Line 1022 
 String LSCPServer::GetMidiInputDeviceInf
      LSCPResultSet result;
      try {
          std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
+         if (!devices.count(DeviceIndex)) throw Exception("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
          MidiInputDevice* pDevice = devices[DeviceIndex];
-         if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
+         result.Add("DRIVER", pDevice->Driver());
-         result.Add("driver", pDevice->Driver());
          std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
          std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
          for (; iter != parameters.end(); iter++) {
              result.Add(iter->first, iter->second->Value());
          }
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 887 
 String LSCPServer::GetMidiInputPortInfo(
+Line 1040 
 String LSCPServer::GetMidiInputPortInfo(
      dmsg(2,("LSCPServer: GetMidiInputPortInfo(DeviceIndex=%d, PortIndex=%d)\n",DeviceIndex, PortIndex));
      LSCPResultSet result;
      try {
+         // get MIDI input device
          std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
+         if (!devices.count(DeviceIndex)) throw Exception("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
          MidiInputDevice* pDevice = devices[DeviceIndex];
-         if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
-         MidiInputDevice::MidiInputPort* pMidiInputPort = pDevice->GetPort(PortIndex);
+         // get MIDI port
-         if (!pMidiInputPort) throw LinuxSamplerException("There is no MIDI input port with index " + ToString(PortIndex) + ".");
+         MidiInputPort* pMidiInputPort = pDevice->GetPort(PortIndex);
-         std::map<String,DeviceCreationParameter*> parameters = pMidiInputPort->DeviceParameters();
+         if (!pMidiInputPort) throw Exception("There is no MIDI input port with index " + ToString(PortIndex) + ".");
-         std::map<String,DeviceCreationParameter*>::iterator iter = parameters.begin();
+         // return the values of all MIDI port parameters
+         std::map<String,DeviceRuntimeParameter*> parameters = pMidiInputPort->PortParameters();
+         std::map<String,DeviceRuntimeParameter*>::iterator iter = parameters.begin();
          for (; iter != parameters.end(); iter++) {
              result.Add(iter->first, iter->second->Value());
          }
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 910 
 String LSCPServer::GetAudioOutputChannel
+Line 1068 
 String LSCPServer::GetAudioOutputChannel
      try {
          // get audio output device
          std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
-         if (!devices[DeviceId]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceId) + ".");
+         if (!devices.count(DeviceId)) throw Exception("There is no audio output device with index " + ToString(DeviceId) + ".");
          AudioOutputDevice* pDevice = devices[DeviceId];
          // get audio channel
          AudioChannel* pChannel = pDevice->Channel(ChannelId);
-         if (!pChannel) throw LinuxSamplerException("Audio ouotput device does not have channel " + ToString(ChannelId) + ".");
+         if (!pChannel) throw Exception("Audio output device does not have audio channel " + ToString(ChannelId) + ".");
          // return the values of all audio channel parameters
          std::map<String,DeviceRuntimeParameter*> parameters = pChannel->ChannelParameters();
-Line 924 
 String LSCPServer::GetAudioOutputChannel
+Line 1082 
 String LSCPServer::GetAudioOutputChannel
              result.Add(iter->first, iter->second->Value());
          }
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 934 
 String LSCPServer::GetMidiInputPortParam
+Line 1092 
 String LSCPServer::GetMidiInputPortParam
      dmsg(2,("LSCPServer: GetMidiInputPortParameterInfo(DeviceId=%d,PortId=%d,ParameterName=%s)\n",DeviceId,PortId,ParameterName.c_str()));
      LSCPResultSet result;
      try {
-         // get audio output device
+         // get MIDI input device
          std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
-         if (!devices[DeviceId]) throw LinuxSamplerException("There is no midi input device with index " + ToString(DeviceId) + ".");
+         if (!devices.count(DeviceId)) throw Exception("There is no midi input device with index " + ToString(DeviceId) + ".");
          MidiInputDevice* pDevice = devices[DeviceId];
          // get midi port
-         MidiInputDevice::MidiInputPort* pPort = pDevice->GetPort(PortId);
+         MidiInputPort* pPort = pDevice->GetPort(PortId);
-         if (!pPort) throw LinuxSamplerException("Midi input device does not have port " + ToString(PortId) + ".");
+         if (!pPort) throw Exception("Midi input device does not have port " + ToString(PortId) + ".");
          // get desired port parameter
-         std::map<String,DeviceCreationParameter*> parameters = pPort->DeviceParameters();
+         std::map<String,DeviceRuntimeParameter*> parameters = pPort->PortParameters();
-         if (!parameters[ParameterName]) throw LinuxSamplerException("Midi port does not provice a parameters '" + ParameterName + "'.");
+         if (!parameters.count(ParameterName)) throw Exception("Midi port does not provide a parameter '" + ParameterName + "'.");
-         DeviceCreationParameter* pParameter = parameters[ParameterName];
+         DeviceRuntimeParameter* pParameter = parameters[ParameterName];
          // return all fields of this audio channel parameter
          result.Add("TYPE",         pParameter->Type());
          result.Add("DESCRIPTION",  pParameter->Description());
          result.Add("FIX",          pParameter->Fix());
          result.Add("MULTIPLICITY", pParameter->Multiplicity());
-         if (pParameter->RangeMin())      result.Add("RANGE_MIN",     pParameter->RangeMin());
+         if (pParameter->RangeMin())      result.Add("RANGE_MIN",     *pParameter->RangeMin());
-         if (pParameter->RangeMax())      result.Add("RANGE_MAX",     pParameter->RangeMax());
+         if (pParameter->RangeMax())      result.Add("RANGE_MAX",     *pParameter->RangeMax());
-         if (pParameter->Possibilities()) result.Add("POSSIBILITIES", pParameter->Possibilities());
+         if (pParameter->Possibilities()) result.Add("POSSIBILITIES", *pParameter->Possibilities());
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 969 
 String LSCPServer::GetAudioOutputChannel
+Line 1127 
 String LSCPServer::GetAudioOutputChannel
      try {
          // get audio output device
          std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
-         if (!devices[DeviceId]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceId) + ".");
+         if (!devices.count(DeviceId)) throw Exception("There is no audio output device with index " + ToString(DeviceId) + ".");
          AudioOutputDevice* pDevice = devices[DeviceId];
          // get audio channel
          AudioChannel* pChannel = pDevice->Channel(ChannelId);
-         if (!pChannel) throw LinuxSamplerException("Audio output device does not have channel " + ToString(ChannelId) + ".");
+         if (!pChannel) throw Exception("Audio output device does not have audio channel " + ToString(ChannelId) + ".");
          // get desired audio channel parameter
          std::map<String,DeviceRuntimeParameter*> parameters = pChannel->ChannelParameters();
-         if (!parameters[ParameterName]) throw LinuxSamplerException("Audio channel does not provide a parameter '" + ParameterName + "'.");
+         if (!parameters.count(ParameterName)) throw Exception("Audio channel does not provide a parameter '" + ParameterName + "'.");
          DeviceRuntimeParameter* pParameter = parameters[ParameterName];
          // return all fields of this audio channel parameter
-Line 986 
 String LSCPServer::GetAudioOutputChannel
+Line 1144 
 String LSCPServer::GetAudioOutputChannel
          result.Add("DESCRIPTION",  pParameter->Description());
          result.Add("FIX",          pParameter->Fix());
          result.Add("MULTIPLICITY", pParameter->Multiplicity());
-         if (pParameter->RangeMin())      result.Add("RANGE_MIN",     pParameter->RangeMin());
+         if (pParameter->RangeMin())      result.Add("RANGE_MIN",     *pParameter->RangeMin());
-         if (pParameter->RangeMax())      result.Add("RANGE_MAX",     pParameter->RangeMax());
+         if (pParameter->RangeMax())      result.Add("RANGE_MAX",     *pParameter->RangeMax());
-         if (pParameter->Possibilities()) result.Add("POSSIBILITIES", pParameter->Possibilities());
+         if (pParameter->Possibilities()) result.Add("POSSIBILITIES", *pParameter->Possibilities());
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 1002 
 String LSCPServer::SetAudioOutputChannel
+Line 1160 
 String LSCPServer::SetAudioOutputChannel
      try {
          // get audio output device
          std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
-         if (!devices[DeviceId]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceId) + ".");
+         if (!devices.count(DeviceId)) throw Exception("There is no audio output device with index " + ToString(DeviceId) + ".");
          AudioOutputDevice* pDevice = devices[DeviceId];
          // get audio channel
          AudioChannel* pChannel = pDevice->Channel(ChannelId);
-         if (!pChannel) throw LinuxSamplerException("Audio output device does not have channel " + ToString(ChannelId) + ".");
+         if (!pChannel) throw Exception("Audio output device does not have audio channel " + ToString(ChannelId) + ".");
          // get desired audio channel parameter
          std::map<String,DeviceRuntimeParameter*> parameters = pChannel->ChannelParameters();
-         if (!parameters[ParamKey]) throw LinuxSamplerException("Audio channel does not provide a parameter '" + ParamKey + "'.");
+         if (!parameters.count(ParamKey)) throw Exception("Audio channel does not provide a parameter '" + ParamKey + "'.");
          DeviceRuntimeParameter* pParameter = parameters[ParamKey];
          // set new channel parameter value
          pParameter->SetValue(ParamVal);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 1028 
 String LSCPServer::SetAudioOutputDeviceP
+Line 1186 
 String LSCPServer::SetAudioOutputDeviceP
      LSCPResultSet result;
      try {
          std::map<uint,AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
-         if (!devices[DeviceIndex]) throw LinuxSamplerException("There is no audio output device with index " + ToString(DeviceIndex) + ".");
+         if (!devices.count(DeviceIndex)) throw Exception("There is no audio output device with index " + ToString(DeviceIndex) + ".");
          AudioOutputDevice* pDevice = devices[DeviceIndex];
          std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
-         if (!parameters[ParamKey]) throw LinuxSamplerException("Audio output device " + ToString(DeviceIndex) + " does not have a device parameter '" + ParamKey + "'");
+         if (!parameters.count(ParamKey)) throw Exception("Audio output device " + ToString(DeviceIndex) + " does not have a device parameter '" + ParamKey + "'");
          parameters[ParamKey]->SetValue(ParamVal);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 1045 
 String LSCPServer::SetMidiInputDevicePar
+Line 1203 
 String LSCPServer::SetMidiInputDevicePar
      LSCPResultSet result;
      try {
          std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
-         if (!devices[DeviceIndex]) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
+         if (!devices.count(DeviceIndex)) throw Exception("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
          MidiInputDevice* pDevice = devices[DeviceIndex];
          std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
-         if (!parameters[ParamKey]) throw LinuxSamplerException("MIDI input device " + ToString(DeviceIndex) + " does not have a device parameter '" + ParamKey + "'");
+         if (!parameters.count(ParamKey)) throw Exception("MIDI input device " + ToString(DeviceIndex) + " does not have a device parameter '" + ParamKey + "'");
          parameters[ParamKey]->SetValue(ParamVal);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 1061 
 String LSCPServer::SetMidiInputPortParam
+Line 1219 
 String LSCPServer::SetMidiInputPortParam
      dmsg(2,("LSCPServer: SetMidiOutputDeviceParameter(DeviceIndex=%d,ParamKey=%s,ParamVal=%s)\n",DeviceIndex,ParamKey.c_str(),ParamVal.c_str()));
      LSCPResultSet result;
      try {
+         // get MIDI input device
          std::map<uint,MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
+         if (!devices.count(DeviceIndex)) throw Exception("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
          MidiInputDevice* pDevice = devices[DeviceIndex];
-         if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(DeviceIndex) + ".");
-         MidiInputDevice::MidiInputPort* pMidiInputPort = pDevice->GetPort(PortIndex);
+         // get MIDI port
-         if (!pMidiInputPort) throw LinuxSamplerException("There is no MIDI input port with index " + ToString(PortIndex) + ".");
+         MidiInputPort* pMidiInputPort = pDevice->GetPort(PortIndex);
-         std::map<String,DeviceCreationParameter*> parameters = pMidiInputPort->DeviceParameters();
+         if (!pMidiInputPort) throw Exception("There is no MIDI input port with index " + ToString(PortIndex) + ".");
-         if (!parameters[ParamKey]) throw LinuxSamplerException("MIDI input device " + ToString(PortIndex) + " does not have a parameter '" + ParamKey + "'");
+         // set port parameter value
+         std::map<String,DeviceRuntimeParameter*> parameters = pMidiInputPort->PortParameters();
+         if (!parameters.count(ParamKey)) throw Exception("MIDI input device " + ToString(PortIndex) + " does not have a parameter '" + ParamKey + "'");
          parameters[ParamKey]->SetValue(ParamVal);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
          result.Error(e);
      }
      return result.Produce();
-Line 1082 
 String LSCPServer::SetMidiInputPortParam
+Line 1245 
 String LSCPServer::SetMidiInputPortParam
   */
  String LSCPServer::SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel) {
      dmsg(2,("LSCPServer: SetAudioOutputChannel(ChannelAudioOutputChannel=%d, AudioOutputDeviceInputChannel=%d, SamplerChannel=%d)\n",ChannelAudioOutputChannel,AudioOutputDeviceInputChannel,uiSamplerChannel));
-     return "ERR:0:Not implemented yet.\r\n"; //FIXME: Add support for this in resultset class?
+     LSCPResultSet result;
+     try {
+         SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
+         if (!pEngineChannel) throw Exception("No engine type yet assigned to sampler channel " + ToString(uiSamplerChannel));
+         if (!pSamplerChannel->GetAudioOutputDevice()) throw Exception("No audio output device connected to sampler channel " + ToString(uiSamplerChannel));
+         pEngineChannel->SetOutputChannel(ChannelAudioOutputChannel, AudioOutputDeviceInputChannel);
+     }
+     catch (Exception e) {
+          result.Error(e);
+     }
+     return result.Produce();
  }
  String LSCPServer::SetAudioOutputDevice(uint AudioDeviceId, uint uiSamplerChannel) {
      dmsg(2,("LSCPServer: SetAudiotOutputDevice(AudioDeviceId=%d, SamplerChannel=%d)\n",AudioDeviceId,uiSamplerChannel));
      LSCPResultSet result;
+     LockRTNotify();
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
          std::map<uint, AudioOutputDevice*> devices = pSampler->GetAudioOutputDevices();
+         if (!devices.count(AudioDeviceId)) throw Exception("There is no audio output device with index " + ToString(AudioDeviceId));
          AudioOutputDevice* pDevice = devices[AudioDeviceId];
-         if (!pDevice) throw LinuxSamplerException("There is no audio output device with index " + ToString(AudioDeviceId));
          pSamplerChannel->SetAudioOutputDevice(pDevice);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
+     UnlockRTNotify();
      return result.Produce();
  }
  String LSCPServer::SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel) {
      dmsg(2,("LSCPServer: SetAudioOutputType(String AudioOutputDriver=%s, SamplerChannel=%d)\n",AudioOutputDriver.c_str(),uiSamplerChannel));
      LSCPResultSet result;
+     LockRTNotify();
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
          // Driver type name aliasing...
-         if (AudioOutputDriver == "ALSA") AudioOutputDriver = "Alsa";
+         if (AudioOutputDriver == "Alsa") AudioOutputDriver = "ALSA";
-         if (AudioOutputDriver == "JACK") AudioOutputDriver = "Jack";
+         if (AudioOutputDriver == "Jack") AudioOutputDriver = "JACK";
          // Check if there's one audio output device already created
          // for the intended audio driver type (AudioOutputDriver)...
          AudioOutputDevice *pDevice = NULL;
-Line 1129 
 String LSCPServer::SetAudioOutputType(St
+Line 1307 
 String LSCPServer::SetAudioOutputType(St
          }
          // Must have a device...
          if (pDevice == NULL)
-             throw LinuxSamplerException("Internal error: could not create audio output device.");
+             throw Exception("Internal error: could not create audio output device.");
          // Set it as the current channel device...
          pSamplerChannel->SetAudioOutputDevice(pDevice);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
+     UnlockRTNotify();
      return result.Produce();
  }
-Line 1144 
 String LSCPServer::SetMIDIInputPort(uint
+Line 1323 
 String LSCPServer::SetMIDIInputPort(uint
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
          pSamplerChannel->SetMidiInputPort(MIDIPort);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 1158 
 String LSCPServer::SetMIDIInputChannel(u
+Line 1337 
 String LSCPServer::SetMIDIInputChannel(u
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
-         pSamplerChannel->SetMidiInputChannel((MidiInputDevice::MidiInputPort::midi_chan_t) MIDIChannel);
+         pSamplerChannel->SetMidiInputChannel((midi_chan_t) MIDIChannel);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 1172 
 String LSCPServer::SetMIDIInputDevice(ui
+Line 1351 
 String LSCPServer::SetMIDIInputDevice(ui
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
          std::map<uint, MidiInputDevice*> devices = pSampler->GetMidiInputDevices();
+         if (!devices.count(MIDIDeviceId)) throw Exception("There is no MIDI input device with index " + ToString(MIDIDeviceId));
          MidiInputDevice* pDevice = devices[MIDIDeviceId];
-         if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(MIDIDeviceId));
          pSamplerChannel->SetMidiInputDevice(pDevice);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 1189 
 String LSCPServer::SetMIDIInputType(Stri
+Line 1368 
 String LSCPServer::SetMIDIInputType(Stri
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
          // Driver type name aliasing...
-         if (MidiInputDriver == "ALSA") MidiInputDriver = "Alsa";
+         if (MidiInputDriver == "Alsa") MidiInputDriver = "ALSA";
          // Check if there's one MIDI input device already created
          // for the intended MIDI driver type (MidiInputDriver)...
          MidiInputDevice *pDevice = NULL;
-Line 1209 
 String LSCPServer::SetMIDIInputType(Stri
+Line 1388 
 String LSCPServer::SetMIDIInputType(Stri
              pDevice = pSampler->CreateMidiInputDevice(MidiInputDriver, params);
              // Make it with at least one initial port.
              std::map<String,DeviceCreationParameter*> parameters = pDevice->DeviceParameters();
-             parameters["ports"]->SetValue("1");
+             parameters["PORTS"]->SetValue("1");
          }
          // Must have a device...
          if (pDevice == NULL)
-             throw LinuxSamplerException("Internal error: could not create MIDI input device.");
+             throw Exception("Internal error: could not create MIDI input device.");
          // Set it as the current channel device...
          pSamplerChannel->SetMidiInputDevice(pDevice);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 1232 
 String LSCPServer::SetMIDIInput(uint MID
+Line 1411 
 String LSCPServer::SetMIDIInput(uint MID
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Invalid channel number " + ToString(uiSamplerChannel));
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
          std::map<uint, MidiInputDevice*> devices =  pSampler->GetMidiInputDevices();
+         if (!devices.count(MIDIDeviceId)) throw Exception("There is no MIDI input device with index " + ToString(MIDIDeviceId));
          MidiInputDevice* pDevice = devices[MIDIDeviceId];
-         if (!pDevice) throw LinuxSamplerException("There is no MIDI input device with index " + ToString(MIDIDeviceId));
+         pSamplerChannel->SetMidiInput(pDevice, MIDIPort, (midi_chan_t) MIDIChannel);
-         pSamplerChannel->SetMidiInput(pDevice, MIDIPort, (MidiInputDevice::MidiInputPort::midi_chan_t) MIDIChannel);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
-Line 1248 
 String LSCPServer::SetMIDIInput(uint MID
+Line 1427 
 String LSCPServer::SetMIDIInput(uint MID
   * Will be called by the parser to change the global volume factor on a
   * particular sampler channel.
   */
- String LSCPServer::SetVolume(double Volume, uint uiSamplerChannel) {
+ String LSCPServer::SetVolume(double dVolume, uint uiSamplerChannel) {
-     dmsg(2,("LSCPServer: SetVolume(Volume=%f, SamplerChannel=%d)\n", Volume, uiSamplerChannel));
+     dmsg(2,("LSCPServer: SetVolume(Volume=%f, SamplerChannel=%d)\n", dVolume, uiSamplerChannel));
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
-         Engine* pEngine = pSamplerChannel->GetEngine();
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
-         if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
+         if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
-         pEngine->Volume(Volume);
+         pEngineChannel->Volume(dVolume);
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
  }
  /**
+  * Will be called by the parser to mute/unmute particular sampler channel.
+  */
+ String LSCPServer::SetChannelMute(bool bMute, uint uiSamplerChannel) {
+     dmsg(2,("LSCPServer: SetChannelMute(bMute=%d,uiSamplerChannel=%d)\n",bMute,uiSamplerChannel));
+     LSCPResultSet result;
+     try {
+         SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
+         if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
+         if(!bMute) pEngineChannel->SetMute((HasSoloChannel() && !pEngineChannel->GetSolo()) ? -1 : 0);
+         else pEngineChannel->SetMute(1);
+     } catch (Exception e) {
+         result.Error(e);
+     }
+     return result.Produce();
+ }
+ /**
+  * Will be called by the parser to solo particular sampler channel.
+  */
+ String LSCPServer::SetChannelSolo(bool bSolo, uint uiSamplerChannel) {
+     dmsg(2,("LSCPServer: SetChannelSolo(bSolo=%d,uiSamplerChannel=%d)\n",bSolo,uiSamplerChannel));
+     LSCPResultSet result;
+     try {
+         SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
+         if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
+         bool oldSolo = pEngineChannel->GetSolo();
+         bool hadSoloChannel = HasSoloChannel();
+         pEngineChannel->SetSolo(bSolo);
+         if(!oldSolo && bSolo) {
+             if(pEngineChannel->GetMute() == -1) pEngineChannel->SetMute(0);
+             if(!hadSoloChannel) MuteNonSoloChannels();
+         }
+         if(oldSolo && !bSolo) {
+             if(!HasSoloChannel()) UnmuteChannels();
+             else if(!pEngineChannel->GetMute()) pEngineChannel->SetMute(-1);
+         }
+     } catch (Exception e) {
+         result.Error(e);
+     }
+     return result.Produce();
+ }
+ /**
+  * Determines whether there is at least one solo channel in the channel list.
+  *
+  * @returns true if there is at least one solo channel in the channel list,
+  * false otherwise.
+  */
+ bool LSCPServer::HasSoloChannel() {
+     std::map<uint,SamplerChannel*> channels = pSampler->GetSamplerChannels();
+     std::map<uint,SamplerChannel*>::iterator iter = channels.begin();
+     for (; iter != channels.end(); iter++) {
+         EngineChannel* c = iter->second->GetEngineChannel();
+         if(c && c->GetSolo()) return true;
+     }
+     return false;
+ }
+ /**
+  * Mutes all unmuted non-solo channels. Notice that the channels are muted
+  * with -1 which indicates that they are muted because of the presence
+  * of a solo channel(s). Channels muted with -1 will be automatically unmuted
+  * when there are no solo channels left.
+  */
+ void LSCPServer::MuteNonSoloChannels() {
+     dmsg(2,("LSCPServer: MuteNonSoloChannels()\n"));
+     std::map<uint,SamplerChannel*> channels = pSampler->GetSamplerChannels();
+     std::map<uint,SamplerChannel*>::iterator iter = channels.begin();
+     for (; iter != channels.end(); iter++) {
+         EngineChannel* c = iter->second->GetEngineChannel();
+         if(c && !c->GetSolo() && !c->GetMute()) c->SetMute(-1);
+     }
+ }
+ /**
+  * Unmutes all channels that are muted because of the presence
+  * of a solo channel(s).
+  */
+ void  LSCPServer::UnmuteChannels() {
+     dmsg(2,("LSCPServer: UnmuteChannels()\n"));
+     std::map<uint,SamplerChannel*> channels = pSampler->GetSamplerChannels();
+     std::map<uint,SamplerChannel*>::iterator iter = channels.begin();
+     for (; iter != channels.end(); iter++) {
+         EngineChannel* c = iter->second->GetEngineChannel();
+         if(c && c->GetMute() == -1) c->SetMute(0);
+     }
+ }
+ /**
   * Will be called by the parser to reset a particular sampler channel.
   */
  String LSCPServer::ResetChannel(uint uiSamplerChannel) {
-Line 1272 
 String LSCPServer::ResetChannel(uint uiS
+Line 1552 
 String LSCPServer::ResetChannel(uint uiS
      LSCPResultSet result;
      try {
          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
-         if (!pSamplerChannel) throw LinuxSamplerException("Index out of bounds");
+         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
-         Engine* pEngine = pSamplerChannel->GetEngine();
+         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
-         if (!pEngine) throw LinuxSamplerException("No engine loaded on channel");
+         if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
-         pEngine->Reset();
+         pEngineChannel->Reset();
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
  }
  /**
+  * Will be called by the parser to reset the whole sampler.
+  */
+ String LSCPServer::ResetSampler() {
+     dmsg(2,("LSCPServer: ResetSampler()\n"));
+     pSampler->Reset();
+     LSCPResultSet result;
+     return result.Produce();
+ }
+ /**
+  * Will be called by the parser to return general informations about this
+  * sampler.
+  */
+ String LSCPServer::GetServerInfo() {
+     dmsg(2,("LSCPServer: GetServerInfo()\n"));
+     LSCPResultSet result;
+     result.Add("DESCRIPTION", "LinuxSampler - modular, streaming capable sampler");
+     result.Add("VERSION", VERSION);
+     result.Add("PROTOCOL_VERSION", "1.0");
+     return result.Produce();
+ }
+ /**
+  * Will be called by the parser to return the current number of all active voices.
+  */
+ String LSCPServer::GetTotalVoiceCount() {
+     dmsg(2,("LSCPServer: GetTotalVoiceCount()\n"));
+     LSCPResultSet result;
+     result.Add(pSampler->GetVoiceCount());
+     return result.Produce();
+ }
+ /**
+  * Will be called by the parser to return the maximum number of voices.
+  */
+ String LSCPServer::GetTotalVoiceCountMax() {
+     dmsg(2,("LSCPServer: GetTotalVoiceCountMax()\n"));
+     LSCPResultSet result;
+     result.Add(EngineFactory::EngineInstances().size() * CONFIG_MAX_VOICES);
+     return result.Produce();
+ }
+ /**
   * Will be called by the parser to subscribe a client (frontend) on the
   * server for receiving event messages.
   */
-Line 1309 
 String LSCPServer::UnsubscribeNotificati
+Line 1632 
 String LSCPServer::UnsubscribeNotificati
      return result.Produce();
  }
+ static int select_callback(void * lscpResultSet, int argc,
+                         char **argv, char **azColName)
+ {
+     LSCPResultSet* resultSet = (LSCPResultSet*) lscpResultSet;
+     resultSet->Add(argc, argv);
+     return 0;
+ }
+ String LSCPServer::QueryDatabase(String query) {
+     LSCPResultSet result;
+ #if HAVE_SQLITE3
+     char* zErrMsg = NULL;
+     sqlite3 *db;
+     String selectStr = "SELECT " + query;
+     int rc = sqlite3_open("linuxsampler.db", &db);
+     if (rc == SQLITE_OK)
+     {
+             rc = sqlite3_exec(db, selectStr.c_str(), select_callback, &result, &zErrMsg);
+     }
+     if ( rc != SQLITE_OK )
+     {
+             result.Error(String(zErrMsg), rc);
+     }
+     sqlite3_close(db);
+ #else
+     result.Error(String("SQLITE3 was not installed when linuxsampler was built. SELECT statement is not available."), 0);
+ #endif
+     return result.Produce();
+ }
  /**
   * Will be called by the parser to enable or disable echo mode; if echo
   * mode is enabled, all commands from the client will (immediately) be
-Line 1320 
 String LSCPServer::SetEcho(yyparse_param
+Line 1674 
 String LSCPServer::SetEcho(yyparse_param
      try {
          if      (boolean_value == 0) pSession->bVerbose = false;
          else if (boolean_value == 1) pSession->bVerbose = true;
-         else throw LinuxSamplerException("Not a boolean value, must either be 0 or 1");
+         else throw Exception("Not a boolean value, must either be 0 or 1");
      }
-     catch (LinuxSamplerException e) {
+     catch (Exception e) {
           result.Error(e);
      }
      return result.Produce();
  }
- // Instrument loader constructor.
- LSCPLoadInstrument::LSCPLoadInstrument(Engine* pEngine, String Filename, uint uiInstrument)
-     : Thread(false, 0, -4)
- {
-     this->pEngine = pEngine;
-     this->Filename = Filename;
-     this->uiInstrument = uiInstrument;
- }
- // Instrument loader process.
- int LSCPLoadInstrument::Main()
- {
-     try {
-         pEngine->LoadInstrument(Filename.c_str(), uiInstrument);
-     }
-     catch (LinuxSamplerException e) {
-         e.PrintMessage();
-     }
-     // Always re-enable the engine.
-     pEngine->Enable();
-     // FIXME: Shoot ourselves on the foot?
-     delete this;
- }

 Legend:



Removed from v.211
 


changed lines


 
Added in v.905
 Legend:



Removed from v.211
 


changed lines


 
Added in v.905
-Removed from v.211
+Added in v.905

	ViewVC Help
Powered by ViewVC