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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2515 - (hide annotations) (download) (as text)
Wed Feb 5 20:45:18 2014 UTC (10 years, 3 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 23838 byte(s) 
* WIP: Introducing the LSCP shell: for now, providing color
  highlighting while typing (indicating correct part bold white,
  incorrect part red, and turning green when the command is
  complete. The shell application is implemented as thin client,
  that is the parser work is performed on sampler side and the
  shell application is just providing output formatting.
* Bumped version (1.0.0.svn28).
1 schoenebeck 35 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 schoenebeck 56 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 2500 * Copyright (C) 2005 - 2014 Christian Schoenebeck *
7 schoenebeck 35 * *
8 schoenebeck 385 * This library is free software; you can redistribute it and/or modify *
9 schoenebeck 35 * 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 schoenebeck 385 * This library is distributed in the hope that it will be useful, *
14 schoenebeck 35 * 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 schoenebeck 385 * along with this library; if not, write to the Free Software *
20 schoenebeck 35 * 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 senoner 1481 #if defined(WIN32)
28     #include <windows.h>
29     typedef int socklen_t;
30     #else
31 schoenebeck 35 #include <unistd.h>
32     #include <sys/types.h>
33     #include <sys/socket.h>
34 senkov 170 #include <sys/select.h>
35     #include <sys/time.h>
36 schoenebeck 35 #include <netinet/in.h>
37     #include <netinet/tcp.h>
38     #include <arpa/inet.h>
39     #include <netdb.h>
40 senoner 1481 #endif
41 schoenebeck 35
42 senkov 170 #include <list>
43    
44 schoenebeck 53 #include "lscp.h"
45 schoenebeck 35 #include "lscpparser.h"
46 senkov 170 #include "lscpevent.h"
47 schoenebeck 53 #include "../Sampler.h"
48     #include "../common/Thread.h"
49 senkov 170 #include "../common/Mutex.h"
50 schoenebeck 211 #include "../common/Condition.h"
51 schoenebeck 1424 #include "../common/global_private.h"
52 schoenebeck 35
53 schoenebeck 947 #include "../drivers/midi/MidiInstrumentMapper.h"
54 schoenebeck 1686 #include "../drivers/midi/VirtualMidiDevice.h"
55 schoenebeck 947
56 iliev 1161 #if HAVE_SQLITE3
57     #include "../db/InstrumentsDb.h"
58     #endif
59    
60 schoenebeck 35 /// TCP Port on which the server should listen for connection requests.
61 senkov 667 #define LSCP_ADDR INADDR_ANY
62 schoenebeck 35 #define LSCP_PORT 8888
63    
64 schoenebeck 227 /// try up to 3 minutes to bind server socket
65     #define LSCP_SERVER_BIND_TIMEOUT 180
66    
67 schoenebeck 35 // External references to the main scanner and parser functions
68     extern int yyparse(void* YYPARSE_PARAM);
69 persson 1765
70     namespace LinuxSampler {
71    
72 schoenebeck 219 extern void restart(yyparse_param_t* pparam, int& yychar);
73 schoenebeck 35
74     /**
75     * Network server for the LinuxSampler Control Protocol (LSCP).
76     */
77     class LSCPServer : public Thread {
78     public:
79 senkov 667 LSCPServer(Sampler* pSampler, long int addr, short int port);
80 schoenebeck 475 virtual ~LSCPServer();
81 schoenebeck 211 int WaitUntilInitialized(long TimeoutSeconds = 0L, long TimeoutNanoSeconds = 0L);
82 iliev 1835 void RemoveListeners();
83 schoenebeck 35
84     // Methods called by the parser
85 schoenebeck 123 String DestroyAudioOutputDevice(uint DeviceIndex);
86 senkov 155 String DestroyMidiInputDevice(uint DeviceIndex);
87 capela 137 String LoadInstrument(String Filename, uint uiInstrument, uint uiSamplerChannel, bool bBackground = false);
88 schoenebeck 411 String SetEngineType(String EngineName, uint uiSamplerChannel);
89 schoenebeck 35 String GetChannels();
90 schoenebeck 209 String ListChannels();
91 schoenebeck 35 String AddChannel();
92 schoenebeck 53 String RemoveChannel(uint uiSamplerChannel);
93 schoenebeck 35 String GetAvailableEngines();
94 capela 527 String ListAvailableEngines();
95 schoenebeck 35 String GetEngineInfo(String EngineName);
96 schoenebeck 53 String GetChannelInfo(uint uiSamplerChannel);
97     String GetVoiceCount(uint uiSamplerChannel);
98     String GetStreamCount(uint uiSamplerChannel);
99     String GetBufferFill(fill_response_t ResponseType, uint uiSamplerChannel);
100 schoenebeck 123 String GetAvailableAudioOutputDrivers();
101 capela 527 String ListAvailableAudioOutputDrivers();
102 senkov 155 String GetAvailableMidiInputDrivers();
103 capela 527 String ListAvailableMidiInputDrivers();
104 schoenebeck 123 String GetAudioOutputDriverInfo(String Driver);
105 senkov 155 String GetMidiInputDriverInfo(String Driver);
106 schoenebeck 123 #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 senkov 155 String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
110 senkov 140 String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = StringMap());
111 senkov 155 String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = StringMap());
112 schoenebeck 123 #else
113     String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
114 senkov 155 String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
115 senkov 140 String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
116 senkov 155 String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
117 schoenebeck 123 #endif // __GNUC__
118     String GetAudioOutputDeviceCount();
119 senkov 155 String GetMidiInputDeviceCount();
120 schoenebeck 123 String GetAudioOutputDevices();
121 senkov 155 String GetMidiInputDevices();
122 schoenebeck 123 String GetAudioOutputDeviceInfo(uint DeviceIndex);
123 senkov 155 String GetMidiInputDeviceInfo(uint DeviceIndex);
124     String GetMidiInputPortInfo(uint DeviceIndex, uint PortIndex);
125 senkov 185 String GetMidiInputPortParameterInfo(uint DeviceId, uint PortId, String ParameterName);
126 schoenebeck 123 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 senkov 155 String SetMidiInputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
131 capela 159 String SetMidiInputPortParameter(uint DeviceIndex, uint PortIndex, String ParamKey, String ParamVal);
132 schoenebeck 123 String SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel);
133 capela 159 String SetAudioOutputDevice(uint AudioDeviceId, uint SamplerChannel);
134 capela 143 String SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel);
135 schoenebeck 2500 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 capela 159 String SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel);
141     String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);
142     String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);
143 schoenebeck 123 String SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel);
144 capela 159 String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);
145 schoenebeck 225 String SetVolume(double dVolume, uint uiSamplerChannel);
146 schoenebeck 705 String SetChannelMute(bool bMute, uint uiSamplerChannel);
147     String SetChannelSolo(bool bSolo, uint uiSamplerChannel);
148 schoenebeck 1047 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 schoenebeck 973 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 schoenebeck 1001 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 iliev 1135 String SetFxSendName(uint uiSamplerChannel, uint FxSendID, String Name);
171 schoenebeck 1001 String SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel);
172 schoenebeck 1026 String SetFxSendMidiController(uint uiSamplerChannel, uint FxSendID, uint MidiController);
173     String SetFxSendLevel(uint uiSamplerChannel, uint FxSendID, double dLevel);
174 schoenebeck 2137 String SetFxSendEffect(uint uiSamplerChannel, uint FxSendID, int iSendEffectChain, int iEffectChainPosition);
175 schoenebeck 2135
176     // effect commands
177     String GetAvailableEffects();
178     String ListAvailableEffects();
179     String GetEffectInfo(int iEffectIndex);
180 schoenebeck 2137 String CreateEffectInstance(int iEffectIndex);
181 schoenebeck 2135 String CreateEffectInstance(String effectSystem, String module, String effectName);
182 schoenebeck 2137 String DestroyEffectInstance(int iEffectInstance);
183 schoenebeck 2135 String GetEffectInstances();
184     String ListEffectInstances();
185 schoenebeck 2137 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 schoenebeck 2135
197 iliev 1161 String AddDbInstrumentDirectory(String Dir);
198     String RemoveDbInstrumentDirectory(String Dir, bool Force = false);
199 iliev 1187 String GetDbInstrumentDirectoryCount(String Dir, bool Recursive = false);
200     String GetDbInstrumentDirectories(String Dir, bool Recursive = false);
201 iliev 1161 String GetDbInstrumentDirectoryInfo(String Dir);
202     String SetDbInstrumentDirectoryName(String Dir, String Name);
203     String MoveDbInstrumentDirectory(String Dir, String Dst);
204 iliev 1187 String CopyDbInstrumentDirectory(String Dir, String Dst);
205 iliev 1161 String SetDbInstrumentDirectoryDescription(String Dir, String Desc);
206 iliev 1187 String FindDbInstrumentDirectories(String Dir, std::map<String,String> Parameters, bool Recursive = true);
207 iliev 1200 String AddDbInstruments(String DbDir, String FilePath, int Index = -1, bool bBackground = false);
208 iliev 1781 String AddDbInstruments(String ScanMode, String DbDir, String FsDir, bool bBackground = false, bool insDir = false);
209 iliev 1161 String RemoveDbInstrument(String Instr);
210 iliev 1187 String GetDbInstrumentCount(String Dir, bool Recursive = false);
211     String GetDbInstruments(String Dir, bool Recursive = false);
212 iliev 1161 String GetDbInstrumentInfo(String Instr);
213     String SetDbInstrumentName(String Instr, String Name);
214     String MoveDbInstrument(String Instr, String Dst);
215 iliev 1187 String CopyDbInstrument(String Instr, String Dst);
216 iliev 1161 String SetDbInstrumentDescription(String Instr, String Desc);
217 iliev 1727 String SetDbInstrumentFilePath(String OldPath, String NewPath);
218     String FindLostDbInstrumentFiles();
219 iliev 1187 String FindDbInstruments(String Dir, std::map<String,String> Parameters, bool Recursive = true);
220 iliev 1353 String FormatInstrumentsDb();
221 schoenebeck 1212 String EditSamplerChannelInstrument(uint uiSamplerChannel);
222 iliev 1200 String GetDbInstrumentsJobInfo(int JobId);
223 schoenebeck 53 String ResetChannel(uint uiSamplerChannel);
224 schoenebeck 212 String ResetSampler();
225 schoenebeck 563 String GetServerInfo();
226 iliev 1541 String GetTotalStreamCount();
227 iliev 778 String GetTotalVoiceCount();
228     String GetTotalVoiceCountMax();
229 schoenebeck 1800 String GetGlobalMaxVoices();
230     String SetGlobalMaxVoices(int iVoices);
231     String GetGlobalMaxStreams();
232     String SetGlobalMaxStreams(int iStreams);
233 schoenebeck 1005 String GetGlobalVolume();
234     String SetGlobalVolume(double dVolume);
235 schoenebeck 1525 String GetFileInstruments(String Filename);
236     String ListFileInstruments(String Filename);
237     String GetFileInstrumentInfo(String Filename, uint InstrumentID);
238 iliev 1771 String SendChannelMidiData(String MidiMsg, uint uiSamplerChannel, uint Arg1, uint Arg2);
239 senkov 170 String SubscribeNotification(LSCPEvent::event_t);
240     String UnsubscribeNotification(LSCPEvent::event_t);
241 schoenebeck 210 String SetEcho(yyparse_param_t* pSession, double boolean_value);
242 schoenebeck 2515 String SetShellInteract(yyparse_param_t* pSession, double boolean_value);
243 schoenebeck 35 void AnswerClient(String ReturnMessage);
244 iliev 1848 void CloseAllConnections();
245 senkov 170
246     static int currentSocket;
247     static std::map<int,String> bufferedCommands;
248 senkov 184
249     static void SendLSCPNotify( LSCPEvent Event );
250 senkov 360 static int EventSubscribers( std::list<LSCPEvent::event_t> events );
251 persson 2427 static String FilterEndlines(String s);
252 senkov 184
253 persson 2427 //Protect main thread that generates real time notify messages
254     //like voice count, stream count and buffer fill
255     //from LSCP server removing engines and channels from underneath
256     static Mutex RTNotifyMutex;
257    
258 schoenebeck 35 protected:
259 schoenebeck 53 int hSocket;
260     sockaddr_in SocketAddress;
261     Sampler* pSampler;
262 schoenebeck 211 Condition Initialized;
263 schoenebeck 35
264     int Main(); ///< Implementation of virtual method from class Thread
265 senkov 170
266 schoenebeck 35 private:
267 schoenebeck 209
268 schoenebeck 35 /**
269 capela 143 * Find a created audio output device index.
270     */
271     int GetAudioOutputDeviceIndex (AudioOutputDevice *pDevice);
272 schoenebeck 209
273 senkov 155 /**
274     * Find a created midi input device index.
275     */
276     int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
277 capela 143
278 iliev 1135 EngineChannel* GetEngineChannel(uint uiSamplerChannel);
279    
280     /**
281     * Gets the specified effect send on the specified sampler channel.
282     */
283     FxSend* GetFxSend(uint uiSamplerChannel, uint FxSendID);
284    
285 schoenebeck 705 bool HasSoloChannel();
286     void MuteNonSoloChannels();
287     void UnmuteChannels();
288 schoenebeck 1551
289 iliev 1535 /**
290     * Throws an exception if the specified file is not found or
291     * if directory is specified.
292     */
293     static void VerifyFile(String Filename);
294 schoenebeck 705
295 senkov 170 static std::map<int,String> bufferedNotifies;
296     static Mutex NotifyMutex;
297     static Mutex NotifyBufferMutex;
298 schoenebeck 2515 bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
299 schoenebeck 210 static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
300     static std::vector<yyparse_param_t> Sessions;
301 senkov 170 static Mutex SubscriptionMutex;
302     static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
303     static fd_set fdSet;
304 senkov 360
305 iliev 1133 class EventHandler : public ChannelCountListener, public AudioDeviceCountListener,
306     public MidiDeviceCountListener, public MidiInstrumentCountListener,
307     public MidiInstrumentInfoListener, public MidiInstrumentMapCountListener,
308     public MidiInstrumentMapInfoListener, public FxSendCountListener,
309 iliev 1541 public VoiceCountListener, public StreamCountListener, public BufferFillListener,
310 schoenebeck 1686 public TotalStreamCountListener, public TotalVoiceCountListener,
311 schoenebeck 1695 public EngineChangeListener, public MidiPortCountListener {
312 iliev 1133
313     public:
314 schoenebeck 1686 EventHandler(LSCPServer* pParent);
315    
316 iliev 1130 /**
317     * Invoked when the number of sampler channels has changed.
318     * @param NewCount The new number of sampler channels.
319     */
320     virtual void ChannelCountChanged(int NewCount);
321 schoenebeck 1686 virtual void ChannelAdded(SamplerChannel* pChannel);
322     virtual void ChannelToBeRemoved(SamplerChannel* pChannel);
323 schoenebeck 1212
324 iliev 1130 /**
325     * Invoked when the number of audio output devices has changed.
326     * @param NewCount The new number of audio output devices.
327     */
328     virtual void AudioDeviceCountChanged(int NewCount);
329 schoenebeck 1212
330 iliev 1130 /**
331     * Invoked when the number of MIDI input devices has changed.
332     * @param NewCount The new number of MIDI input devices.
333     */
334     virtual void MidiDeviceCountChanged(int NewCount);
335 iliev 1133
336 iliev 1130 /**
337 schoenebeck 1695 * Invoked right before the supplied MIDI input device is going
338     * to be destroyed.
339     * @param pDevice MidiInputDevice to be deleted
340     */
341     virtual void MidiDeviceToBeDestroyed(MidiInputDevice* pDevice);
342    
343     /**
344     * Invoked to inform that a new MidiInputDevice has just been
345     * created.
346     * @param pDevice newly created MidiInputDevice
347     */
348     virtual void MidiDeviceCreated(MidiInputDevice* pDevice);
349    
350     /**
351     * Invoked when the number of MIDI input ports has changed.
352     * @param NewCount The new number of MIDI input ports.
353     */
354     virtual void MidiPortCountChanged(int NewCount);
355    
356     /**
357     * Invoked right before the supplied MIDI input port is going
358     * to be destroyed.
359     * @param pPort MidiInputPort to be deleted
360     */
361     virtual void MidiPortToBeRemoved(MidiInputPort* pPort);
362    
363     /**
364     * Invoked to inform that a new MidiInputPort has just been
365     * added.
366     * @param pPort newly created MidiInputPort
367     */
368     virtual void MidiPortAdded(MidiInputPort* pPort);
369    
370     /**
371 iliev 1130 * Invoked when the number of MIDI instruments has changed.
372     * @param MapId The numerical ID of the MIDI instrument map.
373     * @param NewCount The new number of MIDI instruments.
374     */
375     virtual void MidiInstrumentCountChanged(int MapId, int NewCount);
376 schoenebeck 1212
377 iliev 1130 /**
378     * Invoked when a MIDI instrument in a MIDI instrument map is changed.
379     * @param MapId The numerical ID of the MIDI instrument map.
380     * @param Bank The index of the MIDI bank, containing the instrument.
381     * @param Program The MIDI program number of the instrument.
382     */
383     virtual void MidiInstrumentInfoChanged(int MapId, int Bank, int Program);
384 schoenebeck 1212
385 iliev 1133 /**
386 iliev 1130 * Invoked when the number of MIDI instrument maps has changed.
387     * @param NewCount The new number of MIDI instruments.
388     */
389     virtual void MidiInstrumentMapCountChanged(int NewCount);
390    
391     /**
392     * Invoked when the settings of a MIDI instrument map are changed.
393     * @param MapId The numerical ID of the MIDI instrument map.
394     */
395     virtual void MidiInstrumentMapInfoChanged(int MapId);
396 schoenebeck 1212
397 iliev 1130 /**
398     * Invoked when the number of effect sends
399     * on the specified sampler channel has changed.
400     * @param ChannelId The numerical ID of the sampler channel.
401     * @param NewCount The new number of effect sends.
402     */
403     virtual void FxSendCountChanged(int ChannelId, int NewCount);
404 iliev 1133
405 iliev 1130 /**
406     * Invoked when the number of active voices
407     * on the specified sampler channel has changed.
408     * @param ChannelId The numerical ID of the sampler channel.
409     * @param NewCount The new number of active voices.
410     */
411     virtual void VoiceCountChanged(int ChannelId, int NewCount);
412    
413     /**
414     * Invoked when the number of active disk streams
415     * on the specified sampler channel has changed.
416     * @param ChannelId The numerical ID of the sampler channel.
417     * @param NewCount The new number of active disk streams.
418     */
419     virtual void StreamCountChanged(int ChannelId, int NewCount);
420    
421     /**
422     * Invoked when the fill state of the disk stream
423     * buffers on the specified sampler channel is changed.
424     * @param ChannelId The numerical ID of the sampler channel.
425     * @param FillData The buffer fill data for the specified sampler channel.
426     */
427     virtual void BufferFillChanged(int ChannelId, String FillData);
428    
429     /**
430     * Invoked when the total number of active voices is changed.
431     * @param NewCount The new number of active voices.
432     */
433     virtual void TotalVoiceCountChanged(int NewCount);
434 iliev 1541 virtual void TotalStreamCountChanged(int NewCount);
435 schoenebeck 1686
436     virtual void EngineToBeChanged(int ChannelId);
437     virtual void EngineChanged(int ChannelId);
438    
439     virtual ~EventHandler();
440    
441     struct midi_listener_entry {
442     SamplerChannel* pSamplerChannel;
443     EngineChannel* pEngineChannel;
444     VirtualMidiDevice* pMidiListener;
445     };
446    
447     std::vector<midi_listener_entry> channelMidiListeners;
448    
449 schoenebeck 1695 struct device_midi_listener_entry {
450     MidiInputPort* pPort;
451     VirtualMidiDevice* pMidiListener;
452     uint uiDeviceID;
453     };
454    
455     std::vector<device_midi_listener_entry> deviceMidiListeners;
456    
457 schoenebeck 1686 private:
458     LSCPServer* pParent;
459 iliev 1133 } eventHandler;
460 iliev 1161
461     #if HAVE_SQLITE3
462     class DbInstrumentsEventHandler : public InstrumentsDb::Listener {
463     public:
464     virtual void DirectoryCountChanged(String Dir);
465     virtual void DirectoryInfoChanged(String Dir);
466     virtual void DirectoryNameChanged(String Dir, String NewName);
467     virtual void InstrumentCountChanged(String Dir);
468     virtual void InstrumentInfoChanged(String Instr);
469     virtual void InstrumentNameChanged(String Instr, String NewName);
470 iliev 1200 virtual void JobStatusChanged(int JobId);
471 iliev 1161 } dbInstrumentsEventHandler;
472     #endif // HAVE_SQLITE3
473 schoenebeck 35 };
474    
475 persson 1765 }
476    
477 schoenebeck 35 #endif // __LSCPSERVER_H_
  ViewVC Help
Powered by ViewVC