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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 778 by iliev, Fri Sep 23 06:58:26 2005 UTC revision 2515 by schoenebeck, Wed Feb 5 20:45:18 2014 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 Christian Schoenebeck                              *   *   Copyright (C) 2005 - 2014 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  #ifndef __LSCPSERVER_H_  #ifndef __LSCPSERVER_H_
25  #define __LSCPSERVER_H_  #define __LSCPSERVER_H_
26    
27    #if defined(WIN32)
28    #include <windows.h>
29    typedef int socklen_t;
30    #else
31  #include <unistd.h>  #include <unistd.h>
32  #include <sys/types.h>  #include <sys/types.h>
33  #include <sys/socket.h>  #include <sys/socket.h>
# Line 33  Line 37 
37  #include <netinet/tcp.h>  #include <netinet/tcp.h>
38  #include <arpa/inet.h>  #include <arpa/inet.h>
39  #include <netdb.h>  #include <netdb.h>
40    #endif
41    
42  #include <list>  #include <list>
43    
44  #include "lscp.h"  #include "lscp.h"
45  #include "lscpparser.h"  #include "lscpparser.h"
 #include "lscp.h"  
46  #include "lscpevent.h"  #include "lscpevent.h"
 #include "lscpinstrumentloader.h"  
47  #include "../Sampler.h"  #include "../Sampler.h"
48  #include "../common/Thread.h"  #include "../common/Thread.h"
49  #include "../common/Mutex.h"  #include "../common/Mutex.h"
50  #include "../common/Condition.h"  #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.  /// TCP Port on which the server should listen for connection requests.
61  #define LSCP_ADDR INADDR_ANY  #define LSCP_ADDR INADDR_ANY
# Line 53  Line 64 
64  /// try up to 3 minutes to bind server socket  /// try up to 3 minutes to bind server socket
65  #define LSCP_SERVER_BIND_TIMEOUT 180  #define LSCP_SERVER_BIND_TIMEOUT 180
66    
 using namespace LinuxSampler;  
   
