src/network/lscpserver.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2008 Christian Schoenebeck                       *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this library; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LSCPSERVER_H_
#define __LSCPSERVER_H_

#if defined(WIN32)
#include <windows.h>
typedef int socklen_t;
#else
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#endif

#include <list>

#include "lscp.h"
#include "lscpparser.h"
#include "lscp.h"
#include "lscpevent.h"
#include "../Sampler.h"
#include "../common/Thread.h"
#include "../common/Mutex.h"
#include "../common/Condition.h"
#include "../common/global_private.h"

#include "../drivers/midi/MidiInstrumentMapper.h"
#include "../drivers/midi/VirtualMidiDevice.h"

#if HAVE_SQLITE3
#include "../db/InstrumentsDb.h"
#endif

/// TCP Port on which the server should listen for connection requests.
#define LSCP_ADDR INADDR_ANY
#define LSCP_PORT 8888

/// try up to 3 minutes to bind server socket
#define LSCP_SERVER_BIND_TIMEOUT 180

using namespace LinuxSampler;

// External references to the main scanner and parser functions
extern int yyparse(void* YYPARSE_PARAM);
extern void restart(yyparse_param_t* pparam, int& yychar);

/**
 * Network server for the LinuxSampler Control Protocol (LSCP).
 */
class LSCPServer : public Thread {
    public:
        LSCPServer(Sampler* pSampler, long int addr, short int port);
        virtual ~LSCPServer();
        int WaitUntilInitialized(long TimeoutSeconds = 0L, long TimeoutNanoSeconds = 0L);

        // Methods called by the parser
        String DestroyAudioOutputDevice(uint DeviceIndex);
        String DestroyMidiInputDevice(uint DeviceIndex);
        String LoadInstrument(String Filename, uint uiInstrument, uint uiSamplerChannel, bool bBackground = false);
        String SetEngineType(String EngineName, uint uiSamplerChannel);
        String GetChannels();
        String ListChannels();
        String AddChannel();
        String RemoveChannel(uint uiSamplerChannel);
        String GetAvailableEngines();
        String ListAvailableEngines();
        String GetEngineInfo(String EngineName);
        String GetChannelInfo(uint uiSamplerChannel);
        String GetVoiceCount(uint uiSamplerChannel);
        String GetStreamCount(uint uiSamplerChannel);
        String GetBufferFill(fill_response_t ResponseType, uint uiSamplerChannel);
        String GetAvailableAudioOutputDrivers();
        String ListAvailableAudioOutputDrivers();
        String GetAvailableMidiInputDrivers();
        String ListAvailableMidiInputDrivers();
        String GetAudioOutputDriverInfo(String Driver);
        String GetMidiInputDriverInfo(String Driver);
#ifdef __GNUC__
        typedef std::map<String,String> StringMap; // nasty workaround for a GCC bug (see GCC bug #15980, #57)
        String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
        String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
        String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = StringMap());
        String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = StringMap());
#else
        String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
        String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
        String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
        String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
