/[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 1005 by schoenebeck, Fri Dec 29 20:06:14 2006 UTC revision 1353 by iliev, Mon Sep 17 23:15:25 2007 UTC
# Line 3  Line 3 
3   *   LinuxSampler - modular, streaming capable sampler                     *   *   LinuxSampler - modular, streaming capable sampler                     *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
6   *   Copyright (C) 2005, 2006 Christian Schoenebeck                        *   *   Copyright (C) 2005 - 2007 Christian Schoenebeck                       *
7   *                                                                         *   *                                                                         *
8   *   This library 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  *
# Line 24  Line 24 
24  #include "lscpserver.h"  #include "lscpserver.h"
25  #include "lscpresultset.h"  #include "lscpresultset.h"
26  #include "lscpevent.h"  #include "lscpevent.h"
 #include "../common/global.h"  
27    
28  #include <fcntl.h>  #include <fcntl.h>
29    
30  #if HAVE_SQLITE3  #if ! HAVE_SQLITE3
31  # include "sqlite3.h"  #define DOESNT_HAVE_SQLITE3 "No database support. SQLITE3 was not installed when linuxsampler was built."
32  #endif  #endif
33    
34  #include "../engines/EngineFactory.h"  #include "../engines/EngineFactory.h"
# Line 53  Line 52 
52  fd_set LSCPServer::fdSet;  fd_set LSCPServer::fdSet;
53  int LSCPServer::currentSocket = -1;  int LSCPServer::currentSocket = -1;
54  std::vector<yyparse_param_t> LSCPServer::Sessions = std::vector<yyparse_param_t>();  std::vector<yyparse_param_t> LSCPServer::Sessions = std::vector<yyparse_param_t>();
55    std::vector<yyparse_param_t>::iterator itCurrentSession = std::vector<yyparse_param_t>::iterator();
56  std::map<int,String> LSCPServer::bufferedNotifies = std::map<int,String>();  std::map<int,String> LSCPServer::bufferedNotifies = std::map<int,String>();
57  std::map<int,String> LSCPServer::bufferedCommands = std::map<int,String>();  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> >();  std::map< LSCPEvent::event_t, std::list<int> > LSCPServer::eventSubscriptions = std::map< LSCPEvent::event_t, std::list<int> >();
# Line 75  LSCPServer::LSCPServer(Sampler* pSampler Line 75  LSCPServer::LSCPServer(Sampler* pSampler
75      LSCPEvent::RegisterEvent(LSCPEvent::event_stream_count, "STREAM_COUNT");      LSCPEvent::RegisterEvent(LSCPEvent::event_stream_count, "STREAM_COUNT");
76      LSCPEvent::RegisterEvent(LSCPEvent::event_buffer_fill, "BUFFER_FILL");      LSCPEvent::RegisterEvent(LSCPEvent::event_buffer_fill, "BUFFER_FILL");
77      LSCPEvent::RegisterEvent(LSCPEvent::event_channel_info, "CHANNEL_INFO");      LSCPEvent::RegisterEvent(LSCPEvent::event_channel_info, "CHANNEL_INFO");
78        LSCPEvent::RegisterEvent(LSCPEvent::event_fx_send_count, "FX_SEND_COUNT");
79        LSCPEvent::RegisterEvent(LSCPEvent::event_fx_send_info, "FX_SEND_INFO");
80      LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_map_count, "MIDI_INSTRUMENT_MAP_COUNT");      LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_map_count, "MIDI_INSTRUMENT_MAP_COUNT");
81      LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_map_info, "MIDI_INSTRUMENT_MAP_INFO");      LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_map_info, "MIDI_INSTRUMENT_MAP_INFO");
82      LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_count, "MIDI_INSTRUMENT_COUNT");      LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_count, "MIDI_INSTRUMENT_COUNT");
83      LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_info, "MIDI_INSTRUMENT_INFO");      LSCPEvent::RegisterEvent(LSCPEvent::event_midi_instr_info, "MIDI_INSTRUMENT_INFO");
84        LSCPEvent::RegisterEvent(LSCPEvent::event_db_instr_dir_count, "DB_INSTRUMENT_DIRECTORY_COUNT");
85        LSCPEvent::RegisterEvent(LSCPEvent::event_db_instr_dir_info, "DB_INSTRUMENT_DIRECTORY_INFO");
86        LSCPEvent::RegisterEvent(LSCPEvent::event_db_instr_count, "DB_INSTRUMENT_COUNT");
87        LSCPEvent::RegisterEvent(LSCPEvent::event_db_instr_info, "DB_INSTRUMENT_INFO");
88        LSCPEvent::RegisterEvent(LSCPEvent::event_db_instrs_job_info, "DB_INSTRUMENTS_JOB_INFO");
89      LSCPEvent::RegisterEvent(LSCPEvent::event_misc, "MISCELLANEOUS");      LSCPEvent::RegisterEvent(LSCPEvent::event_misc, "MISCELLANEOUS");
90      LSCPEvent::RegisterEvent(LSCPEvent::event_total_voice_count, "TOTAL_VOICE_COUNT");      LSCPEvent::RegisterEvent(LSCPEvent::event_total_voice_count, "TOTAL_VOICE_COUNT");
91        LSCPEvent::RegisterEvent(LSCPEvent::event_global_info, "GLOBAL_INFO");
92      hSocket = -1;      hSocket = -1;
93  }  }
94    
# Line 88  LSCPServer::~LSCPServer() { Line 96  LSCPServer::~LSCPServer() {
96      if (hSocket >= 0) close(hSocket);      if (hSocket >= 0) close(hSocket);
97  }  }
98    
99    void LSCPServer::EventHandler::ChannelCountChanged(int NewCount) {
100        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_channel_count, NewCount));
101    }
102    
103    void LSCPServer::EventHandler::AudioDeviceCountChanged(int NewCount) {
104        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_audio_device_count, NewCount));
105    }
106    
107    void LSCPServer::EventHandler::MidiDeviceCountChanged(int NewCount) {
108        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_device_count, NewCount));
109    }
110    
111    void LSCPServer::EventHandler::MidiInstrumentCountChanged(int MapId, int NewCount) {
112        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_instr_count, MapId, NewCount));
113    }
114    
115    void LSCPServer::EventHandler::MidiInstrumentInfoChanged(int MapId, int Bank, int Program) {
116        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_instr_info, MapId, Bank, Program));
117    }
118    
119    void LSCPServer::EventHandler::MidiInstrumentMapCountChanged(int NewCount) {
120        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_instr_map_count, NewCount));
121    }
122    
123    void LSCPServer::EventHandler::MidiInstrumentMapInfoChanged(int MapId) {
124        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_midi_instr_map_info, MapId));
125    }
126    
127    void LSCPServer::EventHandler::FxSendCountChanged(int ChannelId, int NewCount) {
128        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_count, ChannelId, NewCount));
129    }
130    
131    void LSCPServer::EventHandler::VoiceCountChanged(int ChannelId, int NewCount) {
132        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_voice_count, ChannelId, NewCount));
133    }
134    
135    void LSCPServer::EventHandler::StreamCountChanged(int ChannelId, int NewCount) {
136        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_stream_count, ChannelId, NewCount));
137    }
138    
139    void LSCPServer::EventHandler::BufferFillChanged(int ChannelId, String FillData) {
140        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_buffer_fill, ChannelId, FillData));
141    }
142    
143    void LSCPServer::EventHandler::TotalVoiceCountChanged(int NewCount) {
144        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_total_voice_count, NewCount));
145    }
146    
147    #if HAVE_SQLITE3
148    void LSCPServer::DbInstrumentsEventHandler::DirectoryCountChanged(String Dir) {
149        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_dir_count, InstrumentsDb::toEscapedPath(Dir)));
150    }
151    
152    void LSCPServer::DbInstrumentsEventHandler::DirectoryInfoChanged(String Dir) {
153        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_dir_info, InstrumentsDb::toEscapedPath(Dir)));
154    }
155    
156    void LSCPServer::DbInstrumentsEventHandler::DirectoryNameChanged(String Dir, String NewName) {
157        Dir = "'" + InstrumentsDb::toEscapedPath(Dir) + "'";
158        NewName = "'" + InstrumentsDb::toEscapedPath(NewName) + "'";
159        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_dir_info, "NAME", Dir, NewName));
160    }
161    
162    void LSCPServer::DbInstrumentsEventHandler::InstrumentCountChanged(String Dir) {
163        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_count, InstrumentsDb::toEscapedPath(Dir)));
164    }
165    
166    void LSCPServer::DbInstrumentsEventHandler::InstrumentInfoChanged(String Instr) {
167        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_info, InstrumentsDb::toEscapedPath(Instr)));
168    }
169    
170    void LSCPServer::DbInstrumentsEventHandler::InstrumentNameChanged(String Instr, String NewName) {
171        Instr = "'" + InstrumentsDb::toEscapedPath(Instr) + "'";
172        NewName = "'" + InstrumentsDb::toEscapedPath(NewName) + "'";
173        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instr_info, "NAME", Instr, NewName));
174    }
175    
176    void LSCPServer::DbInstrumentsEventHandler::JobStatusChanged(int JobId) {
177        LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_db_instrs_job_info, JobId));
178    }
179    #endif // HAVE_SQLITE3
180    
181    
182  /**  /**
183   * Blocks the calling thread until the LSCP Server is initialized and   * Blocks the calling thread until the LSCP Server is initialized and
184   * accepting socket connections, if the server is already initialized then   * accepting socket connections, if the server is already initialized then
# Line 129  int LSCPServer::Main() { Line 220  int LSCPServer::Main() {
220      listen(hSocket, 1);      listen(hSocket, 1);
221      Initialized.Set(true);      Initialized.Set(true);
222    
223        // Registering event listeners
224        pSampler->AddChannelCountListener(&eventHandler);
225        pSampler->AddAudioDeviceCountListener(&eventHandler);
226        pSampler->AddMidiDeviceCountListener(&eventHandler);
227        pSampler->AddVoiceCountListener(&eventHandler);
228        pSampler->AddStreamCountListener(&eventHandler);
229        pSampler->AddBufferFillListener(&eventHandler);
230        pSampler->AddTotalVoiceCountListener(&eventHandler);
231        pSampler->AddFxSendCountListener(&eventHandler);
232        MidiInstrumentMapper::AddMidiInstrumentCountListener(&eventHandler);
233        MidiInstrumentMapper::AddMidiInstrumentInfoListener(&eventHandler);
234        MidiInstrumentMapper::AddMidiInstrumentMapCountListener(&eventHandler);
235        MidiInstrumentMapper::AddMidiInstrumentMapInfoListener(&eventHandler);
236    #if HAVE_SQLITE3
237        InstrumentsDb::GetInstrumentsDb()->AddInstrumentsDbListener(&dbInstrumentsEventHandler);
238    #endif
239      // now wait for client connections and handle their requests      // now wait for client connections and handle their requests
240      sockaddr_in client;      sockaddr_in client;
241      int length = sizeof(client);      int length = sizeof(client);
# Line 148  int LSCPServer::Main() { Line 255  int LSCPServer::Main() {
255                  if ((*itEngineChannel)->StatusChanged()) {                  if ((*itEngineChannel)->StatusChanged()) {
256                      SendLSCPNotify(LSCPEvent(LSCPEvent::event_channel_info, (*itEngineChannel)->iSamplerChannelIndex));                      SendLSCPNotify(LSCPEvent(LSCPEvent::event_channel_info, (*itEngineChannel)->iSamplerChannelIndex));
257                  }                  }
258    
259                    for (int i = 0; i < (*itEngineChannel)->GetFxSendCount(); i++) {
260                        FxSend* fxs = (*itEngineChannel)->GetFxSend(i);
261                        if(fxs != NULL && fxs->IsInfoChanged()) {
262                            int chn = (*itEngineChannel)->iSamplerChannelIndex;
263                            LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, chn, fxs->Id()));
264                            fxs->SetInfoChanged(false);
265                        }
266                    }
267              }              }
268          }          }
269    
# Line 212  int LSCPServer::Main() { Line 328  int LSCPServer::Main() {
328                                  int dummy; // just a temporary hack to fulfill the restart() function prototype                                  int dummy; // just a temporary hack to fulfill the restart() function prototype
329                                  restart(NULL, dummy); // restart the 'scanner'                                  restart(NULL, dummy); // restart the 'scanner'
330                                  currentSocket = (*iter).hSession;  //a hack                                  currentSocket = (*iter).hSession;  //a hack
331                                    itCurrentSession = iter; // another hack
332                                  dmsg(2,("LSCPServer: [%s]\n",bufferedCommands[currentSocket].c_str()));                                  dmsg(2,("LSCPServer: [%s]\n",bufferedCommands[currentSocket].c_str()));
333                                  if ((*iter).bVerbose) { // if echo mode enabled                                  if ((*iter).bVerbose) { // if echo mode enabled
334                                      AnswerClient(bufferedCommands[currentSocket]);                                      AnswerClient(bufferedCommands[currentSocket]);
335                                  }                                  }
336                                  int result = yyparse(&(*iter));                                  int result = yyparse(&(*iter));
337                                  currentSocket = -1;     //continuation of a hack                                  currentSocket = -1;     //continuation of a hack
338                                    itCurrentSession = Sessions.end(); // hack as well
339                                  dmsg(3,("LSCPServer: Done parsing on socket %d.\n", currentSocket));                                  dmsg(3,("LSCPServer: Done parsing on socket %d.\n", currentSocket));
340                                  if (result == LSCP_QUIT) { //Was it a quit command by any chance?                                  if (result == LSCP_QUIT) { //Was it a quit command by any chance?
341                                          CloseConnection(iter);                                          CloseConnection(iter);
# Line 310  extern int GetLSCPCommand( void *buf, in Line 428  extern int GetLSCPCommand( void *buf, in
428          return command.size();          return command.size();
429  }  }
430    
431    extern yyparse_param_t* GetCurrentYaccSession() {
432        return &(*itCurrentSession);
433    }
434    
435  /**  /**
436   * Will be called to try to read the command from the socket   * Will be called to try to read the command from the socket
437   * If command is read, it will return true. Otherwise false is returned.   * If command is read, it will return true. Otherwise false is returned.
# Line 490  String LSCPServer::DestroyMidiInputDevic Line 612  String LSCPServer::DestroyMidiInputDevic
612      return result.Produce();      return result.Produce();
613  }  }
614    
615    EngineChannel* LSCPServer::GetEngineChannel(uint uiSamplerChannel) {
616        SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
617        if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
618    
619        EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
620        if (!pEngineChannel) throw Exception("There is no engine deployed on this sampler channel yet");
621    
622        return pEngineChannel;
623    }
624    
625  /**  /**
626   * Will be called by the parser to load an instrument.   * Will be called by the parser to load an instrument.
627   */   */
# Line 670  String LSCPServer::GetChannelInfo(uint u Line 802  String LSCPServer::GetChannelInfo(uint u
802          String AudioRouting;          String AudioRouting;
803          int Mute = 0;          int Mute = 0;
804          bool Solo = false;          bool Solo = false;
805          String MidiInstrumentMap;          String MidiInstrumentMap = "NONE";
806    
807          if (pEngineChannel) {          if (pEngineChannel) {
808              EngineName          = pEngineChannel->EngineName();              EngineName          = pEngineChannel->EngineName();
# Line 1502  String LSCPServer::SetChannelSolo(bool b Line 1634  String LSCPServer::SetChannelSolo(bool b
1634    
1635          bool oldSolo = pEngineChannel->GetSolo();          bool oldSolo = pEngineChannel->GetSolo();
1636          bool hadSoloChannel = HasSoloChannel();          bool hadSoloChannel = HasSoloChannel();
1637            
1638          pEngineChannel->SetSolo(bSolo);          pEngineChannel->SetSolo(bSolo);
1639            
1640          if(!oldSolo && bSolo) {          if(!oldSolo && bSolo) {
1641              if(pEngineChannel->GetMute() == -1) pEngineChannel->SetMute(0);              if(pEngineChannel->GetMute() == -1) pEngineChannel->SetMute(0);
1642              if(!hadSoloChannel) MuteNonSoloChannels();              if(!hadSoloChannel) MuteNonSoloChannels();
1643          }          }
1644            
1645          if(oldSolo && !bSolo) {          if(oldSolo && !bSolo) {
1646              if(!HasSoloChannel()) UnmuteChannels();              if(!HasSoloChannel()) UnmuteChannels();
1647              else if(!pEngineChannel->GetMute()) pEngineChannel->SetMute(-1);              else if(!pEngineChannel->GetMute()) pEngineChannel->SetMute(-1);
# Line 1567  void  LSCPServer::UnmuteChannels() { Line 1699  void  LSCPServer::UnmuteChannels() {
1699      }      }
1700  }  }
1701    
1702  String LSCPServer::AddOrReplaceMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg, String EngineType, String InstrumentFile, uint InstrumentIndex, float Volume, MidiInstrumentMapper::mode_t LoadMode, String Name) {  String LSCPServer::AddOrReplaceMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg, String EngineType, String InstrumentFile, uint InstrumentIndex, float Volume, MidiInstrumentMapper::mode_t LoadMode, String Name, bool bModal) {
1703      dmsg(2,("LSCPServer: AddOrReplaceMIDIInstrumentMapping()\n"));      dmsg(2,("LSCPServer: AddOrReplaceMIDIInstrumentMapping()\n"));
1704    
1705      midi_prog_index_t idx;      midi_prog_index_t idx;
# Line 1585  String LSCPServer::AddOrReplaceMIDIInstr Line 1717  String LSCPServer::AddOrReplaceMIDIInstr
1717    
1718      LSCPResultSet result;      LSCPResultSet result;
1719      try {      try {
1720          // PERSISTENT mapping commands might bloock for a long time, so in          // PERSISTENT mapping commands might block for a long time, so in
1721          // that case we add/replace the mapping in another thread          // that case we add/replace the mapping in another thread in case
1722          bool bInBackground = (entry.LoadMode == MidiInstrumentMapper::PERSISTENT);          // the NON_MODAL argument was supplied, non persistent mappings
1723            // should return immediately, so we don't need to do that for them
1724            bool bInBackground = (entry.LoadMode == MidiInstrumentMapper::PERSISTENT && !bModal);
1725          MidiInstrumentMapper::AddOrReplaceEntry(MidiMapID, idx, entry, bInBackground);          MidiInstrumentMapper::AddOrReplaceEntry(MidiMapID, idx, entry, bInBackground);
1726      } catch (Exception e) {      } catch (Exception e) {
1727          result.Error(e);          result.Error(e);
# Line 1698  String LSCPServer::ListMidiInstrumentMap Line 1832  String LSCPServer::ListMidiInstrumentMap
1832          for (; iter != mappings.end(); iter++) {          for (; iter != mappings.end(); iter++) {
1833              if (s.size()) s += ",";              if (s.size()) s += ",";
1834              s += "{" + ToString(MidiMapID) + ","              s += "{" + ToString(MidiMapID) + ","
1835                       + ToString((int(iter->first.midi_bank_msb) << 7) & int(iter->first.midi_bank_lsb)) + ","                       + ToString((int(iter->first.midi_bank_msb) << 7) | int(iter->first.midi_bank_lsb)) + ","
1836                       + ToString(int(iter->first.midi_prog)) + "}";                       + ToString(int(iter->first.midi_prog)) + "}";
1837          }          }
1838          result.Add(s);          result.Add(s);
# Line 1720  String LSCPServer::ListAllMidiInstrument Line 1854  String LSCPServer::ListAllMidiInstrument
1854              for (; iter != mappings.end(); iter++) {              for (; iter != mappings.end(); iter++) {
1855                  if (s.size()) s += ",";                  if (s.size()) s += ",";
1856                  s += "{" + ToString(maps[i]) + ","                  s += "{" + ToString(maps[i]) + ","
1857                           + ToString((int(iter->first.midi_bank_msb) << 7) & int(iter->first.midi_bank_lsb)) + ","                           + ToString((int(iter->first.midi_bank_msb) << 7) | int(iter->first.midi_bank_lsb)) + ","
1858                           + ToString(int(iter->first.midi_prog)) + "}";                           + ToString(int(iter->first.midi_prog)) + "}";
1859              }              }
1860          }          }
# Line 1822  String LSCPServer::GetMidiInstrumentMap( Line 1956  String LSCPServer::GetMidiInstrumentMap(
1956      LSCPResultSet result;      LSCPResultSet result;
1957      try {      try {
1958          result.Add("NAME", MidiInstrumentMapper::MapName(MidiMapID));          result.Add("NAME", MidiInstrumentMapper::MapName(MidiMapID));
1959            result.Add("DEFAULT", MidiInstrumentMapper::GetDefaultMap() == MidiMapID);
1960      } catch (Exception e) {      } catch (Exception e) {
1961          result.Error(e);          result.Error(e);
1962      }      }
# Line 1870  String LSCPServer::CreateFxSend(uint uiS Line 2005  String LSCPServer::CreateFxSend(uint uiS
2005      dmsg(2,("LSCPServer: CreateFxSend()\n"));      dmsg(2,("LSCPServer: CreateFxSend()\n"));
2006      LSCPResultSet result;      LSCPResultSet result;
2007      try {      try {
2008          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);          EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));  
   
         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();  
         if (!pEngineChannel) throw Exception("There is no engine deployed on this sampler channel yet");  
