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

Contents of /linuxsampler/trunk/src/network/lscpserver.h

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2500 - (show annotations) (download) (as text)
Fri Jan 10 12:20:05 2014 UTC (10 years, 3 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 23763 byte(s) 
* Added support for multiple MIDI input ports per sampler channel (added
  various new C++ API methods for this new feature/design, old C++ API
  methods are now marked as deprecated but should still provide full
  behavior backward compatibility).
* LSCP Network interface: Added the following new LSCP commands for the new
  feature mentioned above: "ADD CHANNEL MIDI_INPUT",
  "REMOVE CHANNEL MIDI_INPUT" and "LIST CHANNEL MIDI_INPUTS". As with the
  C++ API changes, the old LSCP commands for MIDI input management are now
  marked as deprecated, but are still there and should provide full behavior
  backward compatibility.
* New LSCP specification document (LSCP v1.6).
* AbstractEngine::GSCheckSum(): don't allocate memory on the stack (was
  unsafe and caused compilation error with old clang 2.x).
* Bumped version (1.0.0.svn25).
1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2014 Christian Schoenebeck *
7 * *
8 * 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 *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This library is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this library; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #ifndef __LSCPSERVER_H_
25 #define __LSCPSERVER_H_
26
27 #if defined(WIN32)
28 #include <windows.h>
29 typedef int socklen_t;
30 #else
31 #include <unistd.h>
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <sys/select.h>
35 #include <sys/time.h>
36 #include <netinet/in.h>
37 #include <netinet/tcp.h>
38 #include <arpa/inet.h>
39 #include <netdb.h>
40 #endif
41
42 #include <list>
43
44 #include "lscp.h"
45 #include "lscpparser.h"
46 #include "lscpevent.h"
47 #include "../Sampler.h"
48 #include "../common/Thread.h"
49 #include "../common/Mutex.h"
50 #include "../common/Condition.h"
51 #include "../common/global_private.h"
52
53 #include "../drivers/midi/MidiInstrumentMapper.h"
54 #include "../drivers/midi/VirtualMidiDevice.h"
55
56 #if HAVE_SQLITE3
57 #include "../db/InstrumentsDb.h"
58 #endif
59
60 /// TCP Port on which the server should listen for connection requests.
61 #define LSCP_ADDR INADDR_ANY
62 #define LSCP_PORT 8888
63
64 /// try up to 3 minutes to bind server socket
65 #define LSCP_SERVER_BIND_TIMEOUT 180
66
67 // External references to the main scanner and parser functions
68 extern int yyparse(void* YYPARSE_PARAM);
69
70 namespace LinuxSampler {
71
72 extern void restart(yyparse_param_t* pparam, int& yychar);
73
74 /**
75 * Network server for the LinuxSampler Control Protocol (LSCP).
76 */
77 class LSCPServer : public Thread {
78 public:
79 LSCPServer(Sampler* pSampler, long int addr, short int port);
80 virtual ~LSCPServer();
81 int WaitUntilInitialized(long TimeoutSeconds = 0L, long TimeoutNanoSeconds = 0L);
82 void RemoveListeners();
83
84 // Methods called by the parser
85 String DestroyAudioOutputDevice(uint DeviceIndex);
86 String DestroyMidiInputDevice(uint DeviceIndex);
87 String LoadInstrument(String Filename, uint uiInstrument, uint uiSamplerChannel, bool bBackground = false);
88 String SetEngineType(String EngineName, uint uiSamplerChannel);
89 String GetChannels();
90 String ListChannels();
91 String AddChannel();
92 String RemoveChannel(uint uiSamplerChannel);
93 String GetAvailableEngines();
94 String ListAvailableEngines();
95 String GetEngineInfo(String EngineName);
96 String GetChannelInfo(uint uiSamplerChannel);
97 String GetVoiceCount(uint uiSamplerChannel);
98 String GetStreamCount(uint uiSamplerChannel);
99 String GetBufferFill(fill_response_t ResponseType, uint uiSamplerChannel);
100 String GetAvailableAudioOutputDrivers();
101 String ListAvailableAudioOutputDrivers();
102 String GetAvailableMidiInputDrivers();
103 String ListAvailableMidiInputDrivers();
104 String GetAudioOutputDriverInfo(String Driver);
105 String GetMidiInputDriverInfo(String Driver);
106 #ifdef __GNUC__
107 typedef std::map<String,String> StringMap; // nasty workaround for a GCC bug (see GCC bug #15980, #57)
108 String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
109 String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
110 String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = StringMap());
111 String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = StringMap());
112 #else
113 String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
114 String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
115 String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
116 String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
117 #endif // __GNUC__
118 String GetAudioOutputDeviceCount();
119 String GetMidiInputDeviceCount();
120 String GetAudioOutputDevices();
121 String GetMidiInputDevices();
122 String GetAudioOutputDeviceInfo(uint DeviceIndex);
123 String GetMidiInputDeviceInfo(uint DeviceIndex);
124 String GetMidiInputPortInfo(uint DeviceIndex, uint PortIndex);
125 String GetMidiInputPortParameterInfo(uint DeviceId, uint PortId, String ParameterName);
126 String GetAudioOutputChannelInfo(uint DeviceId, uint ChannelId);
127 String GetAudioOutputChannelParameterInfo(uint DeviceId, uint ChannelId, String ParameterName);
128 String SetAudioOutputChannelParameter(uint DeviceId, uint ChannelId, String ParamKey, String ParamVal);
129 String SetAudioOutputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
130 String SetMidiInputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
131 String SetMidiInputPortParameter(uint DeviceIndex, uint PortIndex, String ParamKey, String ParamVal);
132 String SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel);
133 String SetAudioOutputDevice(uint AudioDeviceId, uint SamplerChannel);
134 String SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel);
135 String AddChannelMidiInput(uint uiSamplerChannel, uint MIDIDeviceId, uint MIDIPort = 0);
136 String RemoveChannelMidiInput(uint uiSamplerChannel);
137 String RemoveChannelMidiInput(uint uiSamplerChannel, uint MIDIDeviceId);
138 String RemoveChannelMidiInput(uint uiSamplerChannel, uint MIDIDeviceId, uint MIDIPort);
139 String ListChannelMidiInputs(uint uiSamplerChannel);
140 String SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel);
141 String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);
142 String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);
143 String SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel);
144 String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);
145 String SetVolume(double dVolume, uint uiSamplerChannel);
146 String SetChannelMute(bool bMute, uint uiSamplerChannel);
147 String SetChannelSolo(bool bSolo, uint uiSamplerChannel);
148 String AddOrReplaceMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg, String EngineType, String InstrumentFile, uint InstrumentIndex, float Volume, MidiInstrumentMapper::mode_t LoadMode, String Name, bool bModal);
149 String RemoveMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
150 String GetMidiInstrumentMappings(uint MidiMapID);
151 String GetAllMidiInstrumentMappings();
152 String GetMidiInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
153 String ListMidiInstrumentMappings(uint MidiMapID);
154 String ListAllMidiInstrumentMappings();
155 String ClearMidiInstrumentMappings(uint MidiMapID);
156 String ClearAllMidiInstrumentMappings();
157 String AddMidiInstrumentMap(String MapName = "");
158 String RemoveMidiInstrumentMap(uint MidiMapID);
159 String RemoveAllMidiInstrumentMaps();
160 String GetMidiInstrumentMaps();
161 String ListMidiInstrumentMaps();
162 String GetMidiInstrumentMap(uint MidiMapID);
163 String SetMidiInstrumentMapName(uint MidiMapID, String NewName);
164 String SetChannelMap(uint uiSamplerChannel, int MidiMapID);
165 String CreateFxSend(uint uiSamplerChannel, uint MidiCtrl, String Name = "");
166 String DestroyFxSend(uint uiSamplerChannel, uint FxSendID);
167 String GetFxSends(uint uiSamplerChannel);
168 String ListFxSends(uint uiSamplerChannel);
169 String GetFxSendInfo(uint uiSamplerChannel, uint FxSendID);
170 String SetFxSendName(uint uiSamplerChannel, uint FxSendID, String Name);
171 String SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel);
172 String SetFxSendMidiController(uint uiSamplerChannel, uint FxSendID, uint MidiController);
173 String SetFxSendLevel(uint uiSamplerChannel, uint FxSendID, double dLevel);
174 String SetFxSendEffect(uint uiSamplerChannel, uint FxSendID, int iSendEffectChain, int iEffectChainPosition);
175
176 // effect commands
177 String GetAvailableEffects();
178 String ListAvailableEffects();
179 String GetEffectInfo(int iEffectIndex);
180 String CreateEffectInstance(int iEffectIndex);
181 String CreateEffectInstance(String effectSystem, String module, String effectName);
182 String DestroyEffectInstance(int iEffectInstance);
183 String GetEffectInstances();
184 String ListEffectInstances();
185 String GetEffectInstanceInfo(int iEffectInstance);
186 String GetEffectInstanceInputControlInfo(int iEffectInstance, int iInputControlIndex);
187 String SetEffectInstanceInputControlValue(int iEffectInstance, int iInputControlIndex, double dValue);
188 String GetSendEffectChains(int iAudioOutputDevice);
189 String ListSendEffectChains(int iAudioOutputDevice);
190 String AddSendEffectChain(int iAudioOutputDevice);
191 String RemoveSendEffectChain(int iAudioOutputDevice, int iSendEffectChain);
192 String GetSendEffectChainInfo(int iAudioOutputDevice, int iSendEffectChain);
193 String AppendSendEffectChainEffect(int iAudioOutputDevice, int iSendEffectChain, int iEffectInstance);
194 String InsertSendEffectChainEffect(int iAudioOutputDevice, int iSendEffectChain, int iEffectChainPosition, int iEffectInstance);
195 String RemoveSendEffectChainEffect(int iAudioOutputDevice, int iSendEffectChain, int iEffectChainPosition);
196
197 String AddDbInstrumentDirectory(String Dir);
198 String RemoveDbInstrumentDirectory(String Dir, bool Force = false);
199 String GetDbInstrumentDirectoryCount(String Dir, bool Recursive = false);
200 String GetDbInstrumentDirectories(String Dir, bool Recursive = false);
201 String GetDbInstrumentDirectoryInfo(String Dir);
202 String SetDbInstrumentDirectoryName(String Dir, String Name);
203 String MoveDbInstrumentDirectory(String Dir, String Dst);
204 String CopyDbInstrumentDirectory(String Dir, String Dst);
205 String SetDbInstrumentDirectoryDescription(String Dir, String Desc);
206 String FindDbInstrumentDirectories(String Dir, std::map<String,String> Parameters, bool Recursive = true);
207 String AddDbInstruments(String DbDir, String FilePath, int Index = -1, bool bBackground = false);
208 String AddDbInstruments(String ScanMode, String DbDir, String FsDir, bool bBackground = false, bool insDir = false);
209 String RemoveDbInstrument(String Instr);
210 String GetDbInstrumentCount(String Dir, bool Recursive = false);
211 String GetDbInstruments(String Dir, bool Recursive = false);
212 String GetDbInstrumentInfo(String Instr);
213 String SetDbInstrumentName(String Instr, String Name);
214 String MoveDbInstrument(String Instr, String Dst);
215 String CopyDbInstrument(String Instr, String Dst);
216 String SetDbInstrumentDescription(String Instr, String Desc);
217 String SetDbInstrumentFilePath(String OldPath, String NewPath);
218 String FindLostDbInstrumentFiles();
219 String FindDbInstruments(String Dir, std::map<String,String> Parameters, bool Recursive = true);
220 String FormatInstrumentsDb();
221 String EditSamplerChannelInstrument(uint uiSamplerChannel);
222 String GetDbInstrumentsJobInfo(int JobId);
223 String ResetChannel(uint uiSamplerChannel);
224 String ResetSampler();
225 String GetServerInfo();
226 String GetTotalStreamCount();
227 String GetTotalVoiceCount();
228 String GetTotalVoiceCountMax();
229 String GetGlobalMaxVoices();
230 String SetGlobalMaxVoices(int iVoices);
231 String GetGlobalMaxStreams();
232 String SetGlobalMaxStreams(int iStreams);
233 String GetGlobalVolume();
234 String SetGlobalVolume(double dVolume);
235 String GetFileInstruments(String Filename);
236 String ListFileInstruments(String Filename);
237 String GetFileInstrumentInfo(String Filename, uint InstrumentID);
238 String SendChannelMidiData(String MidiMsg, uint uiSamplerChannel, uint Arg1, uint Arg2);
239 String SubscribeNotification(LSCPEvent::event_t);
240 String UnsubscribeNotification(LSCPEvent::event_t);
241 String SetEcho(yyparse_param_t* pSession, double boolean_value);
242 void AnswerClient(String ReturnMessage);
243 void CloseAllConnections();
244
245 static int currentSocket;
246 static std::map<int,String> bufferedCommands;
247
248 static void SendLSCPNotify( LSCPEvent Event );
249 static int EventSubscribers( std::list<LSCPEvent::event_t> events );
250 static String FilterEndlines(String s);
251
252 //Protect main thread that generates real time notify messages
253 //like voice count, stream count and buffer fill
254 //from LSCP server removing engines and channels from underneath
255 static Mutex RTNotifyMutex;
256
257 protected:
258 int hSocket;
259 sockaddr_in SocketAddress;
260 Sampler* pSampler;
261 Condition Initialized;
262
263 int Main(); ///< Implementation of virtual method from class Thread
264
265 private:
266
267 /**
268 * Find a created audio output device index.
269 */
270 int GetAudioOutputDeviceIndex (AudioOutputDevice *pDevice);
271
272 /**
273 * Find a created midi input device index.
274 */
275 int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
276
277 EngineChannel* GetEngineChannel(uint uiSamplerChannel);
278
279 /**
280 * Gets the specified effect send on the specified sampler channel.
281 */
282 FxSend* GetFxSend(uint uiSamplerChannel, uint FxSendID);
283
284 bool HasSoloChannel();
285 void MuteNonSoloChannels();
286 void UnmuteChannels();
287
288 /**
289 * Throws an exception if the specified file is not found or
290 * if directory is specified.
291 */
292 static void VerifyFile(String Filename);
293
294 static std::map<int,String> bufferedNotifies;
295 static Mutex NotifyMutex;
296 static Mutex NotifyBufferMutex;
297 static bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
298 static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
299 static std::vector<yyparse_param_t> Sessions;
300 static Mutex SubscriptionMutex;
301 static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
302 static fd_set fdSet;
303
304 class EventHandler : public ChannelCountListener, public AudioDeviceCountListener,
305 public MidiDeviceCountListener, public MidiInstrumentCountListener,
306 public MidiInstrumentInfoListener, public MidiInstrumentMapCountListener,
307 public MidiInstrumentMapInfoListener, public FxSendCountListener,
308 public VoiceCountListener, public StreamCountListener, public BufferFillListener,
309 public TotalStreamCountListener, public TotalVoiceCountListener,
310 public EngineChangeListener, public MidiPortCountListener {
311
312 public:
313 EventHandler(LSCPServer* pParent);
314
315 /**
316 * Invoked when the number of sampler channels has changed.
317 * @param NewCount The new number of sampler channels.
318 */
319 virtual void ChannelCountChanged(int NewCount);
320 virtual void ChannelAdded(SamplerChannel* pChannel);
321 virtual void ChannelToBeRemoved(SamplerChannel* pChannel);
322
323 /**
324 * Invoked when the number of audio output devices has changed.
325 * @param NewCount The new number of audio output devices.
326 */
327 virtual void AudioDeviceCountChanged(int NewCount);
328
329 /**
330 * Invoked when the number of MIDI input devices has changed.
331 * @param NewCount The new number of MIDI input devices.
332 */
333 virtual void MidiDeviceCountChanged(int NewCount);
334
335 /**
336 * Invoked right before the supplied MIDI input device is going
337 * to be destroyed.
338 * @param pDevice MidiInputDevice to be deleted
339 */
340 virtual void MidiDeviceToBeDestroyed(MidiInputDevice* pDevice);
341
342 /**
343 * Invoked to inform that a new MidiInputDevice has just been
344 * created.
345 * @param pDevice newly created MidiInputDevice
346 */
347 virtual void MidiDeviceCreated(MidiInputDevice* pDevice);
348
349 /**
350 * Invoked when the number of MIDI input ports has changed.
351 * @param NewCount The new number of MIDI input ports.
352 */
353 virtual void MidiPortCountChanged(int NewCount);
354
355 /**
356 * Invoked right before the supplied MIDI input port is going
357 * to be destroyed.
358 * @param pPort MidiInputPort to be deleted
359 */
360 virtual void MidiPortToBeRemoved(MidiInputPort* pPort);
361
362 /**
363 * Invoked to inform that a new MidiInputPort has just been
364 * added.
365 * @param pPort newly created MidiInputPort
366 */
367 virtual void MidiPortAdded(MidiInputPort* pPort);
368
369 /**
370 * Invoked when the number of MIDI instruments has changed.
371 * @param MapId The numerical ID of the MIDI instrument map.
372 * @param NewCount The new number of MIDI instruments.
373 */
374 virtual void MidiInstrumentCountChanged(int MapId, int NewCount);
375
376 /**
377 * Invoked when a MIDI instrument in a MIDI instrument map is changed.
378 * @param MapId The numerical ID of the MIDI instrument map.
379 * @param Bank The index of the MIDI bank, containing the instrument.
380 * @param Program The MIDI program number of the instrument.
381 */
382 virtual void MidiInstrumentInfoChanged(int MapId, int Bank, int Program);
383
384 /**
385 * Invoked when the number of MIDI instrument maps has changed.
386 * @param NewCount The new number of MIDI instruments.
387 */
388 virtual void MidiInstrumentMapCountChanged(int NewCount);
389
390 /**
391 * Invoked when the settings of a MIDI instrument map are changed.
392 * @param MapId The numerical ID of the MIDI instrument map.
393 */
394 virtual void MidiInstrumentMapInfoChanged(int MapId);
395
396 /**
397 * Invoked when the number of effect sends
398 * on the specified sampler channel has changed.
399 * @param ChannelId The numerical ID of the sampler channel.
400 * @param NewCount The new number of effect sends.
401 */
402 virtual void FxSendCountChanged(int ChannelId, int NewCount);
403
404 /**
405 * Invoked when the number of active voices
406 * on the specified sampler channel has changed.
407 * @param ChannelId The numerical ID of the sampler channel.
408 * @param NewCount The new number of active voices.
409 */
410 virtual void VoiceCountChanged(int ChannelId, int NewCount);
411
412 /**
413 * Invoked when the number of active disk streams
414 * on the specified sampler channel has changed.
415 * @param ChannelId The numerical ID of the sampler channel.
416 * @param NewCount The new number of active disk streams.
417 */
418 virtual void StreamCountChanged(int ChannelId, int NewCount);
419
420 /**
421 * Invoked when the fill state of the disk stream
422 * buffers on the specified sampler channel is changed.
423 * @param ChannelId The numerical ID of the sampler channel.
424 * @param FillData The buffer fill data for the specified sampler channel.
425 */
426 virtual void BufferFillChanged(int ChannelId, String FillData);
427
428 /**
429 * Invoked when the total number of active voices is changed.
430 * @param NewCount The new number of active voices.
431 */
432 virtual void TotalVoiceCountChanged(int NewCount);
433 virtual void TotalStreamCountChanged(int NewCount);
434
435 virtual void EngineToBeChanged(int ChannelId);
436 virtual void EngineChanged(int ChannelId);
437
438 virtual ~EventHandler();
439
440 struct midi_listener_entry {
441 SamplerChannel* pSamplerChannel;
442 EngineChannel* pEngineChannel;
443 VirtualMidiDevice* pMidiListener;
444 };
445
446 std::vector<midi_listener_entry> channelMidiListeners;
447
448 struct device_midi_listener_entry {
449 MidiInputPort* pPort;
450 VirtualMidiDevice* pMidiListener;
451 uint uiDeviceID;
452 };
453
454 std::vector<device_midi_listener_entry> deviceMidiListeners;
455
456 private:
457 LSCPServer* pParent;
458 } eventHandler;
459
460 #if HAVE_SQLITE3
461 class DbInstrumentsEventHandler : public InstrumentsDb::Listener {
462 public:
463 virtual void DirectoryCountChanged(String Dir);
464 virtual void DirectoryInfoChanged(String Dir);
465 virtual void DirectoryNameChanged(String Dir, String NewName);
466 virtual void InstrumentCountChanged(String Dir);
467 virtual void InstrumentInfoChanged(String Instr);
468 virtual void InstrumentNameChanged(String Instr, String NewName);
469 virtual void JobStatusChanged(int JobId);
470 } dbInstrumentsEventHandler;
471 #endif // HAVE_SQLITE3
472 };
473
474 }
475
476 #endif // __LSCPSERVER_H_
  ViewVC Help
Powered by ViewVC