#endif // __GNUC__
        String GetAudioOutputDeviceCount();
        String GetMidiInputDeviceCount();
        String GetAudioOutputDevices();
        String GetMidiInputDevices();
        String GetAudioOutputDeviceInfo(uint DeviceIndex);
        String GetMidiInputDeviceInfo(uint DeviceIndex);
        String GetMidiInputPortInfo(uint DeviceIndex, uint PortIndex);
        String GetMidiInputPortParameterInfo(uint DeviceId, uint PortId, String ParameterName);
        String GetAudioOutputChannelInfo(uint DeviceId, uint ChannelId);
        String GetAudioOutputChannelParameterInfo(uint DeviceId, uint ChannelId, String ParameterName);
        String SetAudioOutputChannelParameter(uint DeviceId, uint ChannelId, String ParamKey, String ParamVal);
        String SetAudioOutputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
        String SetMidiInputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
        String SetMidiInputPortParameter(uint DeviceIndex, uint PortIndex, String ParamKey, String ParamVal);
        String SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel);
        String SetAudioOutputDevice(uint AudioDeviceId, uint SamplerChannel);
        String SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel);
        String SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel);
        String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);
        String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);
        String SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel);
        String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);
        String SetVolume(double dVolume, uint uiSamplerChannel);
        String SetChannelMute(bool bMute, uint uiSamplerChannel);
        String SetChannelSolo(bool bSolo, uint uiSamplerChannel);
        String AddOrReplaceMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg, String EngineType, String InstrumentFile, uint InstrumentIndex, float Volume, MidiInstrumentMapper::mode_t LoadMode, String Name, bool bModal);
        String RemoveMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
        String GetMidiInstrumentMappings(uint MidiMapID);
        String GetAllMidiInstrumentMappings();
        String GetMidiInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
        String ListMidiInstrumentMappings(uint MidiMapID);
        String ListAllMidiInstrumentMappings();
        String ClearMidiInstrumentMappings(uint MidiMapID);
        String ClearAllMidiInstrumentMappings();
        String AddMidiInstrumentMap(String MapName = "");
        String RemoveMidiInstrumentMap(uint MidiMapID);
        String RemoveAllMidiInstrumentMaps();
        String GetMidiInstrumentMaps();
        String ListMidiInstrumentMaps();
        String GetMidiInstrumentMap(uint MidiMapID);
        String SetMidiInstrumentMapName(uint MidiMapID, String NewName);
        String SetChannelMap(uint uiSamplerChannel, int MidiMapID);
        String CreateFxSend(uint uiSamplerChannel, uint MidiCtrl, String Name = "");
        String DestroyFxSend(uint uiSamplerChannel, uint FxSendID);
        String GetFxSends(uint uiSamplerChannel);
        String ListFxSends(uint uiSamplerChannel);
        String GetFxSendInfo(uint uiSamplerChannel, uint FxSendID);
        String SetFxSendName(uint uiSamplerChannel, uint FxSendID, String Name);
        String SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel);
        String SetFxSendMidiController(uint uiSamplerChannel, uint FxSendID, uint MidiController);
        String SetFxSendLevel(uint uiSamplerChannel, uint FxSendID, double dLevel);
        String AddDbInstrumentDirectory(String Dir);
        String RemoveDbInstrumentDirectory(String Dir, bool Force = false);
        String GetDbInstrumentDirectoryCount(String Dir, bool Recursive = false);
        String GetDbInstrumentDirectories(String Dir, bool Recursive = false);
        String GetDbInstrumentDirectoryInfo(String Dir);
        String SetDbInstrumentDirectoryName(String Dir, String Name);
        String MoveDbInstrumentDirectory(String Dir, String Dst);
        String CopyDbInstrumentDirectory(String Dir, String Dst);
        String SetDbInstrumentDirectoryDescription(String Dir, String Desc);
        String FindDbInstrumentDirectories(String Dir, std::map<String,String> Parameters, bool Recursive = true);
        String AddDbInstruments(String DbDir, String FilePath, int Index = -1, bool bBackground = false);
        String AddDbInstruments(String ScanMode, String DbDir, String FsDir, bool bBackground = false);
        String RemoveDbInstrument(String Instr);
        String GetDbInstrumentCount(String Dir, bool Recursive = false);
        String GetDbInstruments(String Dir, bool Recursive = false);
        String GetDbInstrumentInfo(String Instr);
        String SetDbInstrumentName(String Instr, String Name);
        String MoveDbInstrument(String Instr, String Dst);
        String CopyDbInstrument(String Instr, String Dst);
        String SetDbInstrumentDescription(String Instr, String Desc);
        String FindDbInstruments(String Dir, std::map<String,String> Parameters, bool Recursive = true);
        String FormatInstrumentsDb();
        String EditSamplerChannelInstrument(uint uiSamplerChannel);
        String GetDbInstrumentsJobInfo(int JobId);
        String ResetChannel(uint uiSamplerChannel);
        String ResetSampler();
        String GetServerInfo();
        String GetTotalStreamCount();
        String GetTotalVoiceCount();
        String GetTotalVoiceCountMax();
        String GetGlobalVolume();
        String SetGlobalVolume(double dVolume);
        String GetFileInstruments(String Filename);
        String ListFileInstruments(String Filename);
        String GetFileInstrumentInfo(String Filename, uint InstrumentID);
        String SubscribeNotification(LSCPEvent::event_t);
        String UnsubscribeNotification(LSCPEvent::event_t);
        String SetEcho(yyparse_param_t* pSession, double boolean_value);
        void   AnswerClient(String ReturnMessage);

        static int currentSocket;
        static std::map<int,String> bufferedCommands;

        static void SendLSCPNotify( LSCPEvent Event );
        static int EventSubscribers( std::list<LSCPEvent::event_t> events );
    static void LockRTNotify();
    static void UnlockRTNotify();
    static String FilterEndlines(String s);

    protected:
        int            hSocket;
        sockaddr_in    SocketAddress;
        Sampler*       pSampler;
        Condition      Initialized;

        int Main(); ///< Implementation of virtual method from class Thread

    private:

        /**
         * Find a created audio output device index.
         */
        int GetAudioOutputDeviceIndex (AudioOutputDevice *pDevice);

        /**
         * Find a created midi input device index.
         */
        int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);

        EngineChannel* GetEngineChannel(uint uiSamplerChannel);

                /**
                 * Gets the specified effect send on the specified sampler channel.
                 */
                FxSend* GetFxSend(uint uiSamplerChannel, uint FxSendID);

        bool HasSoloChannel();
        void MuteNonSoloChannels();
        void UnmuteChannels();

        /**
         * Throws an exception if the specified file is not found or
         * if directory is specified.
         */
        static void VerifyFile(String Filename);

        static std::map<int,String> bufferedNotifies;
        static Mutex NotifyMutex;
        static Mutex NotifyBufferMutex;
        static bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
        static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
        static std::vector<yyparse_param_t> Sessions;
        static Mutex SubscriptionMutex;
        static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
        static fd_set fdSet;

        //Protect main thread that generates real time notify messages
        //like voice count, stream count and buffer fill
        //from LSCP server removing engines and channels from underneath
        static Mutex RTNotifyMutex;

        class EventHandler : public ChannelCountListener, public AudioDeviceCountListener,
            public MidiDeviceCountListener, public MidiInstrumentCountListener,
            public MidiInstrumentInfoListener, public MidiInstrumentMapCountListener,
            public MidiInstrumentMapInfoListener, public FxSendCountListener,
            public VoiceCountListener, public StreamCountListener, public BufferFillListener,
            public TotalStreamCountListener, public TotalVoiceCountListener,
            public EngineChangeListener {

            public:
                EventHandler(LSCPServer* pParent);

                /**
                 * Invoked when the number of sampler channels has changed.
                 * @param NewCount The new number of sampler channels.
                 */
                virtual void ChannelCountChanged(int NewCount);
                virtual void ChannelAdded(SamplerChannel* pChannel);
                virtual void ChannelToBeRemoved(SamplerChannel* pChannel);

                /**
                 * Invoked when the number of audio output devices has changed.
                 * @param NewCount The new number of audio output devices.
                 */
                virtual void AudioDeviceCountChanged(int NewCount);

                /**
                 * Invoked when the number of MIDI input devices has changed.
                 * @param NewCount The new number of MIDI input devices.
                 */
                virtual void MidiDeviceCountChanged(int NewCount);

                /**
                 * Invoked when the number of MIDI instruments has changed.
                 * @param MapId The numerical ID of the MIDI instrument map.
                 * @param NewCount The new number of MIDI instruments.
                 */
                virtual void MidiInstrumentCountChanged(int MapId, int NewCount);

                /**
                 * Invoked when a MIDI instrument in a MIDI instrument map is changed.
                 * @param MapId The numerical ID of the MIDI instrument map.
                 * @param Bank The index of the MIDI bank, containing the instrument.
                 * @param Program The MIDI program number of the instrument.
                 */
                virtual void MidiInstrumentInfoChanged(int MapId, int Bank, int Program);

                /**
                 * Invoked when the number of MIDI instrument maps has changed.
                 * @param NewCount The new number of MIDI instruments.
                 */
                virtual void MidiInstrumentMapCountChanged(int NewCount);

                /**
                 * Invoked when the settings of a MIDI instrument map are changed.
                 * @param MapId The numerical ID of the MIDI instrument map.
                 */
                virtual void MidiInstrumentMapInfoChanged(int MapId);

                /**
                 * Invoked when the number of effect sends
                 * on the specified sampler channel has changed.
                 * @param ChannelId The numerical ID of the sampler channel.
                 * @param NewCount The new number of effect sends.
                 */
                virtual void FxSendCountChanged(int ChannelId, int NewCount);

                /**
                 * Invoked when the number of active voices
                 * on the specified sampler channel has changed.
                 * @param ChannelId The numerical ID of the sampler channel.
                 * @param NewCount The new number of active voices.
                 */
                virtual void VoiceCountChanged(int ChannelId, int NewCount);

                /**
                 * Invoked when the number of active disk streams
                 * on the specified sampler channel has changed.
                 * @param ChannelId The numerical ID of the sampler channel.
                 * @param NewCount The new number of active disk streams.
                 */
                virtual void StreamCountChanged(int ChannelId, int NewCount);

                /**
                 * Invoked when the fill state of the disk stream
                 * buffers on the specified sampler channel is changed.
                 * @param ChannelId The numerical ID of the sampler channel.
                 * @param FillData The buffer fill data for the specified sampler channel.
                 */
                virtual void BufferFillChanged(int ChannelId, String FillData);

                /**
                 * Invoked when the total number of active voices is changed.
                 * @param NewCount The new number of active voices.
                 */
                virtual void TotalVoiceCountChanged(int NewCount);
                virtual void TotalStreamCountChanged(int NewCount);

                virtual void EngineToBeChanged(int ChannelId);
                virtual void EngineChanged(int ChannelId);

                virtual ~EventHandler();

                struct midi_listener_entry {
                    SamplerChannel* pSamplerChannel;
                    EngineChannel* pEngineChannel;
                    VirtualMidiDevice* pMidiListener;
                };

                std::vector<midi_listener_entry> channelMidiListeners;

            private:
                LSCPServer* pParent;
        } eventHandler;