2009    
2010          FxSend* pFxSend = pEngineChannel->AddFxSend(MidiCtrl, Name);          FxSend* pFxSend = pEngineChannel->AddFxSend(MidiCtrl, Name);
2011          if (!pFxSend) throw Exception("Could not add FxSend, don't ask, I don't know why (probably a bug)");          if (!pFxSend) throw Exception("Could not add FxSend, don't ask, I don't know why (probably a bug)");
# Line 1890  String LSCPServer::DestroyFxSend(uint ui Line 2021  String LSCPServer::DestroyFxSend(uint ui
2021      dmsg(2,("LSCPServer: DestroyFxSend()\n"));      dmsg(2,("LSCPServer: DestroyFxSend()\n"));
2022      LSCPResultSet result;      LSCPResultSet result;
2023      try {      try {
2024          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);          EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));  
   
         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();  
         if (!pEngineChannel) throw Exception("There is no engine deployed on this sampler channel yet");  
2025    
2026          FxSend* pFxSend = NULL;          FxSend* pFxSend = NULL;
2027          for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {          for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {
# Line 1915  String LSCPServer::GetFxSends(uint uiSam Line 2042  String LSCPServer::GetFxSends(uint uiSam
2042      dmsg(2,("LSCPServer: GetFxSends()\n"));      dmsg(2,("LSCPServer: GetFxSends()\n"));
2043      LSCPResultSet result;      LSCPResultSet result;
2044      try {      try {
2045          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);          EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));  
   
         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();  
         if (!pEngineChannel) throw Exception("There is no engine deployed on this sampler channel yet");  
2046    
2047          result.Add(pEngineChannel->GetFxSendCount());          result.Add(pEngineChannel->GetFxSendCount());
2048      } catch (Exception e) {      } catch (Exception e) {
# Line 1933  String LSCPServer::ListFxSends(uint uiSa Line 2056  String LSCPServer::ListFxSends(uint uiSa
2056      LSCPResultSet result;      LSCPResultSet result;
2057      String list;      String list;
2058      try {      try {
2059          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);          EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));  
   
         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();  
         if (!pEngineChannel) throw Exception("There is no engine deployed on this sampler channel yet");  
