/[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 1848 - (show annotations) (download) (as text)
Sat Feb 28 21:23:06 2009 UTC (10 years, 8 months ago) by iliev
File MIME type: text/x-c++hdr
File size: 21904 byte(s)
* close all connections when LSCPServer is deleted

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2008 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 SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel);
136 String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);
137 String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);
138 String SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel);
139 String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);
140 String SetVolume(double dVolume, uint uiSamplerChannel);
141 String SetChannelMute(bool bMute, uint uiSamplerChannel);
142 String SetChannelSolo(bool bSolo, uint uiSamplerChannel);
143 String AddOrReplaceMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg, String EngineType, String InstrumentFile, uint InstrumentIndex, float Volume, MidiInstrumentMapper::mode_t LoadMode, String Name, bool bModal);
144 String RemoveMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
145 String GetMidiInstrumentMappings(uint MidiMapID);
146 String GetAllMidiInstrumentMappings();
147 String GetMidiInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
148 String ListMidiInstrumentMappings(uint MidiMapID);
149 String ListAllMidiInstrumentMappings();
150 String ClearMidiInstrumentMappings(uint MidiMapID);
151 String ClearAllMidiInstrumentMappings();
152 String AddMidiInstrumentMap(String MapName = "");
153 String RemoveMidiInstrumentMap(uint MidiMapID);
154 String RemoveAllMidiInstrumentMaps();
155 String GetMidiInstrumentMaps();
156 String ListMidiInstrumentMaps();
157 String GetMidiInstrumentMap(uint MidiMapID);
158 String SetMidiInstrumentMapName(uint MidiMapID, String NewName);
159 String SetChannelMap(uint uiSamplerChannel, int MidiMapID);
160 String CreateFxSend(uint uiSamplerChannel, uint MidiCtrl, String Name = "");
161 String DestroyFxSend(uint uiSamplerChannel, uint FxSendID);
162 String GetFxSends(uint uiSamplerChannel);
163 String ListFxSends(uint uiSamplerChannel);
164 String GetFxSendInfo(uint uiSamplerChannel, uint FxSendID);
165 String SetFxSendName(uint uiSamplerChannel, uint FxSendID, String Name);
166 String SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel);
167 String SetFxSendMidiController(uint uiSamplerChannel, uint FxSendID, uint MidiController);
168 String SetFxSendLevel(uint uiSamplerChannel, uint FxSendID, double dLevel);
169 String AddDbInstrumentDirectory(String Dir);
170 String RemoveDbInstrumentDirectory(String Dir, bool Force = false);
171 String GetDbInstrumentDirectoryCount(String Dir, bool Recursive = false);
172 String GetDbInstrumentDirectories(String Dir, bool Recursive = false);
173 String GetDbInstrumentDirectoryInfo(String Dir);
174 String SetDbInstrumentDirectoryName(String Dir, String Name);
175 String MoveDbInstrumentDirectory(String Dir, String Dst);
176 String CopyDbInstrumentDirectory(String Dir, String Dst);
177 String SetDbInstrumentDirectoryDescription(String Dir, String Desc);
178 String FindDbInstrumentDirectories(String Dir, std::map<String,String> Parameters, bool Recursive = true);
179 String AddDbInstruments(String DbDir, String FilePath, int Index = -1, bool bBackground = false);
180 String AddDbInstruments(String ScanMode, String DbDir, String FsDir, bool bBackground = false, bool insDir = false);
181 String RemoveDbInstrument(String Instr);
182 String GetDbInstrumentCount(String Dir, bool Recursive = false);
183 String GetDbInstruments(String Dir, bool Recursive = false);
184 String GetDbInstrumentInfo(String Instr);
185 String SetDbInstrumentName(String Instr, String Name);
186 String MoveDbInstrument(String Instr, String Dst);
187 String CopyDbInstrument(String Instr, String Dst);
188 String SetDbInstrumentDescription(String Instr, String Desc);
189 String SetDbInstrumentFilePath(String OldPath, String NewPath);
190 String FindLostDbInstrumentFiles();
191 String FindDbInstruments(String Dir, std::map<String,String> Parameters, bool Recursive = true);
192 String FormatInstrumentsDb();
193 String EditSamplerChannelInstrument(uint uiSamplerChannel);
194 String GetDbInstrumentsJobInfo(int JobId);
195 String ResetChannel(uint uiSamplerChannel);
196 String ResetSampler();
197 String GetServerInfo();
198 String GetTotalStreamCount();
199 String GetTotalVoiceCount();
200 String GetTotalVoiceCountMax();
201 String GetGlobalMaxVoices();
202 String SetGlobalMaxVoices(int iVoices);
203 String GetGlobalMaxStreams();
204 String SetGlobalMaxStreams(int iStreams);
205 String GetGlobalVolume();
206 String SetGlobalVolume(double dVolume);
207 String GetFileInstruments(String Filename);
208 String ListFileInstruments(String Filename);
209 String GetFileInstrumentInfo(String Filename, uint InstrumentID);
210 String SendChannelMidiData(String MidiMsg, uint uiSamplerChannel, uint Arg1, uint Arg2);
211 String SubscribeNotification(LSCPEvent::event_t);
212 String UnsubscribeNotification(LSCPEvent::event_t);
213 String SetEcho(yyparse_param_t* pSession, double boolean_value);
214 void AnswerClient(String ReturnMessage);
215 void CloseAllConnections();
216
217 static int currentSocket;
218 static std::map<int,String> bufferedCommands;
219
220 static void SendLSCPNotify( LSCPEvent Event );
221 static int EventSubscribers( std::list<LSCPEvent::event_t> events );
222 static void LockRTNotify();
223 static void UnlockRTNotify();
224 static String FilterEndlines(String s);
225
226 protected:
227 int hSocket;
228 sockaddr_in SocketAddress;
229 Sampler* pSampler;
230 Condition Initialized;
231
232 int Main(); ///< Implementation of virtual method from class Thread
233
234 private:
235
236 /**
237 * Find a created audio output device index.
238 */
239 int GetAudioOutputDeviceIndex (AudioOutputDevice *pDevice);
240
241 /**
242 * Find a created midi input device index.
243 */
244 int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
245
246 EngineChannel* GetEngineChannel(uint uiSamplerChannel);
247
248 /**
249 * Gets the specified effect send on the specified sampler channel.
250 */
251 FxSend* GetFxSend(uint uiSamplerChannel, uint FxSendID);
252
253 bool HasSoloChannel();
254 void MuteNonSoloChannels();
255 void UnmuteChannels();
256
257 /**
258 * Throws an exception if the specified file is not found or
259 * if directory is specified.
260 */
261 static void VerifyFile(String Filename);
262
263 static std::map<int,String> bufferedNotifies;
264 static Mutex NotifyMutex;
265 static Mutex NotifyBufferMutex;
266 static bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
267 static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
268 static std::vector<yyparse_param_t> Sessions;
269 static Mutex SubscriptionMutex;
270 static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
271 static fd_set fdSet;
272
273 //Protect main thread that generates real time notify messages
274 //like voice count, stream count and buffer fill
275 //from LSCP server removing engines and channels from underneath
276 static Mutex RTNotifyMutex;
277
278 class EventHandler : public ChannelCountListener, public AudioDeviceCountListener,
279 public MidiDeviceCountListener, public MidiInstrumentCountListener,
280 public MidiInstrumentInfoListener, public MidiInstrumentMapCountListener,
281 public MidiInstrumentMapInfoListener, public FxSendCountListener,
282 public VoiceCountListener, public StreamCountListener, public BufferFillListener,
283 public TotalStreamCountListener, public TotalVoiceCountListener,
284 public EngineChangeListener, public MidiPortCountListener {
285
286 public:
287 EventHandler(LSCPServer* pParent);
288
289 /**
290 * Invoked when the number of sampler channels has changed.
291 * @param NewCount The new number of sampler channels.
292 */
293 virtual void ChannelCountChanged(int NewCount);
294 virtual void ChannelAdded(SamplerChannel* pChannel);
295 virtual void ChannelToBeRemoved(SamplerChannel* pChannel);
296
297 /**
298 * Invoked when the number of audio output devices has changed.
299 * @param NewCount The new number of audio output devices.
300 */
301 virtual void AudioDeviceCountChanged(int NewCount);
302
303 /**
304 * Invoked when the number of MIDI input devices has changed.
305 * @param NewCount The new number of MIDI input devices.
306 */
307 virtual void MidiDeviceCountChanged(int NewCount);
308
309 /**
310 * Invoked right before the supplied MIDI input device is going
311 * to be destroyed.
312 * @param pDevice MidiInputDevice to be deleted
313 */
314 virtual void MidiDeviceToBeDestroyed(MidiInputDevice* pDevice);
315
316 /**
317 * Invoked to inform that a new MidiInputDevice has just been
318 * created.
319 * @param pDevice newly created MidiInputDevice
320 */
321 virtual void MidiDeviceCreated(MidiInputDevice* pDevice);
322
323 /**
324 * Invoked when the number of MIDI input ports has changed.
325 * @param NewCount The new number of MIDI input ports.
326 */
327 virtual void MidiPortCountChanged(int NewCount);
328
329 /**
330 * Invoked right before the supplied MIDI input port is going
331 * to be destroyed.
332 * @param pPort MidiInputPort to be deleted
333 */
334 virtual void MidiPortToBeRemoved(MidiInputPort* pPort);
335
336 /**
337 * Invoked to inform that a new MidiInputPort has just been
338 * added.
339 * @param pPort newly created MidiInputPort
340 */
341 virtual void MidiPortAdded(MidiInputPort* pPort);
342
343 /**
344 * Invoked when the number of MIDI instruments has changed.
345 * @param MapId The numerical ID of the MIDI instrument map.
346 * @param NewCount The new number of MIDI instruments.
347 */
348 virtual void MidiInstrumentCountChanged(int MapId, int NewCount);
349
350 /**
351 * Invoked when a MIDI instrument in a MIDI instrument map is changed.
352 * @param MapId The numerical ID of the MIDI instrument map.
353 * @param Bank The index of the MIDI bank, containing the instrument.
354 * @param Program The MIDI program number of the instrument.
355 */
356 virtual void MidiInstrumentInfoChanged(int MapId, int Bank, int Program);
357
358 /**
359 * Invoked when the number of MIDI instrument maps has changed.
360 * @param NewCount The new number of MIDI instruments.
361 */
362 virtual void MidiInstrumentMapCountChanged(int NewCount);
363
364 /**
365 * Invoked when the settings of a MIDI instrument map are changed.
366 * @param MapId The numerical ID of the MIDI instrument map.
367 */
368 virtual void MidiInstrumentMapInfoChanged(int MapId);
369
370 /**
371 * Invoked when the number of effect sends
372 * on the specified sampler channel has changed.
373 * @param ChannelId The numerical ID of the sampler channel.
374 * @param NewCount The new number of effect sends.
375 */
376 virtual void FxSendCountChanged(int ChannelId, int NewCount);
377
378 /**
379 * Invoked when the number of active voices
380 * on the specified sampler channel has changed.
381 * @param ChannelId The numerical ID of the sampler channel.
382 * @param NewCount The new number of active voices.
383 */
384 virtual void VoiceCountChanged(int ChannelId, int NewCount);
385
386 /**
387 * Invoked when the number of active disk streams
388 * on the specified sampler channel has changed.
389 * @param ChannelId The numerical ID of the sampler channel.
390 * @param NewCount The new number of active disk streams.
391 */
392 virtual void StreamCountChanged(int ChannelId, int NewCount);
393
394 /**
395 * Invoked when the fill state of the disk stream
396 * buffers on the specified sampler channel is changed.
397 * @param ChannelId The numerical ID of the sampler channel.
398 * @param FillData The buffer fill data for the specified sampler channel.
399 */
400 virtual void BufferFillChanged(int ChannelId, String FillData);
401
402 /**
403 * Invoked when the total number of active voices is changed.
404 * @param NewCount The new number of active voices.
405 */
406 virtual void TotalVoiceCountChanged(int NewCount);
407 virtual void TotalStreamCountChanged(int NewCount);
408
409 virtual void EngineToBeChanged(int ChannelId);
410 virtual void EngineChanged(int ChannelId);
411
412 virtual ~EventHandler();
413
414 struct midi_listener_entry {
415 SamplerChannel* pSamplerChannel;
416 EngineChannel* pEngineChannel;
417 VirtualMidiDevice* pMidiListener;
418 };
419
420 std::vector<midi_listener_entry> channelMidiListeners;
421
422 struct device_midi_listener_entry {
423 MidiInputPort* pPort;
424 VirtualMidiDevice* pMidiListener;
425 uint uiDeviceID;
426 };
427
428 std::vector<device_midi_listener_entry> deviceMidiListeners;
429
430 private:
431 LSCPServer* pParent;
432 } eventHandler;
433
434 #if HAVE_SQLITE3
435 class DbInstrumentsEventHandler : public InstrumentsDb::Listener {
436 public:
437 virtual void DirectoryCountChanged(String Dir);
438 virtual void DirectoryInfoChanged(String Dir);
439 virtual void DirectoryNameChanged(String Dir, String NewName);
440 virtual void InstrumentCountChanged(String Dir);
441 virtual void InstrumentInfoChanged(String Instr);
442 virtual void InstrumentNameChanged(String Instr, String NewName);
443 virtual void JobStatusChanged(int JobId);
444 } dbInstrumentsEventHandler;
445 #endif // HAVE_SQLITE3
446 };
447
448 }
449
450 #endif // __LSCPSERVER_H_

  ViewVC Help
Powered by ViewVC