#if HAVE_SQLITE3
        class DbInstrumentsEventHandler : public InstrumentsDb::Listener {
            public:
                virtual void DirectoryCountChanged(String Dir);
                virtual void DirectoryInfoChanged(String Dir);
                virtual void DirectoryNameChanged(String Dir, String NewName);
                virtual void InstrumentCountChanged(String Dir);
                virtual void InstrumentInfoChanged(String Instr);
                virtual void InstrumentNameChanged(String Instr, String NewName);
                virtual void JobStatusChanged(int JobId);
        } dbInstrumentsEventHandler;
#endif // HAVE_SQLITE3
};

#endif // __LSCPSERVER_H_
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 "lscp.h"
47	#include "lscpevent.h"
48	#include "../Sampler.h"
49	#include "../common/Thread.h"
50	#include "../common/Mutex.h"
51	#include "../common/Condition.h"
52	#include "../common/global_private.h"
53
54	#include "../drivers/midi/MidiInstrumentMapper.h"
55	#include "../drivers/midi/VirtualMidiDevice.h"
56
57	#if HAVE_SQLITE3
58	#include "../db/InstrumentsDb.h"
59	#endif
60
61	/// TCP Port on which the server should listen for connection requests.
62	#define LSCP_ADDR INADDR_ANY
63	#define LSCP_PORT 8888
64
65	/// try up to 3 minutes to bind server socket
66	#define LSCP_SERVER_BIND_TIMEOUT 180
67
68	using namespace LinuxSampler;
69
70	// External references to the main scanner and parser functions
71	extern int yyparse(void* YYPARSE_PARAM);
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
83	// Methods called by the parser
84	String DestroyAudioOutputDevice(uint DeviceIndex);
85	String DestroyMidiInputDevice(uint DeviceIndex);
86	String LoadInstrument(String Filename, uint uiInstrument, uint uiSamplerChannel, bool bBackground = false);
87	String SetEngineType(String EngineName, uint uiSamplerChannel);
88	String GetChannels();
89	String ListChannels();
90	String AddChannel();
91	String RemoveChannel(uint uiSamplerChannel);
92	String GetAvailableEngines();
93	String ListAvailableEngines();
94	String GetEngineInfo(String EngineName);
95	String GetChannelInfo(uint uiSamplerChannel);
96	String GetVoiceCount(uint uiSamplerChannel);
97	String GetStreamCount(uint uiSamplerChannel);
98	String GetBufferFill(fill_response_t ResponseType, uint uiSamplerChannel);
99	String GetAvailableAudioOutputDrivers();
100	String ListAvailableAudioOutputDrivers();
101	String GetAvailableMidiInputDrivers();
102	String ListAvailableMidiInputDrivers();
103	String GetAudioOutputDriverInfo(String Driver);
104	String GetMidiInputDriverInfo(String Driver);
105	#ifdef __GNUC__
106	typedef std::map<String,String> StringMap; // nasty workaround for a GCC bug (see GCC bug #15980, #57)
107	String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
108	String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
109	String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = StringMap());
110	String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = StringMap());
111	#else
112	String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
113	String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
114	String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
115	String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
116	#endif // __GNUC__
117	String GetAudioOutputDeviceCount();
118	String GetMidiInputDeviceCount();
119	String GetAudioOutputDevices();
120	String GetMidiInputDevices();
121	String GetAudioOutputDeviceInfo(uint DeviceIndex);
122	String GetMidiInputDeviceInfo(uint DeviceIndex);
123	String GetMidiInputPortInfo(uint DeviceIndex, uint PortIndex);
124	String GetMidiInputPortParameterInfo(uint DeviceId, uint PortId, String ParameterName);
125	String GetAudioOutputChannelInfo(uint DeviceId, uint ChannelId);
126	String GetAudioOutputChannelParameterInfo(uint DeviceId, uint ChannelId, String ParameterName);
127	String SetAudioOutputChannelParameter(uint DeviceId, uint ChannelId, String ParamKey, String ParamVal);
128	String SetAudioOutputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
129	String SetMidiInputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
130	String SetMidiInputPortParameter(uint DeviceIndex, uint PortIndex, String ParamKey, String ParamVal);
131	String SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel);
132	String SetAudioOutputDevice(uint AudioDeviceId, uint SamplerChannel);
133	String SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel);
134	String SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel);
135	String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);
136	String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);
137	String SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel);
138	String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);
139	String SetVolume(double dVolume, uint uiSamplerChannel);
140	String SetChannelMute(bool bMute, uint uiSamplerChannel);
141	String SetChannelSolo(bool bSolo, uint uiSamplerChannel);
142	String AddOrReplaceMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg, String EngineType, String InstrumentFile, uint InstrumentIndex, float Volume, MidiInstrumentMapper::mode_t LoadMode, String Name, bool bModal);
143	String RemoveMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
144	String GetMidiInstrumentMappings(uint MidiMapID);
145	String GetAllMidiInstrumentMappings();
146	String GetMidiInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
147	String ListMidiInstrumentMappings(uint MidiMapID);
148	String ListAllMidiInstrumentMappings();
149	String ClearMidiInstrumentMappings(uint MidiMapID);
150	String ClearAllMidiInstrumentMappings();
151	String AddMidiInstrumentMap(String MapName = "");
152	String RemoveMidiInstrumentMap(uint MidiMapID);
153	String RemoveAllMidiInstrumentMaps();
154	String GetMidiInstrumentMaps();
155	String ListMidiInstrumentMaps();
156	String GetMidiInstrumentMap(uint MidiMapID);
157	String SetMidiInstrumentMapName(uint MidiMapID, String NewName);
158	String SetChannelMap(uint uiSamplerChannel, int MidiMapID);
159	String CreateFxSend(uint uiSamplerChannel, uint MidiCtrl, String Name = "");
160	String DestroyFxSend(uint uiSamplerChannel, uint FxSendID);
161	String GetFxSends(uint uiSamplerChannel);
162	String ListFxSends(uint uiSamplerChannel);
163	String GetFxSendInfo(uint uiSamplerChannel, uint FxSendID);
164	String SetFxSendName(uint uiSamplerChannel, uint FxSendID, String Name);
165	String SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel);
166	String SetFxSendMidiController(uint uiSamplerChannel, uint FxSendID, uint MidiController);
167	String SetFxSendLevel(uint uiSamplerChannel, uint FxSendID, double dLevel);
168	String AddDbInstrumentDirectory(String Dir);
169	String RemoveDbInstrumentDirectory(String Dir, bool Force = false);
170	String GetDbInstrumentDirectoryCount(String Dir, bool Recursive = false);
171	String GetDbInstrumentDirectories(String Dir, bool Recursive = false);
172	String GetDbInstrumentDirectoryInfo(String Dir);
173	String SetDbInstrumentDirectoryName(String Dir, String Name);
174	String MoveDbInstrumentDirectory(String Dir, String Dst);
175	String CopyDbInstrumentDirectory(String Dir, String Dst);
176	String SetDbInstrumentDirectoryDescription(String Dir, String Desc);
177	String FindDbInstrumentDirectories(String Dir, std::map<String,String> Parameters, bool Recursive = true);
178	String AddDbInstruments(String DbDir, String FilePath, int Index = -1, bool bBackground = false);
179	String AddDbInstruments(String ScanMode, String DbDir, String FsDir, bool bBackground = false);
180	String RemoveDbInstrument(String Instr);
181	String GetDbInstrumentCount(String Dir, bool Recursive = false);
182	String GetDbInstruments(String Dir, bool Recursive = false);
183	String GetDbInstrumentInfo(String Instr);
184	String SetDbInstrumentName(String Instr, String Name);
185	String MoveDbInstrument(String Instr, String Dst);
186	String CopyDbInstrument(String Instr, String Dst);
187	String SetDbInstrumentDescription(String Instr, String Desc);
188	String FindDbInstruments(String Dir, std::map<String,String> Parameters, bool Recursive = true);
189	String FormatInstrumentsDb();
190	String EditSamplerChannelInstrument(uint uiSamplerChannel);
191	String GetDbInstrumentsJobInfo(int JobId);
192	String ResetChannel(uint uiSamplerChannel);
193	String ResetSampler();
194	String GetServerInfo();
195	String GetTotalStreamCount();
196	String GetTotalVoiceCount();
197	String GetTotalVoiceCountMax();
198	String GetGlobalVolume();
199	String SetGlobalVolume(double dVolume);
200	String GetFileInstruments(String Filename);
201	String ListFileInstruments(String Filename);
202	String GetFileInstrumentInfo(String Filename, uint InstrumentID);
203	String SubscribeNotification(LSCPEvent::event_t);
204	String UnsubscribeNotification(LSCPEvent::event_t);
205	String SetEcho(yyparse_param_t* pSession, double boolean_value);
206	void AnswerClient(String ReturnMessage);
207
208	static int currentSocket;
209	static std::map<int,String> bufferedCommands;
210
211	static void SendLSCPNotify( LSCPEvent Event );
212	static int EventSubscribers( std::list<LSCPEvent::event_t> events );
213	static void LockRTNotify();
214	static void UnlockRTNotify();
215	static String FilterEndlines(String s);
216
217	protected:
218	int hSocket;
219	sockaddr_in SocketAddress;
220	Sampler* pSampler;
221	Condition Initialized;
222
223	int Main(); ///< Implementation of virtual method from class Thread
224
225	private:
226
227	/**
228	* Find a created audio output device index.
229	*/
230	int GetAudioOutputDeviceIndex (AudioOutputDevice *pDevice);
231
232	/**
233	* Find a created midi input device index.
234	*/
235	int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
236
237	EngineChannel* GetEngineChannel(uint uiSamplerChannel);
238
239	/**
240	* Gets the specified effect send on the specified sampler channel.
241	*/
242	FxSend* GetFxSend(uint uiSamplerChannel, uint FxSendID);
243
244	bool HasSoloChannel();
245	void MuteNonSoloChannels();
246	void UnmuteChannels();
247
248	/**
249	* Throws an exception if the specified file is not found or
250	* if directory is specified.
251	*/
252	static void VerifyFile(String Filename);
253
254	static std::map<int,String> bufferedNotifies;
255	static Mutex NotifyMutex;
256	static Mutex NotifyBufferMutex;
257	static bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
258	static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
259	static std::vector<yyparse_param_t> Sessions;
260	static Mutex SubscriptionMutex;
261	static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
262	static fd_set fdSet;
263
264	//Protect main thread that generates real time notify messages
265	//like voice count, stream count and buffer fill
266	//from LSCP server removing engines and channels from underneath
267	static Mutex RTNotifyMutex;
268
269	class EventHandler : public ChannelCountListener, public AudioDeviceCountListener,
270	public MidiDeviceCountListener, public MidiInstrumentCountListener,
271	public MidiInstrumentInfoListener, public MidiInstrumentMapCountListener,
272	public MidiInstrumentMapInfoListener, public FxSendCountListener,
273	public VoiceCountListener, public StreamCountListener, public BufferFillListener,
274	public TotalStreamCountListener, public TotalVoiceCountListener,
275	public EngineChangeListener {
276
277	public:
278	EventHandler(LSCPServer* pParent);
279
280	/**
281	* Invoked when the number of sampler channels has changed.
282	* @param NewCount The new number of sampler channels.
283	*/
284	virtual void ChannelCountChanged(int NewCount);
285	virtual void ChannelAdded(SamplerChannel* pChannel);
286	virtual void ChannelToBeRemoved(SamplerChannel* pChannel);
287
288	/**
289	* Invoked when the number of audio output devices has changed.
290	* @param NewCount The new number of audio output devices.
291	*/
292	virtual void AudioDeviceCountChanged(int NewCount);
293
294	/**
295	* Invoked when the number of MIDI input devices has changed.
296	* @param NewCount The new number of MIDI input devices.
297	*/
298	virtual void MidiDeviceCountChanged(int NewCount);
299
300	/**
301	* Invoked when the number of MIDI instruments has changed.
302	* @param MapId The numerical ID of the MIDI instrument map.
303	* @param NewCount The new number of MIDI instruments.
304	*/
305	virtual void MidiInstrumentCountChanged(int MapId, int NewCount);
306
307	/**
308	* Invoked when a MIDI instrument in a MIDI instrument map is changed.
309	* @param MapId The numerical ID of the MIDI instrument map.
310	* @param Bank The index of the MIDI bank, containing the instrument.
311	* @param Program The MIDI program number of the instrument.
312	*/
313	virtual void MidiInstrumentInfoChanged(int MapId, int Bank, int Program);
314
315	/**
316	* Invoked when the number of MIDI instrument maps has changed.
317	* @param NewCount The new number of MIDI instruments.
318	*/
319	virtual void MidiInstrumentMapCountChanged(int NewCount);
320
321	/**
322	* Invoked when the settings of a MIDI instrument map are changed.
323	* @param MapId The numerical ID of the MIDI instrument map.
324	*/
325	virtual void MidiInstrumentMapInfoChanged(int MapId);
326
327	/**
328	* Invoked when the number of effect sends
329	* on the specified sampler channel has changed.
330	* @param ChannelId The numerical ID of the sampler channel.
331	* @param NewCount The new number of effect sends.
332	*/
333	virtual void FxSendCountChanged(int ChannelId, int NewCount);
334
335	/**
336	* Invoked when the number of active voices
337	* on the specified sampler channel has changed.
338	* @param ChannelId The numerical ID of the sampler channel.
339	* @param NewCount The new number of active voices.
340	*/
341	virtual void VoiceCountChanged(int ChannelId, int NewCount);
342
343	/**
344	* Invoked when the number of active disk streams
345	* on the specified sampler channel has changed.
346	* @param ChannelId The numerical ID of the sampler channel.
347	* @param NewCount The new number of active disk streams.
348	*/
349	virtual void StreamCountChanged(int ChannelId, int NewCount);
350
351	/**
352	* Invoked when the fill state of the disk stream
353	* buffers on the specified sampler channel is changed.
354	* @param ChannelId The numerical ID of the sampler channel.
355	* @param FillData The buffer fill data for the specified sampler channel.
356	*/
357	virtual void BufferFillChanged(int ChannelId, String FillData);
358
359	/**
360	* Invoked when the total number of active voices is changed.
361	* @param NewCount The new number of active voices.
362	*/
363	virtual void TotalVoiceCountChanged(int NewCount);
364	virtual void TotalStreamCountChanged(int NewCount);
365
366	virtual void EngineToBeChanged(int ChannelId);
367	virtual void EngineChanged(int ChannelId);
368
369	virtual ~EventHandler();
370
371	struct midi_listener_entry {
372	SamplerChannel* pSamplerChannel;
373	EngineChannel* pEngineChannel;
374	VirtualMidiDevice* pMidiListener;
375	};
376
377	std::vector<midi_listener_entry> channelMidiListeners;
378
379	private:
380	LSCPServer* pParent;
381	} eventHandler;
382
383	#if HAVE_SQLITE3
384	class DbInstrumentsEventHandler : public InstrumentsDb::Listener {
385	public:
386	virtual void DirectoryCountChanged(String Dir);
387	virtual void DirectoryInfoChanged(String Dir);
388	virtual void DirectoryNameChanged(String Dir, String NewName);
389	virtual void InstrumentCountChanged(String Dir);
390	virtual void InstrumentInfoChanged(String Instr);
391	virtual void InstrumentNameChanged(String Instr, String NewName);
392	virtual void JobStatusChanged(int JobId);
393	} dbInstrumentsEventHandler;
394	#endif // HAVE_SQLITE3
395	};
396
397	#endif // __LSCPSERVER_H_