2060    
2061          for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {          for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {
2062              FxSend* pFxSend = pEngineChannel->GetFxSend(i);              FxSend* pFxSend = pEngineChannel->GetFxSend(i);
# Line 1951  String LSCPServer::ListFxSends(uint uiSa Line 2070  String LSCPServer::ListFxSends(uint uiSa
2070      return result.Produce();      return result.Produce();
2071  }  }
2072    
2073    FxSend* LSCPServer::GetFxSend(uint uiSamplerChannel, uint FxSendID) {
2074        EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
2075    
2076        FxSend* pFxSend = NULL;
2077        for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {
2078            if (pEngineChannel->GetFxSend(i)->Id() == FxSendID) {
2079                pFxSend = pEngineChannel->GetFxSend(i);
2080                break;
2081            }
2082        }
2083        if (!pFxSend) throw Exception("There is no FxSend with that ID on the given sampler channel");
2084        return pFxSend;
2085    }
2086    
2087  String LSCPServer::GetFxSendInfo(uint uiSamplerChannel, uint FxSendID) {  String LSCPServer::GetFxSendInfo(uint uiSamplerChannel, uint FxSendID) {
2088      dmsg(2,("LSCPServer: GetFxSendInfo()\n"));      dmsg(2,("LSCPServer: GetFxSendInfo()\n"));
2089      LSCPResultSet result;      LSCPResultSet result;
2090      try {      try {
2091          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);          EngineChannel* pEngineChannel = GetEngineChannel(uiSamplerChannel);
2092          if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));          FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
   
         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();  
         if (!pEngineChannel) throw Exception("There is no engine deployed on this sampler channel yet");  
   
         FxSend* pFxSend = NULL;  
         for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {  
             if (pEngineChannel->GetFxSend(i)->Id() == FxSendID) {  
                 pFxSend = pEngineChannel->GetFxSend(i);  
                 break;  
             }  
         }  
         if (!pFxSend) throw Exception("There is no FxSend with that ID on the given sampler channel");  
2093    
2094          // gather audio routing informations          // gather audio routing informations
2095          String AudioRouting;          String AudioRouting;
# Line 1979  String LSCPServer::GetFxSendInfo(uint ui Line 2100  String LSCPServer::GetFxSendInfo(uint ui
2100    
2101          // success          // success
2102          result.Add("NAME", pFxSend->Name());          result.Add("NAME", pFxSend->Name());
2103            result.Add("MIDI_CONTROLLER", pFxSend->MidiController());
2104            result.Add("LEVEL", ToString(pFxSend->Level()));
2105          result.Add("AUDIO_OUTPUT_ROUTING", AudioRouting);          result.Add("AUDIO_OUTPUT_ROUTING", AudioRouting);
2106      } catch (Exception e) {      } catch (Exception e) {
2107          result.Error(e);          result.Error(e);
# Line 1986  String LSCPServer::GetFxSendInfo(uint ui Line 2109  String LSCPServer::GetFxSendInfo(uint ui
2109      return result.Produce();      return result.Produce();
2110  }  }
2111    
2112    String LSCPServer::SetFxSendName(uint uiSamplerChannel, uint FxSendID, String Name) {
2113        dmsg(2,("LSCPServer: SetFxSendName()\n"));
2114        LSCPResultSet result;
2115        try {
2116            FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
2117    
2118            pFxSend->SetName(Name);
2119            LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, uiSamplerChannel, FxSendID));
2120        } catch (Exception e) {
2121            result.Error(e);
2122        }
2123        return result.Produce();
2124    }
2125    
2126  String LSCPServer::SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel) {  String LSCPServer::SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel) {
2127      dmsg(2,("LSCPServer: SetFxSendAudioOutputChannel()\n"));      dmsg(2,("LSCPServer: SetFxSendAudioOutputChannel()\n"));
2128      LSCPResultSet result;      LSCPResultSet result;
2129      try {      try {
2130          SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);          FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
         if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));  
