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 "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

// External references to the main scanner and parser functions
extern int yyparse(void* YYPARSE_PARAM);

namespace LinuxSampler {

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, bool insDir = 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 SetDbInstrumentFilePath(String OldPath, String NewPath);
        String FindLostDbInstrumentFiles();
        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 GetGlobalMaxVoices();
        String SetGlobalMaxVoices(int iVoices);
        String GetGlobalMaxStreams();
        String SetGlobalMaxStreams(int iStreams);
        String GetGlobalVolume();
        String SetGlobalVolume(double dVolume);
        String GetFileInstruments(String Filename);
        String ListFileInstruments(String Filename);
        String GetFileInstrumentInfo(String Filename, uint InstrumentID);
        String SendChannelMidiData(String MidiMsg, uint uiSamplerChannel, uint Arg1, uint Arg2);
        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 MidiPortCountListener {

            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 right before the supplied MIDI input device is going
                 * to be destroyed.
                 * @param pDevice MidiInputDevice to be deleted
                 */
                virtual void MidiDeviceToBeDestroyed(MidiInputDevice* pDevice);

                /**
                 * Invoked to inform that a new MidiInputDevice has just been
                 * created.
                 * @param pDevice newly created MidiInputDevice
                 */
                virtual void MidiDeviceCreated(MidiInputDevice* pDevice);

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

                /**
                 * Invoked right before the supplied MIDI input port is going
                 * to be destroyed.
                 * @param pPort MidiInputPort to be deleted
                 */
                virtual void MidiPortToBeRemoved(MidiInputPort* pPort);

                /**
                 * Invoked to inform that a new MidiInputPort has just been
                 * added.
                 * @param pPort newly created MidiInputPort
                 */
                virtual void MidiPortAdded(MidiInputPort* pPort);

                /**
                 * 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;

                struct device_midi_listener_entry {
                    MidiInputPort* pPort;
                    VirtualMidiDevice* pMidiListener;
                    uint uiDeviceID;
                };

                std::vector<device_midi_listener_entry> deviceMidiListeners;

            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 "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
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, bool insDir = 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 SetDbInstrumentFilePath(String OldPath, String NewPath);
189	String FindLostDbInstrumentFiles();
190	String FindDbInstruments(String Dir, std::map<String,String> Parameters, bool Recursive = true);
191	String FormatInstrumentsDb();
192	String EditSamplerChannelInstrument(uint uiSamplerChannel);
193	String GetDbInstrumentsJobInfo(int JobId);
194	String ResetChannel(uint uiSamplerChannel);
195	String ResetSampler();
196	String GetServerInfo();
197	String GetTotalStreamCount();
198	String GetTotalVoiceCount();
199	String GetTotalVoiceCountMax();
200	String GetGlobalMaxVoices();
201	String SetGlobalMaxVoices(int iVoices);
202	String GetGlobalMaxStreams();
203	String SetGlobalMaxStreams(int iStreams);
204	String GetGlobalVolume();
205	String SetGlobalVolume(double dVolume);
206	String GetFileInstruments(String Filename);
207	String ListFileInstruments(String Filename);
208	String GetFileInstrumentInfo(String Filename, uint InstrumentID);
209	String SendChannelMidiData(String MidiMsg, uint uiSamplerChannel, uint Arg1, uint Arg2);
210	String SubscribeNotification(LSCPEvent::event_t);
211	String UnsubscribeNotification(LSCPEvent::event_t);
212	String SetEcho(yyparse_param_t* pSession, double boolean_value);
213	void AnswerClient(String ReturnMessage);
214
215	static int currentSocket;
216	static std::map<int,String> bufferedCommands;
217
218	static void SendLSCPNotify( LSCPEvent Event );
219	static int EventSubscribers( std::list<LSCPEvent::event_t> events );
220	static void LockRTNotify();
221	static void UnlockRTNotify();
222	static String FilterEndlines(String s);
223
224	protected:
225	int hSocket;
226	sockaddr_in SocketAddress;
227	Sampler* pSampler;
228	Condition Initialized;
229
230	int Main(); ///< Implementation of virtual method from class Thread
231
232	private:
233
234	/**
235	* Find a created audio output device index.
236	*/
237	int GetAudioOutputDeviceIndex (AudioOutputDevice *pDevice);
238
239	/**
240	* Find a created midi input device index.
241	*/
242	int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
243
244	EngineChannel* GetEngineChannel(uint uiSamplerChannel);
245
246	/**
247	* Gets the specified effect send on the specified sampler channel.
248	*/
249	FxSend* GetFxSend(uint uiSamplerChannel, uint FxSendID);
250
251	bool HasSoloChannel();
252	void MuteNonSoloChannels();
253	void UnmuteChannels();
254
255	/**
256	* Throws an exception if the specified file is not found or
257	* if directory is specified.
258	*/
259	static void VerifyFile(String Filename);
260
261	static std::map<int,String> bufferedNotifies;
262	static Mutex NotifyMutex;
263	static Mutex NotifyBufferMutex;
264	static bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
265	static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
266	static std::vector<yyparse_param_t> Sessions;
267	static Mutex SubscriptionMutex;
268	static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
269	static fd_set fdSet;
270
271	//Protect main thread that generates real time notify messages
272	//like voice count, stream count and buffer fill
273	//from LSCP server removing engines and channels from underneath
274	static Mutex RTNotifyMutex;
275
276	class EventHandler : public ChannelCountListener, public AudioDeviceCountListener,
277	public MidiDeviceCountListener, public MidiInstrumentCountListener,
278	public MidiInstrumentInfoListener, public MidiInstrumentMapCountListener,
279	public MidiInstrumentMapInfoListener, public FxSendCountListener,
280	public VoiceCountListener, public StreamCountListener, public BufferFillListener,
281	public TotalStreamCountListener, public TotalVoiceCountListener,
282	public EngineChangeListener, public MidiPortCountListener {
283
284	public:
285	EventHandler(LSCPServer* pParent);
286
287	/**
288	* Invoked when the number of sampler channels has changed.
289	* @param NewCount The new number of sampler channels.
290	*/
291	virtual void ChannelCountChanged(int NewCount);
292	virtual void ChannelAdded(SamplerChannel* pChannel);
293	virtual void ChannelToBeRemoved(SamplerChannel* pChannel);
294
295	/**
296	* Invoked when the number of audio output devices has changed.
297	* @param NewCount The new number of audio output devices.
298	*/
299	virtual void AudioDeviceCountChanged(int NewCount);
300
301	/**
302	* Invoked when the number of MIDI input devices has changed.
303	* @param NewCount The new number of MIDI input devices.
304	*/
305	virtual void MidiDeviceCountChanged(int NewCount);
306
307	/**
308	* Invoked right before the supplied MIDI input device is going
309	* to be destroyed.
310	* @param pDevice MidiInputDevice to be deleted
311	*/
312	virtual void MidiDeviceToBeDestroyed(MidiInputDevice* pDevice);
313
314	/**
315	* Invoked to inform that a new MidiInputDevice has just been
316	* created.
317	* @param pDevice newly created MidiInputDevice
318	*/
319	virtual void MidiDeviceCreated(MidiInputDevice* pDevice);
320
321	/**
322	* Invoked when the number of MIDI input ports has changed.
323	* @param NewCount The new number of MIDI input ports.
324	*/
325	virtual void MidiPortCountChanged(int NewCount);
326
327	/**
328	* Invoked right before the supplied MIDI input port is going
329	* to be destroyed.
330	* @param pPort MidiInputPort to be deleted
331	*/
332	virtual void MidiPortToBeRemoved(MidiInputPort* pPort);
333
334	/**
335	* Invoked to inform that a new MidiInputPort has just been
336	* added.
337	* @param pPort newly created MidiInputPort
338	*/
339	virtual void MidiPortAdded(MidiInputPort* pPort);
340
341	/**
342	* Invoked when the number of MIDI instruments has changed.
343	* @param MapId The numerical ID of the MIDI instrument map.
344	* @param NewCount The new number of MIDI instruments.
345	*/
346	virtual void MidiInstrumentCountChanged(int MapId, int NewCount);
347
348	/**
349	* Invoked when a MIDI instrument in a MIDI instrument map is changed.
350	* @param MapId The numerical ID of the MIDI instrument map.
351	* @param Bank The index of the MIDI bank, containing the instrument.
352	* @param Program The MIDI program number of the instrument.
353	*/
354	virtual void MidiInstrumentInfoChanged(int MapId, int Bank, int Program);
355
356	/**
357	* Invoked when the number of MIDI instrument maps has changed.
358	* @param NewCount The new number of MIDI instruments.
359	*/
360	virtual void MidiInstrumentMapCountChanged(int NewCount);
361
362	/**
363	* Invoked when the settings of a MIDI instrument map are changed.
364	* @param MapId The numerical ID of the MIDI instrument map.
365	*/
366	virtual void MidiInstrumentMapInfoChanged(int MapId);
367
368	/**
369	* Invoked when the number of effect sends
370	* on the specified sampler channel has changed.
371	* @param ChannelId The numerical ID of the sampler channel.
372	* @param NewCount The new number of effect sends.
373	*/
374	virtual void FxSendCountChanged(int ChannelId, int NewCount);
375
376	/**
377	* Invoked when the number of active voices
378	* on the specified sampler channel has changed.
379	* @param ChannelId The numerical ID of the sampler channel.
380	* @param NewCount The new number of active voices.
381	*/
382	virtual void VoiceCountChanged(int ChannelId, int NewCount);
383
384	/**
385	* Invoked when the number of active disk streams
386	* on the specified sampler channel has changed.
387	* @param ChannelId The numerical ID of the sampler channel.
388	* @param NewCount The new number of active disk streams.
389	*/
390	virtual void StreamCountChanged(int ChannelId, int NewCount);
391
392	/**
393	* Invoked when the fill state of the disk stream
394	* buffers on the specified sampler channel is changed.
395	* @param ChannelId The numerical ID of the sampler channel.
396	* @param FillData The buffer fill data for the specified sampler channel.
397	*/
398	virtual void BufferFillChanged(int ChannelId, String FillData);
399
400	/**
401	* Invoked when the total number of active voices is changed.
402	* @param NewCount The new number of active voices.
403	*/
404	virtual void TotalVoiceCountChanged(int NewCount);
405	virtual void TotalStreamCountChanged(int NewCount);
406
407	virtual void EngineToBeChanged(int ChannelId);
408	virtual void EngineChanged(int ChannelId);
409
410	virtual ~EventHandler();
411
412	struct midi_listener_entry {
413	SamplerChannel* pSamplerChannel;
414	EngineChannel* pEngineChannel;
415	VirtualMidiDevice* pMidiListener;
416	};
417
418	std::vector<midi_listener_entry> channelMidiListeners;
419
420	struct device_midi_listener_entry {
421	MidiInputPort* pPort;
422	VirtualMidiDevice* pMidiListener;
423	uint uiDeviceID;
424	};
425
426	std::vector<device_midi_listener_entry> deviceMidiListeners;
427
428	private:
429	LSCPServer* pParent;
430	} eventHandler;
431
432	#if HAVE_SQLITE3
433	class DbInstrumentsEventHandler : public InstrumentsDb::Listener {
434	public:
435	virtual void DirectoryCountChanged(String Dir);
436	virtual void DirectoryInfoChanged(String Dir);
437	virtual void DirectoryNameChanged(String Dir, String NewName);
438	virtual void InstrumentCountChanged(String Dir);
439	virtual void InstrumentInfoChanged(String Instr);
440	virtual void InstrumentNameChanged(String Instr, String NewName);
441	virtual void JobStatusChanged(int JobId);
442	} dbInstrumentsEventHandler;
443	#endif // HAVE_SQLITE3
444	};
445
446	}
447
448	#endif // __LSCPSERVER_H_