67  // External references to the main scanner and parser functions  // External references to the main scanner and parser functions
68  extern int yyparse(void* YYPARSE_PARAM);  extern int yyparse(void* YYPARSE_PARAM);
69    
70    namespace LinuxSampler {
71    
72  extern void restart(yyparse_param_t* pparam, int& yychar);  extern void restart(yyparse_param_t* pparam, int& yychar);
73    
74  /**  /**
# Line 67  class LSCPServer : public Thread { Line 79  class LSCPServer : public Thread {
79          LSCPServer(Sampler* pSampler, long int addr, short int port);          LSCPServer(Sampler* pSampler, long int addr, short int port);
80          virtual ~LSCPServer();          virtual ~LSCPServer();
81          int WaitUntilInitialized(long TimeoutSeconds = 0L, long TimeoutNanoSeconds = 0L);          int WaitUntilInitialized(long TimeoutSeconds = 0L, long TimeoutNanoSeconds = 0L);
82            void RemoveListeners();
83    
84          // Methods called by the parser          // Methods called by the parser
85          String DestroyAudioOutputDevice(uint DeviceIndex);          String DestroyAudioOutputDevice(uint DeviceIndex);
# Line 119  class LSCPServer : public Thread { Line 132  class LSCPServer : public Thread {
132          String SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel);          String SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel);
133          String SetAudioOutputDevice(uint AudioDeviceId, uint SamplerChannel);          String SetAudioOutputDevice(uint AudioDeviceId, uint SamplerChannel);
134          String SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel);          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);          String SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel);
141          String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);          String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);
142          String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);          String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);
# Line 127  class LSCPServer : public Thread { Line 145  class LSCPServer : public Thread {
145          String SetVolume(double dVolume, uint uiSamplerChannel);          String SetVolume(double dVolume, uint uiSamplerChannel);
146          String SetChannelMute(bool bMute, uint uiSamplerChannel);          String SetChannelMute(bool bMute, uint uiSamplerChannel);
147          String SetChannelSolo(bool bSolo, uint uiSamplerChannel);          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);          String ResetChannel(uint uiSamplerChannel);
224          String ResetSampler();          String ResetSampler();
225          String GetServerInfo();          String GetServerInfo();
226            String GetTotalStreamCount();
227          String GetTotalVoiceCount();          String GetTotalVoiceCount();
228          String GetTotalVoiceCountMax();          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);          String SubscribeNotification(LSCPEvent::event_t);
240          String UnsubscribeNotification(LSCPEvent::event_t);          String UnsubscribeNotification(LSCPEvent::event_t);
         String QueryDatabase(String query);  
241          String SetEcho(yyparse_param_t* pSession, double boolean_value);          String SetEcho(yyparse_param_t* pSession, double boolean_value);
242            String SetShellInteract(yyparse_param_t* pSession, double boolean_value);
243          void   AnswerClient(String ReturnMessage);          void   AnswerClient(String ReturnMessage);
244            void   CloseAllConnections();
245    
246          static int currentSocket;          static int currentSocket;
247          static std::map<int,String> bufferedCommands;          static std::map<int,String> bufferedCommands;
248    
249          static void SendLSCPNotify( LSCPEvent Event );          static void SendLSCPNotify( LSCPEvent Event );
250          static int EventSubscribers( std::list<LSCPEvent::event_t> events );          static int EventSubscribers( std::list<LSCPEvent::event_t> events );
251          static void LockRTNotify( void ) { RTNotifyMutex.Lock(); }          static String FilterEndlines(String s);
252          static void UnlockRTNotify( void ) { RTNotifyMutex.Unlock(); }  
253            //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      protected:      protected:
259          int            hSocket;          int            hSocket;
260          sockaddr_in    SocketAddress;          sockaddr_in    SocketAddress;
261          Sampler*       pSampler;          Sampler*       pSampler;
262          Condition      Initialized;          Condition      Initialized;
         LSCPInstrumentLoader InstrumentLoader; ///< thread responsible for loading instruments in the background  
263    
264          int Main(); ///< Implementation of virtual method from class Thread          int Main(); ///< Implementation of virtual method from class Thread
265    
# Line 167  class LSCPServer : public Thread { Line 275  class LSCPServer : public Thread {
275           */           */
276          int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);          int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
277    
278            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          bool HasSoloChannel();          bool HasSoloChannel();
286          void MuteNonSoloChannels();          void MuteNonSoloChannels();
287          void UnmuteChannels();          void UnmuteChannels();
288    
289            /**
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    
295          static std::map<int,String> bufferedNotifies;          static std::map<int,String> bufferedNotifies;
296          static Mutex NotifyMutex;          static Mutex NotifyMutex;
297          static Mutex NotifyBufferMutex;          static Mutex NotifyBufferMutex;
298          static bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );          bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
299          static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );          static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
300          static std::vector<yyparse_param_t> Sessions;          static std::vector<yyparse_param_t> Sessions;
301          static Mutex SubscriptionMutex;          static Mutex SubscriptionMutex;
302          static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;          static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
303          static fd_set fdSet;          static fd_set fdSet;
304    
305          //Protect main thread that generates real time notify messages          class EventHandler : public ChannelCountListener, public AudioDeviceCountListener,
306          //like voice count, stream count and buffer fill              public MidiDeviceCountListener, public MidiInstrumentCountListener,
307          //from LSCP server removing engines and channels from underneath              public MidiInstrumentInfoListener, public MidiInstrumentMapCountListener,
308          static Mutex RTNotifyMutex;              public MidiInstrumentMapInfoListener, public FxSendCountListener,
309                public VoiceCountListener, public StreamCountListener, public BufferFillListener,
310                public TotalStreamCountListener, public TotalVoiceCountListener,
311                public EngineChangeListener, public MidiPortCountListener {
312    
313                public:
314                    EventHandler(LSCPServer* pParent);
315    
316                    /**
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                    virtual void ChannelAdded(SamplerChannel* pChannel);
322                    virtual void ChannelToBeRemoved(SamplerChannel* pChannel);
323    
324                    /**
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    
330                    /**
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    
336                    /**
337                     * 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                     * 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    
377                    /**
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    
385                    /**
386                     * 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    
397                    /**
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    
405                    /**
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                    virtual void TotalStreamCountChanged(int NewCount);
435    
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                    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                private:
458                    LSCPServer* pParent;
459            } eventHandler;
460    
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                    virtual void JobStatusChanged(int JobId);
471            } dbInstrumentsEventHandler;
472    #endif // HAVE_SQLITE3
473  };  };
474    
475    }
476    
477  #endif // __LSCPSERVER_H_  #endif // __LSCPSERVER_H_
Legend:
Removed from v.778  
changed lines
  Added in v.2515
  ViewVC Help
Powered by ViewVC