2131    
2132          EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();          pFxSend->SetDestinationChannel(FxSendChannel, DeviceChannel);
2133          if (!pEngineChannel) throw Exception("There is no engine deployed on this sampler channel yet");          LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, uiSamplerChannel, FxSendID));
2134        } catch (Exception e) {
2135            result.Error(e);
2136        }
2137        return result.Produce();
2138    }
2139    
2140          FxSend* pFxSend = NULL;  String LSCPServer::SetFxSendMidiController(uint uiSamplerChannel, uint FxSendID, uint MidiController) {
2141          for (int i = 0; i < pEngineChannel->GetFxSendCount(); i++) {      dmsg(2,("LSCPServer: SetFxSendMidiController()\n"));
2142              if (pEngineChannel->GetFxSend(i)->Id() == FxSendID) {      LSCPResultSet result;
2143                  pFxSend = pEngineChannel->GetFxSend(i);      try {
2144                  break;          FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
             }  
         }  
         if (!pFxSend) throw Exception("There is no FxSend with that ID on the given sampler channel");  
2145    
2146          pFxSend->SetDestinationChannel(FxSendChannel, DeviceChannel);          pFxSend->SetMidiController(MidiController);
2147            LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, uiSamplerChannel, FxSendID));
2148        } catch (Exception e) {
2149            result.Error(e);
2150        }
2151        return result.Produce();
2152    }
2153    
2154    String LSCPServer::SetFxSendLevel(uint uiSamplerChannel, uint FxSendID, double dLevel) {
2155        dmsg(2,("LSCPServer: SetFxSendLevel()\n"));
2156        LSCPResultSet result;
2157        try {
2158            FxSend* pFxSend = GetFxSend(uiSamplerChannel, FxSendID);
2159    
2160            pFxSend->SetLevel((float)dLevel);
2161            LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_fx_send_info, uiSamplerChannel, FxSendID));
2162        } catch (Exception e) {
2163            result.Error(e);
2164        }
2165        return result.Produce();
2166    }
2167    
2168    String LSCPServer::EditSamplerChannelInstrument(uint uiSamplerChannel) {
2169        dmsg(2,("LSCPServer: EditSamplerChannelInstrument(SamplerChannel=%d)\n", uiSamplerChannel));
2170        LSCPResultSet result;
2171        try {
2172            SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(uiSamplerChannel);
2173            if (!pSamplerChannel) throw Exception("Invalid sampler channel number " + ToString(uiSamplerChannel));
2174            EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
2175            if (!pEngineChannel) throw Exception("No engine type assigned to sampler channel");
2176            if (pEngineChannel->InstrumentStatus() < 0) throw Exception("No instrument loaded to sampler channel");
2177            Engine* pEngine = pEngineChannel->GetEngine();
2178            InstrumentManager* pInstrumentManager = pEngine->GetInstrumentManager();
2179            if (!pInstrumentManager) throw Exception("Engine does not provide an instrument manager");
2180            InstrumentManager::instrument_id_t instrumentID;
2181            instrumentID.FileName = pEngineChannel->InstrumentFileName();
2182            instrumentID.Index    = pEngineChannel->InstrumentIndex();
2183            pInstrumentManager->LaunchInstrumentEditor(instrumentID);
2184      } catch (Exception e) {      } catch (Exception e) {
2185          result.Error(e);          result.Error(e);
2186      }      }
# Line 2051  String LSCPServer::GetServerInfo() { Line 2226  String LSCPServer::GetServerInfo() {
2226      result.Add("DESCRIPTION", "LinuxSampler - modular, streaming capable sampler");      result.Add("DESCRIPTION", "LinuxSampler - modular, streaming capable sampler");
2227      result.Add("VERSION", VERSION);      result.Add("VERSION", VERSION);
2228      result.Add("PROTOCOL_VERSION", ToString(LSCP_RELEASE_MAJOR) + "." + ToString(LSCP_RELEASE_MINOR));      result.Add("PROTOCOL_VERSION", ToString(LSCP_RELEASE_MAJOR) + "." + ToString(LSCP_RELEASE_MINOR));
2229    #if HAVE_SQLITE3
2230        result.Add("INSTRUMENTS_DB_SUPPORT", "yes");
2231    #else
2232        result.Add("INSTRUMENTS_DB_SUPPORT", "no");
2233    #endif
2234    
2235      return result.Produce();      return result.Produce();
2236  }  }
2237    
# Line 2085  String LSCPServer::SetGlobalVolume(doubl Line 2266  String LSCPServer::SetGlobalVolume(doubl
2266      try {      try {
2267          if (dVolume < 0) throw Exception("Volume may not be negative");          if (dVolume < 0) throw Exception("Volume may not be negative");
2268          GLOBAL_VOLUME = dVolume; // see common/global.cpp          GLOBAL_VOLUME = dVolume; // see common/global.cpp
2269            LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_global_info, "VOLUME", GLOBAL_VOLUME));
2270      } catch (Exception e) {      } catch (Exception e) {
2271          result.Error(e);          result.Error(e);
2272      }      }
# Line 2117  String LSCPServer::UnsubscribeNotificati Line 2299  String LSCPServer::UnsubscribeNotificati
2299      return result.Produce();      return result.Produce();
2300  }  }
2301    
2302  static int select_callback(void * lscpResultSet, int argc,  String LSCPServer::AddDbInstrumentDirectory(String Dir) {
2303                          char **argv, char **azColName)      dmsg(2,("LSCPServer: AddDbInstrumentDirectory(Dir=%s)\n", Dir.c_str()));
2304  {      LSCPResultSet result;
2305      LSCPResultSet* resultSet = (LSCPResultSet*) lscpResultSet;  #if HAVE_SQLITE3
2306      resultSet->Add(argc, argv);      try {
2307      return 0;          InstrumentsDb::GetInstrumentsDb()->AddDirectory(Dir);
2308        } catch (Exception e) {
2309             result.Error(e);
2310        }
2311    #else
2312        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2313    #endif
2314        return result.Produce();
2315    }
2316    
2317    String LSCPServer::RemoveDbInstrumentDirectory(String Dir, bool Force) {
2318        dmsg(2,("LSCPServer: RemoveDbInstrumentDirectory(Dir=%s,Force=%d)\n", Dir.c_str(), Force));
2319        LSCPResultSet result;
2320    #if HAVE_SQLITE3
2321        try {
2322            InstrumentsDb::GetInstrumentsDb()->RemoveDirectory(Dir, Force);
2323        } catch (Exception e) {
2324             result.Error(e);
2325        }
2326    #else
2327        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2328    #endif
2329        return result.Produce();
2330  }  }
2331    
2332  String LSCPServer::QueryDatabase(String query) {  String LSCPServer::GetDbInstrumentDirectoryCount(String Dir, bool Recursive) {
2333        dmsg(2,("LSCPServer: GetDbInstrumentDirectoryCount(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
2334      LSCPResultSet result;      LSCPResultSet result;
2335  #if HAVE_SQLITE3  #if HAVE_SQLITE3
2336      char* zErrMsg = NULL;      try {
2337      sqlite3 *db;          result.Add(InstrumentsDb::GetInstrumentsDb()->GetDirectoryCount(Dir, Recursive));
2338      String selectStr = "SELECT " + query;      } catch (Exception e) {
2339             result.Error(e);
2340        }
2341    #else
2342        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2343    #endif
2344        return result.Produce();
2345    }
2346    
2347      int rc = sqlite3_open("linuxsampler.db", &db);  String LSCPServer::GetDbInstrumentDirectories(String Dir, bool Recursive) {
2348      if (rc == SQLITE_OK)      dmsg(2,("LSCPServer: GetDbInstrumentDirectories(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
2349      {      LSCPResultSet result;
2350              rc = sqlite3_exec(db, selectStr.c_str(), select_callback, &result, &zErrMsg);  #if HAVE_SQLITE3
2351        try {
2352            String list;
2353            StringListPtr dirs = InstrumentsDb::GetInstrumentsDb()->GetDirectories(Dir, Recursive);
2354    
2355            for (int i = 0; i < dirs->size(); i++) {
2356                if (list != "") list += ",";
2357                list += "'" + InstrumentsDb::toEscapedPath(dirs->at(i)) + "'";
2358            }
2359    
2360            result.Add(list);
2361        } catch (Exception e) {
2362             result.Error(e);
2363        }
2364    #else
2365        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2366    #endif
2367        return result.Produce();
2368    }
2369    
2370    String LSCPServer::GetDbInstrumentDirectoryInfo(String Dir) {
2371        dmsg(2,("LSCPServer: GetDbInstrumentDirectoryInfo(Dir=%s)\n", Dir.c_str()));
2372        LSCPResultSet result;
2373    #if HAVE_SQLITE3
2374        try {
2375            DbDirectory info = InstrumentsDb::GetInstrumentsDb()->GetDirectoryInfo(Dir);
2376    
2377            result.Add("DESCRIPTION", InstrumentsDb::toEscapedText(info.Description));
2378            result.Add("CREATED", info.Created);
2379            result.Add("MODIFIED", info.Modified);
2380        } catch (Exception e) {
2381             result.Error(e);
2382      }      }
2383      if ( rc != SQLITE_OK )  #else
2384      {      result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2385              result.Error(String(zErrMsg), rc);  #endif
2386        return result.Produce();
2387    }
2388    
2389    String LSCPServer::SetDbInstrumentDirectoryName(String Dir, String Name) {
2390        dmsg(2,("LSCPServer: SetDbInstrumentDirectoryName(Dir=%s,Name=%s)\n", Dir.c_str(), Name.c_str()));
2391        LSCPResultSet result;
2392    #if HAVE_SQLITE3
2393        try {
2394            InstrumentsDb::GetInstrumentsDb()->RenameDirectory(Dir, Name);
2395        } catch (Exception e) {
2396             result.Error(e);
2397      }      }
     sqlite3_close(db);  
2398  #else  #else
2399      result.Error(String("SQLITE3 was not installed when linuxsampler was built. SELECT statement is not available."), 0);      result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2400  #endif  #endif
2401      return result.Produce();      return result.Produce();
2402  }  }
2403    
2404    String LSCPServer::MoveDbInstrumentDirectory(String Dir, String Dst) {
2405        dmsg(2,("LSCPServer: MoveDbInstrumentDirectory(Dir=%s,Dst=%s)\n", Dir.c_str(), Dst.c_str()));
2406        LSCPResultSet result;
2407    #if HAVE_SQLITE3
2408        try {
2409            InstrumentsDb::GetInstrumentsDb()->MoveDirectory(Dir, Dst);
2410        } catch (Exception e) {
2411             result.Error(e);
2412        }
2413    #else
2414        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2415    #endif
2416        return result.Produce();
2417    }
2418    
2419    String LSCPServer::CopyDbInstrumentDirectory(String Dir, String Dst) {
2420        dmsg(2,("LSCPServer: CopyDbInstrumentDirectory(Dir=%s,Dst=%s)\n", Dir.c_str(), Dst.c_str()));
2421        LSCPResultSet result;
2422    #if HAVE_SQLITE3
2423        try {
2424            InstrumentsDb::GetInstrumentsDb()->CopyDirectory(Dir, Dst);
2425        } catch (Exception e) {
2426             result.Error(e);
2427        }
2428    #else
2429        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2430    #endif
2431        return result.Produce();
2432    }
2433    
2434    String LSCPServer::SetDbInstrumentDirectoryDescription(String Dir, String Desc) {
2435        dmsg(2,("LSCPServer: SetDbInstrumentDirectoryDescription(Dir=%s,Desc=%s)\n", Dir.c_str(), Desc.c_str()));
2436        LSCPResultSet result;
2437    #if HAVE_SQLITE3
2438        try {
2439            InstrumentsDb::GetInstrumentsDb()->SetDirectoryDescription(Dir, Desc);
2440        } catch (Exception e) {
2441             result.Error(e);
2442        }
2443    #else
2444        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2445    #endif
2446        return result.Produce();
2447    }
2448    
2449    String LSCPServer::AddDbInstruments(String DbDir, String FilePath, int Index, bool bBackground) {
2450        dmsg(2,("LSCPServer: AddDbInstruments(DbDir=%s,FilePath=%s,Index=%d,bBackground=%d)\n", DbDir.c_str(), FilePath.c_str(), Index, bBackground));
2451        LSCPResultSet result;
2452    #if HAVE_SQLITE3
2453        try {
2454            int id;
2455            InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
2456            id = db->AddInstruments(DbDir, FilePath, Index, bBackground);
2457            if (bBackground) result = id;
2458        } catch (Exception e) {
2459             result.Error(e);
2460        }
2461    #else
2462        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2463    #endif
2464        return result.Produce();
2465    }
2466    
2467    String LSCPServer::AddDbInstruments(String ScanMode, String DbDir, String FsDir, bool bBackground) {
2468        dmsg(2,("LSCPServer: AddDbInstruments(ScanMode=%s,DbDir=%s,FsDir=%s,bBackground=%d)\n", ScanMode.c_str(), DbDir.c_str(), FsDir.c_str(), bBackground));
2469        LSCPResultSet result;
2470    #if HAVE_SQLITE3
2471        try {
2472            int id;
2473            InstrumentsDb* db = InstrumentsDb::GetInstrumentsDb();
2474            if (ScanMode.compare("RECURSIVE") == 0) {
2475               id = db->AddInstruments(RECURSIVE, DbDir, FsDir, bBackground);
2476            } else if (ScanMode.compare("NON_RECURSIVE") == 0) {
2477               id = db->AddInstruments(NON_RECURSIVE, DbDir, FsDir, bBackground);
2478            } else if (ScanMode.compare("FLAT") == 0) {
2479               id = db->AddInstruments(FLAT, DbDir, FsDir, bBackground);
2480            } else {
2481                throw Exception("Unknown scan mode: " + ScanMode);
2482            }
2483    
2484            if (bBackground) result = id;
2485        } catch (Exception e) {
2486             result.Error(e);
2487        }
2488    #else
2489        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2490    #endif
2491        return result.Produce();
2492    }
2493    
2494    String LSCPServer::RemoveDbInstrument(String Instr) {
2495        dmsg(2,("LSCPServer: RemoveDbInstrument(Instr=%s)\n", Instr.c_str()));
2496        LSCPResultSet result;
2497    #if HAVE_SQLITE3
2498        try {
2499            InstrumentsDb::GetInstrumentsDb()->RemoveInstrument(Instr);
2500        } catch (Exception e) {
2501             result.Error(e);
2502        }
2503    #else
2504        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2505    #endif
2506        return result.Produce();
2507    }
2508    
2509    String LSCPServer::GetDbInstrumentCount(String Dir, bool Recursive) {
2510        dmsg(2,("LSCPServer: GetDbInstrumentCount(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
2511        LSCPResultSet result;
2512    #if HAVE_SQLITE3
2513        try {
2514            result.Add(InstrumentsDb::GetInstrumentsDb()->GetInstrumentCount(Dir, Recursive));
2515        } catch (Exception e) {
2516             result.Error(e);
2517        }
2518    #else
2519        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2520    #endif
2521        return result.Produce();
2522    }
2523    
2524    String LSCPServer::GetDbInstruments(String Dir, bool Recursive) {
2525        dmsg(2,("LSCPServer: GetDbInstruments(Dir=%s,Recursive=%d)\n", Dir.c_str(), Recursive));
2526        LSCPResultSet result;
2527    #if HAVE_SQLITE3
2528        try {
2529            String list;
2530            StringListPtr instrs = InstrumentsDb::GetInstrumentsDb()->GetInstruments(Dir, Recursive);
2531    
2532            for (int i = 0; i < instrs->size(); i++) {
2533                if (list != "") list += ",";
2534                list += "'" + InstrumentsDb::toEscapedPath(instrs->at(i)) + "'";
2535            }
2536    
2537            result.Add(list);
2538        } catch (Exception e) {
2539             result.Error(e);
2540        }
2541    #else
2542        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2543    #endif
2544        return result.Produce();
2545    }
2546    
2547    String LSCPServer::GetDbInstrumentInfo(String Instr) {
2548        dmsg(2,("LSCPServer: GetDbInstrumentInfo(Instr=%s)\n", Instr.c_str()));
2549        LSCPResultSet result;
2550    #if HAVE_SQLITE3
2551        try {
2552            DbInstrument info = InstrumentsDb::GetInstrumentsDb()->GetInstrumentInfo(Instr);
2553    
2554            result.Add("INSTRUMENT_FILE", info.InstrFile);
2555            result.Add("INSTRUMENT_NR", info.InstrNr);
2556            result.Add("FORMAT_FAMILY", info.FormatFamily);
2557            result.Add("FORMAT_VERSION", info.FormatVersion);
2558            result.Add("SIZE", (int)info.Size);
2559            result.Add("CREATED", info.Created);
2560            result.Add("MODIFIED", info.Modified);
2561            result.Add("DESCRIPTION", InstrumentsDb::toEscapedText(info.Description));
2562            result.Add("IS_DRUM", info.IsDrum);
2563            result.Add("PRODUCT", InstrumentsDb::toEscapedText(info.Product));
2564            result.Add("ARTISTS", InstrumentsDb::toEscapedText(info.Artists));
2565            result.Add("KEYWORDS", InstrumentsDb::toEscapedText(info.Keywords));
2566        } catch (Exception e) {
2567             result.Error(e);
2568        }
2569    #else
2570        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2571    #endif
2572        return result.Produce();
2573    }
2574    
2575    String LSCPServer::GetDbInstrumentsJobInfo(int JobId) {
2576        dmsg(2,("LSCPServer: GetDbInstrumentsJobInfo(JobId=%d)\n", JobId));
2577        LSCPResultSet result;
2578    #if HAVE_SQLITE3
2579        try {
2580            ScanJob job = InstrumentsDb::GetInstrumentsDb()->Jobs.GetJobById(JobId);
2581    
2582            result.Add("FILES_TOTAL", job.FilesTotal);
2583            result.Add("FILES_SCANNED", job.FilesScanned);
2584            result.Add("SCANNING", job.Scanning);
2585            result.Add("STATUS", job.Status);
2586        } catch (Exception e) {
2587             result.Error(e);
2588        }
2589    #else
2590        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2591    #endif
2592        return result.Produce();
2593    }
2594    
2595    String LSCPServer::SetDbInstrumentName(String Instr, String Name) {
2596        dmsg(2,("LSCPServer: SetDbInstrumentName(Instr=%s,Name=%s)\n", Instr.c_str(), Name.c_str()));
2597        LSCPResultSet result;
2598    #if HAVE_SQLITE3
2599        try {
2600            InstrumentsDb::GetInstrumentsDb()->RenameInstrument(Instr, Name);
2601        } catch (Exception e) {
2602             result.Error(e);
2603        }
2604    #else
2605        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2606    #endif
2607        return result.Produce();
2608    }
2609    
2610    String LSCPServer::MoveDbInstrument(String Instr, String Dst) {
2611        dmsg(2,("LSCPServer: MoveDbInstrument(Instr=%s,Dst=%s)\n", Instr.c_str(), Dst.c_str()));
2612        LSCPResultSet result;
2613    #if HAVE_SQLITE3
2614        try {
2615            InstrumentsDb::GetInstrumentsDb()->MoveInstrument(Instr, Dst);
2616        } catch (Exception e) {
2617             result.Error(e);
2618        }
2619    #else
2620        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2621    #endif
2622        return result.Produce();
2623    }
2624    
2625    String LSCPServer::CopyDbInstrument(String Instr, String Dst) {
2626        dmsg(2,("LSCPServer: CopyDbInstrument(Instr=%s,Dst=%s)\n", Instr.c_str(), Dst.c_str()));
2627        LSCPResultSet result;
2628    #if HAVE_SQLITE3
2629        try {
2630            InstrumentsDb::GetInstrumentsDb()->CopyInstrument(Instr, Dst);
2631        } catch (Exception e) {
2632             result.Error(e);
2633        }
2634    #else
2635        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2636    #endif
2637        return result.Produce();
2638    }
2639    
2640    String LSCPServer::SetDbInstrumentDescription(String Instr, String Desc) {
2641        dmsg(2,("LSCPServer: SetDbInstrumentDescription(Instr=%s,Desc=%s)\n", Instr.c_str(), Desc.c_str()));
2642        LSCPResultSet result;
2643    #if HAVE_SQLITE3
2644        try {
2645            InstrumentsDb::GetInstrumentsDb()->SetInstrumentDescription(Instr, Desc);
2646        } catch (Exception e) {
2647             result.Error(e);
2648        }
2649    #else
2650        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2651    #endif
2652        return result.Produce();
2653    }
2654    
2655    String LSCPServer::FindDbInstrumentDirectories(String Dir, std::map<String,String> Parameters, bool Recursive) {
2656        dmsg(2,("LSCPServer: FindDbInstrumentDirectories(Dir=%s)\n", Dir.c_str()));
2657        LSCPResultSet result;
2658    #if HAVE_SQLITE3
2659        try {
2660            SearchQuery Query;
2661            std::map<String,String>::iterator iter;
2662            for (iter = Parameters.begin(); iter != Parameters.end(); iter++) {
2663                if (iter->first.compare("NAME") == 0) {
2664                    Query.Name = iter->second;
2665                } else if (iter->first.compare("CREATED") == 0) {
2666                    Query.SetCreated(iter->second);
2667                } else if (iter->first.compare("MODIFIED") == 0) {
2668                    Query.SetModified(iter->second);
2669                } else if (iter->first.compare("DESCRIPTION") == 0) {
2670                    Query.Description = iter->second;
2671                } else {
2672                    throw Exception("Unknown search criteria: " + iter->first);
2673                }
2674            }
2675    
2676            String list;
2677            StringListPtr pDirectories =
2678                InstrumentsDb::GetInstrumentsDb()->FindDirectories(Dir, &Query, Recursive);
2679    
2680            for (int i = 0; i < pDirectories->size(); i++) {
2681                if (list != "") list += ",";
2682                list += "'" + InstrumentsDb::toEscapedPath(pDirectories->at(i)) + "'";
2683            }
2684    
2685            result.Add(list);
2686        } catch (Exception e) {
2687             result.Error(e);
2688        }
2689    #else
2690        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2691    #endif
2692        return result.Produce();
2693    }
2694    
2695    String LSCPServer::FindDbInstruments(String Dir, std::map<String,String> Parameters, bool Recursive) {
2696        dmsg(2,("LSCPServer: FindDbInstruments(Dir=%s)\n", Dir.c_str()));
2697        LSCPResultSet result;
2698    #if HAVE_SQLITE3
2699        try {
2700            SearchQuery Query;
2701            std::map<String,String>::iterator iter;
2702            for (iter = Parameters.begin(); iter != Parameters.end(); iter++) {
2703                if (iter->first.compare("NAME") == 0) {
2704                    Query.Name = iter->second;
2705                } else if (iter->first.compare("FORMAT_FAMILIES") == 0) {
2706                    Query.SetFormatFamilies(iter->second);
2707                } else if (iter->first.compare("SIZE") == 0) {
2708                    Query.SetSize(iter->second);
2709                } else if (iter->first.compare("CREATED") == 0) {
2710                    Query.SetCreated(iter->second);
2711                } else if (iter->first.compare("MODIFIED") == 0) {
2712                    Query.SetModified(iter->second);
2713                } else if (iter->first.compare("DESCRIPTION") == 0) {
2714                    Query.Description = iter->second;
2715                } else if (iter->first.compare("IS_DRUM") == 0) {
2716                    if (!strcasecmp(iter->second.c_str(), "true")) {
2717                        Query.InstrType = SearchQuery::DRUM;
2718                    } else {
2719                        Query.InstrType = SearchQuery::CHROMATIC;
2720                    }
2721                } else if (iter->first.compare("PRODUCT") == 0) {
2722                     Query.Product = iter->second;
2723                } else if (iter->first.compare("ARTISTS") == 0) {
2724                     Query.Artists = iter->second;
2725                } else if (iter->first.compare("KEYWORDS") == 0) {
2726                     Query.Keywords = iter->second;
2727                } else {
2728                    throw Exception("Unknown search criteria: " + iter->first);
2729                }
2730            }
2731    
2732            String list;
2733            StringListPtr pInstruments =
2734                InstrumentsDb::GetInstrumentsDb()->FindInstruments(Dir, &Query, Recursive);
2735    
2736            for (int i = 0; i < pInstruments->size(); i++) {
2737                if (list != "") list += ",";
2738                list += "'" + InstrumentsDb::toEscapedPath(pInstruments->at(i)) + "'";
2739            }
2740    
2741            result.Add(list);
2742        } catch (Exception e) {
2743             result.Error(e);
2744        }
2745    #else
2746        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2747    #endif
2748        return result.Produce();
2749    }
2750    
2751    String LSCPServer::FormatInstrumentsDb() {
2752        dmsg(2,("LSCPServer: FormatInstrumentsDb()\n"));
2753        LSCPResultSet result;
2754    #if HAVE_SQLITE3
2755        try {
2756            InstrumentsDb::GetInstrumentsDb()->Format();
2757        } catch (Exception e) {
2758             result.Error(e);
2759        }
2760    #else
2761        result.Error(String(DOESNT_HAVE_SQLITE3), 0);
2762    #endif
2763        return result.Produce();
2764    }
2765    
2766    
2767  /**  /**
2768   * Will be called by the parser to enable or disable echo mode; if echo   * Will be called by the parser to enable or disable echo mode; if echo
2769   * mode is enabled, all commands from the client will (immediately) be   * mode is enabled, all commands from the client will (immediately) be
Legend:
Removed from v.1005  
changed lines
  Added in v.1353
  ViewVC Help
Powered by ViewVC