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);
        void RemoveListeners();

        // 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 SetFxSendEffect(uint uiSamplerChannel, uint FxSendID, int iSendEffectChain, int iEffectChainPosition);

        // effect commands
        String GetAvailableEffects();
        String ListAvailableEffects();
        String GetEffectInfo(int iEffectIndex);
        String CreateEffectInstance(int iEffectIndex);
        String CreateEffectInstance(String effectSystem, String module, String effectName);
        String DestroyEffectInstance(int iEffectInstance);
        String GetEffectInstances();
        String ListEffectInstances();
        String GetEffectInstanceInfo(int iEffectInstance);
        String GetEffectInstanceInputControlInfo(int iEffectInstance, int iInputControlIndex);
        String SetEffectInstanceInputControlValue(int iEffectInstance, int iInputControlIndex, double dValue);
        String GetSendEffectChains(int iAudioOutputDevice);
        String ListSendEffectChains(int iAudioOutputDevice);
        String AddSendEffectChain(int iAudioOutputDevice);
        String RemoveSendEffectChain(int iAudioOutputDevice, int iSendEffectChain);
        String GetSendEffectChainInfo(int iAudioOutputDevice, int iSendEffectChain);
        String AppendSendEffectChainEffect(int iAudioOutputDevice, int iSendEffectChain, int iEffectInstance);
        String InsertSendEffectChainEffect(int iAudioOutputDevice, int iSendEffectChain, int iEffectChainPosition, int iEffectInstance);
        String RemoveSendEffectChainEffect(int iAudioOutputDevice, int iSendEffectChain, int iEffectChainPosition);

        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);
        void   CloseAllConnections();

        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	void RemoveListeners();
83
84	// Methods called by the parser
85	String DestroyAudioOutputDevice(uint DeviceIndex);
86	String DestroyMidiInputDevice(uint DeviceIndex);
87	String LoadInstrument(String Filename, uint uiInstrument, uint uiSamplerChannel, bool bBackground = false);
88	String SetEngineType(String EngineName, uint uiSamplerChannel);
89	String GetChannels();
90	String ListChannels();
91	String AddChannel();
92	String RemoveChannel(uint uiSamplerChannel);
93	String GetAvailableEngines();
94	String ListAvailableEngines();
95	String GetEngineInfo(String EngineName);
96	String GetChannelInfo(uint uiSamplerChannel);
97	String GetVoiceCount(uint uiSamplerChannel);
98	String GetStreamCount(uint uiSamplerChannel);
99	String GetBufferFill(fill_response_t ResponseType, uint uiSamplerChannel);
100	String GetAvailableAudioOutputDrivers();
101	String ListAvailableAudioOutputDrivers();
102	String GetAvailableMidiInputDrivers();
103	String ListAvailableMidiInputDrivers();
104	String GetAudioOutputDriverInfo(String Driver);
105	String GetMidiInputDriverInfo(String Driver);
106	#ifdef __GNUC__
107	typedef std::map<String,String> StringMap; // nasty workaround for a GCC bug (see GCC bug #15980, #57)
108	String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
109	String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
110	String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = StringMap());
111	String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = StringMap());
112	#else
113	String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
114	String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
115	String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
116	String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
117	#endif // __GNUC__
118	String GetAudioOutputDeviceCount();
119	String GetMidiInputDeviceCount();
120	String GetAudioOutputDevices();
121	String GetMidiInputDevices();
122	String GetAudioOutputDeviceInfo(uint DeviceIndex);
123	String GetMidiInputDeviceInfo(uint DeviceIndex);
124	String GetMidiInputPortInfo(uint DeviceIndex, uint PortIndex);
125	String GetMidiInputPortParameterInfo(uint DeviceId, uint PortId, String ParameterName);
126	String GetAudioOutputChannelInfo(uint DeviceId, uint ChannelId);
127	String GetAudioOutputChannelParameterInfo(uint DeviceId, uint ChannelId, String ParameterName);
128	String SetAudioOutputChannelParameter(uint DeviceId, uint ChannelId, String ParamKey, String ParamVal);
129	String SetAudioOutputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
130	String SetMidiInputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
131	String SetMidiInputPortParameter(uint DeviceIndex, uint PortIndex, String ParamKey, String ParamVal);
132	String SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel);
133	String SetAudioOutputDevice(uint AudioDeviceId, uint SamplerChannel);
134	String SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel);
135	String SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel);
136	String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);
137	String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);
138	String SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel);
139	String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);
140	String SetVolume(double dVolume, uint uiSamplerChannel);
141	String SetChannelMute(bool bMute, uint uiSamplerChannel);
142	String SetChannelSolo(bool bSolo, uint uiSamplerChannel);
143	String AddOrReplaceMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg, String EngineType, String InstrumentFile, uint InstrumentIndex, float Volume, MidiInstrumentMapper::mode_t LoadMode, String Name, bool bModal);
144	String RemoveMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
145	String GetMidiInstrumentMappings(uint MidiMapID);
146	String GetAllMidiInstrumentMappings();
147	String GetMidiInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
148	String ListMidiInstrumentMappings(uint MidiMapID);
149	String ListAllMidiInstrumentMappings();
150	String ClearMidiInstrumentMappings(uint MidiMapID);
151	String ClearAllMidiInstrumentMappings();
152	String AddMidiInstrumentMap(String MapName = "");
153	String RemoveMidiInstrumentMap(uint MidiMapID);
154	String RemoveAllMidiInstrumentMaps();
155	String GetMidiInstrumentMaps();
156	String ListMidiInstrumentMaps();
157	String GetMidiInstrumentMap(uint MidiMapID);
158	String SetMidiInstrumentMapName(uint MidiMapID, String NewName);
159	String SetChannelMap(uint uiSamplerChannel, int MidiMapID);
160	String CreateFxSend(uint uiSamplerChannel, uint MidiCtrl, String Name = "");
161	String DestroyFxSend(uint uiSamplerChannel, uint FxSendID);
162	String GetFxSends(uint uiSamplerChannel);
163	String ListFxSends(uint uiSamplerChannel);
164	String GetFxSendInfo(uint uiSamplerChannel, uint FxSendID);
165	String SetFxSendName(uint uiSamplerChannel, uint FxSendID, String Name);
166	String SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel);
167	String SetFxSendMidiController(uint uiSamplerChannel, uint FxSendID, uint MidiController);
168	String SetFxSendLevel(uint uiSamplerChannel, uint FxSendID, double dLevel);
169	String SetFxSendEffect(uint uiSamplerChannel, uint FxSendID, int iSendEffectChain, int iEffectChainPosition);
170
171	// effect commands
172	String GetAvailableEffects();
173	String ListAvailableEffects();
174	String GetEffectInfo(int iEffectIndex);
175	String CreateEffectInstance(int iEffectIndex);
176	String CreateEffectInstance(String effectSystem, String module, String effectName);
177	String DestroyEffectInstance(int iEffectInstance);
178	String GetEffectInstances();
179	String ListEffectInstances();
180	String GetEffectInstanceInfo(int iEffectInstance);
181	String GetEffectInstanceInputControlInfo(int iEffectInstance, int iInputControlIndex);
182	String SetEffectInstanceInputControlValue(int iEffectInstance, int iInputControlIndex, double dValue);
183	String GetSendEffectChains(int iAudioOutputDevice);
184	String ListSendEffectChains(int iAudioOutputDevice);
185	String AddSendEffectChain(int iAudioOutputDevice);
186	String RemoveSendEffectChain(int iAudioOutputDevice, int iSendEffectChain);
187	String GetSendEffectChainInfo(int iAudioOutputDevice, int iSendEffectChain);
188	String AppendSendEffectChainEffect(int iAudioOutputDevice, int iSendEffectChain, int iEffectInstance);
189	String InsertSendEffectChainEffect(int iAudioOutputDevice, int iSendEffectChain, int iEffectChainPosition, int iEffectInstance);
190	String RemoveSendEffectChainEffect(int iAudioOutputDevice, int iSendEffectChain, int iEffectChainPosition);
191
192	String AddDbInstrumentDirectory(String Dir);
193	String RemoveDbInstrumentDirectory(String Dir, bool Force = false);
194	String GetDbInstrumentDirectoryCount(String Dir, bool Recursive = false);
195	String GetDbInstrumentDirectories(String Dir, bool Recursive = false);
196	String GetDbInstrumentDirectoryInfo(String Dir);
197	String SetDbInstrumentDirectoryName(String Dir, String Name);
198	String MoveDbInstrumentDirectory(String Dir, String Dst);
199	String CopyDbInstrumentDirectory(String Dir, String Dst);
200	String SetDbInstrumentDirectoryDescription(String Dir, String Desc);
201	String FindDbInstrumentDirectories(String Dir, std::map<String,String> Parameters, bool Recursive = true);
202	String AddDbInstruments(String DbDir, String FilePath, int Index = -1, bool bBackground = false);
203	String AddDbInstruments(String ScanMode, String DbDir, String FsDir, bool bBackground = false, bool insDir = false);
204	String RemoveDbInstrument(String Instr);
205	String GetDbInstrumentCount(String Dir, bool Recursive = false);
206	String GetDbInstruments(String Dir, bool Recursive = false);
207	String GetDbInstrumentInfo(String Instr);
208	String SetDbInstrumentName(String Instr, String Name);
209	String MoveDbInstrument(String Instr, String Dst);
210	String CopyDbInstrument(String Instr, String Dst);
211	String SetDbInstrumentDescription(String Instr, String Desc);
212	String SetDbInstrumentFilePath(String OldPath, String NewPath);
213	String FindLostDbInstrumentFiles();
214	String FindDbInstruments(String Dir, std::map<String,String> Parameters, bool Recursive = true);
215	String FormatInstrumentsDb();
216	String EditSamplerChannelInstrument(uint uiSamplerChannel);
217	String GetDbInstrumentsJobInfo(int JobId);
218	String ResetChannel(uint uiSamplerChannel);
219	String ResetSampler();
220	String GetServerInfo();
221	String GetTotalStreamCount();
222	String GetTotalVoiceCount();
223	String GetTotalVoiceCountMax();
224	String GetGlobalMaxVoices();
225	String SetGlobalMaxVoices(int iVoices);
226	String GetGlobalMaxStreams();
227	String SetGlobalMaxStreams(int iStreams);
228	String GetGlobalVolume();
229	String SetGlobalVolume(double dVolume);
230	String GetFileInstruments(String Filename);
231	String ListFileInstruments(String Filename);
232	String GetFileInstrumentInfo(String Filename, uint InstrumentID);
233	String SendChannelMidiData(String MidiMsg, uint uiSamplerChannel, uint Arg1, uint Arg2);
234	String SubscribeNotification(LSCPEvent::event_t);
235	String UnsubscribeNotification(LSCPEvent::event_t);
236	String SetEcho(yyparse_param_t* pSession, double boolean_value);
237	void AnswerClient(String ReturnMessage);
238	void CloseAllConnections();
239
240	static int currentSocket;
241	static std::map<int,String> bufferedCommands;
242
243	static void SendLSCPNotify( LSCPEvent Event );
244	static int EventSubscribers( std::list<LSCPEvent::event_t> events );
245	static void LockRTNotify();
246	static void UnlockRTNotify();
247	static String FilterEndlines(String s);
248
249	protected:
250	int hSocket;
251	sockaddr_in SocketAddress;
252	Sampler* pSampler;
253	Condition Initialized;
254
255	int Main(); ///< Implementation of virtual method from class Thread
256
257	private:
258
259	/**
260	* Find a created audio output device index.
261	*/
262	int GetAudioOutputDeviceIndex (AudioOutputDevice *pDevice);
263
264	/**
265	* Find a created midi input device index.
266	*/
267	int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
268
269	EngineChannel* GetEngineChannel(uint uiSamplerChannel);
270
271	/**
272	* Gets the specified effect send on the specified sampler channel.
273	*/
274	FxSend* GetFxSend(uint uiSamplerChannel, uint FxSendID);
275
276	bool HasSoloChannel();
277	void MuteNonSoloChannels();
278	void UnmuteChannels();
279
280	/**
281	* Throws an exception if the specified file is not found or
282	* if directory is specified.
283	*/
284	static void VerifyFile(String Filename);
285
286	static std::map<int,String> bufferedNotifies;
287	static Mutex NotifyMutex;
288	static Mutex NotifyBufferMutex;
289	static bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
290	static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
291	static std::vector<yyparse_param_t> Sessions;
292	static Mutex SubscriptionMutex;
293	static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
294	static fd_set fdSet;
295
296	//Protect main thread that generates real time notify messages
297	//like voice count, stream count and buffer fill
298	//from LSCP server removing engines and channels from underneath
299	static Mutex RTNotifyMutex;
300
301	class EventHandler : public ChannelCountListener, public AudioDeviceCountListener,
302	public MidiDeviceCountListener, public MidiInstrumentCountListener,
303	public MidiInstrumentInfoListener, public MidiInstrumentMapCountListener,
304	public MidiInstrumentMapInfoListener, public FxSendCountListener,
305	public VoiceCountListener, public StreamCountListener, public BufferFillListener,
306	public TotalStreamCountListener, public TotalVoiceCountListener,
307	public EngineChangeListener, public MidiPortCountListener {
308
309	public:
310	EventHandler(LSCPServer* pParent);
311
312	/**
313	* Invoked when the number of sampler channels has changed.
314	* @param NewCount The new number of sampler channels.
315	*/
316	virtual void ChannelCountChanged(int NewCount);
317	virtual void ChannelAdded(SamplerChannel* pChannel);
318	virtual void ChannelToBeRemoved(SamplerChannel* pChannel);
319
320	/**
321	* Invoked when the number of audio output devices has changed.
322	* @param NewCount The new number of audio output devices.
323	*/
324	virtual void AudioDeviceCountChanged(int NewCount);
325
326	/**
327	* Invoked when the number of MIDI input devices has changed.
328	* @param NewCount The new number of MIDI input devices.
329	*/
330	virtual void MidiDeviceCountChanged(int NewCount);
331
332	/**
333	* Invoked right before the supplied MIDI input device is going
334	* to be destroyed.
335	* @param pDevice MidiInputDevice to be deleted
336	*/
337	virtual void MidiDeviceToBeDestroyed(MidiInputDevice* pDevice);
338
339	/**
340	* Invoked to inform that a new MidiInputDevice has just been
341	* created.
342	* @param pDevice newly created MidiInputDevice
343	*/
344	virtual void MidiDeviceCreated(MidiInputDevice* pDevice);
345
346	/**
347	* Invoked when the number of MIDI input ports has changed.
348	* @param NewCount The new number of MIDI input ports.
349	*/
350	virtual void MidiPortCountChanged(int NewCount);
351
352	/**
353	* Invoked right before the supplied MIDI input port is going
354	* to be destroyed.
355	* @param pPort MidiInputPort to be deleted
356	*/
357	virtual void MidiPortToBeRemoved(MidiInputPort* pPort);
358
359	/**
360	* Invoked to inform that a new MidiInputPort has just been
361	* added.
362	* @param pPort newly created MidiInputPort
363	*/
364	virtual void MidiPortAdded(MidiInputPort* pPort);
365
366	/**
367	* Invoked when the number of MIDI instruments has changed.
368	* @param MapId The numerical ID of the MIDI instrument map.
369	* @param NewCount The new number of MIDI instruments.
370	*/
371	virtual void MidiInstrumentCountChanged(int MapId, int NewCount);
372
373	/**
374	* Invoked when a MIDI instrument in a MIDI instrument map is changed.
375	* @param MapId The numerical ID of the MIDI instrument map.
376	* @param Bank The index of the MIDI bank, containing the instrument.
377	* @param Program The MIDI program number of the instrument.
378	*/
379	virtual void MidiInstrumentInfoChanged(int MapId, int Bank, int Program);
380
381	/**
382	* Invoked when the number of MIDI instrument maps has changed.
383	* @param NewCount The new number of MIDI instruments.
384	*/
385	virtual void MidiInstrumentMapCountChanged(int NewCount);
386
387	/**
388	* Invoked when the settings of a MIDI instrument map are changed.
389	* @param MapId The numerical ID of the MIDI instrument map.
390	*/
391	virtual void MidiInstrumentMapInfoChanged(int MapId);
392
393	/**
394	* Invoked when the number of effect sends
395	* on the specified sampler channel has changed.
396	* @param ChannelId The numerical ID of the sampler channel.
397	* @param NewCount The new number of effect sends.
398	*/
399	virtual void FxSendCountChanged(int ChannelId, int NewCount);
400
401	/**
402	* Invoked when the number of active voices
403	* on the specified sampler channel has changed.
404	* @param ChannelId The numerical ID of the sampler channel.
405	* @param NewCount The new number of active voices.
406	*/
407	virtual void VoiceCountChanged(int ChannelId, int NewCount);
408
409	/**
410	* Invoked when the number of active disk streams
411	* on the specified sampler channel has changed.
412	* @param ChannelId The numerical ID of the sampler channel.
413	* @param NewCount The new number of active disk streams.
414	*/
415	virtual void StreamCountChanged(int ChannelId, int NewCount);
416
417	/**
418	* Invoked when the fill state of the disk stream
419	* buffers on the specified sampler channel is changed.
420	* @param ChannelId The numerical ID of the sampler channel.
421	* @param FillData The buffer fill data for the specified sampler channel.
422	*/
423	virtual void BufferFillChanged(int ChannelId, String FillData);
424
425	/**
426	* Invoked when the total number of active voices is changed.
427	* @param NewCount The new number of active voices.
428	*/
429	virtual void TotalVoiceCountChanged(int NewCount);
430	virtual void TotalStreamCountChanged(int NewCount);
431
432	virtual void EngineToBeChanged(int ChannelId);
433	virtual void EngineChanged(int ChannelId);
434
435	virtual ~EventHandler();
436
437	struct midi_listener_entry {
438	SamplerChannel* pSamplerChannel;
439	EngineChannel* pEngineChannel;
440	VirtualMidiDevice* pMidiListener;
441	};
442
443	std::vector<midi_listener_entry> channelMidiListeners;
444
445	struct device_midi_listener_entry {
446	MidiInputPort* pPort;
447	VirtualMidiDevice* pMidiListener;
448	uint uiDeviceID;
449	};
450
451	std::vector<device_midi_listener_entry> deviceMidiListeners;
452
453	private:
454	LSCPServer* pParent;
455	} eventHandler;
456
457	#if HAVE_SQLITE3
458	class DbInstrumentsEventHandler : public InstrumentsDb::Listener {
459	public:
460	virtual void DirectoryCountChanged(String Dir);
461	virtual void DirectoryInfoChanged(String Dir);
462	virtual void DirectoryNameChanged(String Dir, String NewName);
463	virtual void InstrumentCountChanged(String Dir);
464	virtual void InstrumentInfoChanged(String Instr);
465	virtual void InstrumentNameChanged(String Instr, String NewName);
466	virtual void JobStatusChanged(int JobId);
467	} dbInstrumentsEventHandler;
468	#endif // HAVE_SQLITE3
469	};
470
471	}
472
473	#endif // __LSCPSERVER_H_