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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1135 - (hide annotations) (download) (as text)
Thu Mar 29 09:40:45 2007 UTC (13 years, 6 months ago) by iliev
File MIME type: text/x-c++hdr
File size: 15981 byte(s)
* Added new LSCP command - SET FX_SEND NAME
* The default map is now the first available map

1 schoenebeck 35 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 schoenebeck 56 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 1026 * Copyright (C) 2005 - 2007 Christian Schoenebeck *
7 schoenebeck 35 * *
8 schoenebeck 385 * This library is free software; you can redistribute it and/or modify *
9 schoenebeck 35 * it under the terms of the GNU General Public License as published by *
10     * the Free Software Foundation; either version 2 of the License, or *
11     * (at your option) any later version. *
12     * *
13 schoenebeck 385 * This library is distributed in the hope that it will be useful, *
14 schoenebeck 35 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16     * GNU General Public License for more details. *
17     * *
18     * You should have received a copy of the GNU General Public License *
19 schoenebeck 385 * along with this library; if not, write to the Free Software *
20 schoenebeck 35 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21     * MA 02111-1307 USA *
22     ***************************************************************************/
23    
24     #ifndef __LSCPSERVER_H_
25     #define __LSCPSERVER_H_
26    
27     #include <unistd.h>
28     #include <sys/types.h>
29     #include <sys/socket.h>
30 senkov 170 #include <sys/select.h>
31     #include <sys/time.h>
32 schoenebeck 35 #include <netinet/in.h>
33     #include <netinet/tcp.h>
34     #include <arpa/inet.h>
35     #include <netdb.h>
36    
37 senkov 170 #include <list>
38    
39 schoenebeck 53 #include "lscp.h"
40 schoenebeck 35 #include "lscpparser.h"
41 senkov 170 #include "lscp.h"
42     #include "lscpevent.h"
43 schoenebeck 53 #include "../Sampler.h"
44     #include "../common/Thread.h"
45 senkov 170 #include "../common/Mutex.h"
46 schoenebeck 211 #include "../common/Condition.h"
47 schoenebeck 35
48 schoenebeck 947 #include "../drivers/midi/MidiInstrumentMapper.h"
49    
50 schoenebeck 35 /// TCP Port on which the server should listen for connection requests.
51 senkov 667 #define LSCP_ADDR INADDR_ANY
52 schoenebeck 35 #define LSCP_PORT 8888
53    
54 schoenebeck 227 /// try up to 3 minutes to bind server socket
55     #define LSCP_SERVER_BIND_TIMEOUT 180
56    
57 schoenebeck 53 using namespace LinuxSampler;
58    
59 schoenebeck 35 // External references to the main scanner and parser functions
60     extern int yyparse(void* YYPARSE_PARAM);
61 schoenebeck 219 extern void restart(yyparse_param_t* pparam, int& yychar);
62 schoenebeck 35
63     /**
64     * Network server for the LinuxSampler Control Protocol (LSCP).
65     */
66     class LSCPServer : public Thread {
67     public:
68 senkov 667 LSCPServer(Sampler* pSampler, long int addr, short int port);
69 schoenebeck 475 virtual ~LSCPServer();
70 schoenebeck 211 int WaitUntilInitialized(long TimeoutSeconds = 0L, long TimeoutNanoSeconds = 0L);
71 schoenebeck 35
72     // Methods called by the parser
73 schoenebeck 123 String DestroyAudioOutputDevice(uint DeviceIndex);
74 senkov 155 String DestroyMidiInputDevice(uint DeviceIndex);
75 capela 137 String LoadInstrument(String Filename, uint uiInstrument, uint uiSamplerChannel, bool bBackground = false);
76 schoenebeck 411 String SetEngineType(String EngineName, uint uiSamplerChannel);
77 schoenebeck 35 String GetChannels();
78 schoenebeck 209 String ListChannels();
79 schoenebeck 35 String AddChannel();
80 schoenebeck 53 String RemoveChannel(uint uiSamplerChannel);
81 schoenebeck 35 String GetAvailableEngines();
82 capela 527 String ListAvailableEngines();
83 schoenebeck 35 String GetEngineInfo(String EngineName);
84 schoenebeck 53 String GetChannelInfo(uint uiSamplerChannel);
85     String GetVoiceCount(uint uiSamplerChannel);
86     String GetStreamCount(uint uiSamplerChannel);
87     String GetBufferFill(fill_response_t ResponseType, uint uiSamplerChannel);
88 schoenebeck 123 String GetAvailableAudioOutputDrivers();
89 capela 527 String ListAvailableAudioOutputDrivers();
90 senkov 155 String GetAvailableMidiInputDrivers();
91 capela 527 String ListAvailableMidiInputDrivers();
92 schoenebeck 123 String GetAudioOutputDriverInfo(String Driver);
93 senkov 155 String GetMidiInputDriverInfo(String Driver);
94 schoenebeck 123 #ifdef __GNUC__
95     typedef std::map<String,String> StringMap; // nasty workaround for a GCC bug (see GCC bug #15980, #57)
96     String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
97 senkov 155 String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
98 senkov 140 String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = StringMap());
99 senkov 155 String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = StringMap());
100 schoenebeck 123 #else
101     String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
102 senkov 155 String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
103 senkov 140 String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
104 senkov 155 String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
105 schoenebeck 123 #endif // __GNUC__
106     String GetAudioOutputDeviceCount();
107 senkov 155 String GetMidiInputDeviceCount();
108 schoenebeck 123 String GetAudioOutputDevices();
109 senkov 155 String GetMidiInputDevices();
110 schoenebeck 123 String GetAudioOutputDeviceInfo(uint DeviceIndex);
111 senkov 155 String GetMidiInputDeviceInfo(uint DeviceIndex);
112     String GetMidiInputPortInfo(uint DeviceIndex, uint PortIndex);
113 senkov 185 String GetMidiInputPortParameterInfo(uint DeviceId, uint PortId, String ParameterName);
114 schoenebeck 123 String GetAudioOutputChannelInfo(uint DeviceId, uint ChannelId);
115     String GetAudioOutputChannelParameterInfo(uint DeviceId, uint ChannelId, String ParameterName);
116     String SetAudioOutputChannelParameter(uint DeviceId, uint ChannelId, String ParamKey, String ParamVal);
117     String SetAudioOutputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
118 senkov 155 String SetMidiInputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
119 capela 159 String SetMidiInputPortParameter(uint DeviceIndex, uint PortIndex, String ParamKey, String ParamVal);
120 schoenebeck 123 String SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel);
121 capela 159 String SetAudioOutputDevice(uint AudioDeviceId, uint SamplerChannel);
122 capela 143 String SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel);
123 capela 159 String SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel);
124     String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);
125     String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);
126 schoenebeck 123 String SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel);
127 capela 159 String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);
128 schoenebeck 225 String SetVolume(double dVolume, uint uiSamplerChannel);
129 schoenebeck 705 String SetChannelMute(bool bMute, uint uiSamplerChannel);
130     String SetChannelSolo(bool bSolo, uint uiSamplerChannel);
131 schoenebeck 1047 String AddOrReplaceMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg, String EngineType, String InstrumentFile, uint InstrumentIndex, float Volume, MidiInstrumentMapper::mode_t LoadMode, String Name, bool bModal);
132 schoenebeck 973 String RemoveMIDIInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
133     String GetMidiInstrumentMappings(uint MidiMapID);
134     String GetAllMidiInstrumentMappings();
135     String GetMidiInstrumentMapping(uint MidiMapID, uint MidiBank, uint MidiProg);
136     String ListMidiInstrumentMappings(uint MidiMapID);
137     String ListAllMidiInstrumentMappings();
138     String ClearMidiInstrumentMappings(uint MidiMapID);
139     String ClearAllMidiInstrumentMappings();
140     String AddMidiInstrumentMap(String MapName = "");
141     String RemoveMidiInstrumentMap(uint MidiMapID);
142     String RemoveAllMidiInstrumentMaps();
143     String GetMidiInstrumentMaps();
144     String ListMidiInstrumentMaps();
145     String GetMidiInstrumentMap(uint MidiMapID);
146     String SetMidiInstrumentMapName(uint MidiMapID, String NewName);
147     String SetChannelMap(uint uiSamplerChannel, int MidiMapID);
148 schoenebeck 1001 String CreateFxSend(uint uiSamplerChannel, uint MidiCtrl, String Name = "");
149     String DestroyFxSend(uint uiSamplerChannel, uint FxSendID);
150     String GetFxSends(uint uiSamplerChannel);
151     String ListFxSends(uint uiSamplerChannel);
152     String GetFxSendInfo(uint uiSamplerChannel, uint FxSendID);
153 iliev 1135 String SetFxSendName(uint uiSamplerChannel, uint FxSendID, String Name);
154 schoenebeck 1001 String SetFxSendAudioOutputChannel(uint uiSamplerChannel, uint FxSendID, uint FxSendChannel, uint DeviceChannel);
155 schoenebeck 1026 String SetFxSendMidiController(uint uiSamplerChannel, uint FxSendID, uint MidiController);
156     String SetFxSendLevel(uint uiSamplerChannel, uint FxSendID, double dLevel);
157 schoenebeck 53 String ResetChannel(uint uiSamplerChannel);
158 schoenebeck 212 String ResetSampler();
159 schoenebeck 563 String GetServerInfo();
160 iliev 778 String GetTotalVoiceCount();
161     String GetTotalVoiceCountMax();
162 schoenebeck 1005 String GetGlobalVolume();
163     String SetGlobalVolume(double dVolume);
164 senkov 170 String SubscribeNotification(LSCPEvent::event_t);
165     String UnsubscribeNotification(LSCPEvent::event_t);
166 senkov 397 String QueryDatabase(String query);
167 schoenebeck 210 String SetEcho(yyparse_param_t* pSession, double boolean_value);
168 schoenebeck 35 void AnswerClient(String ReturnMessage);
169 senkov 170
170     static int currentSocket;
171     static std::map<int,String> bufferedCommands;
172 senkov 184
173     static void SendLSCPNotify( LSCPEvent Event );
174 senkov 360 static int EventSubscribers( std::list<LSCPEvent::event_t> events );
175     static void LockRTNotify( void ) { RTNotifyMutex.Lock(); }
176     static void UnlockRTNotify( void ) { RTNotifyMutex.Unlock(); }
177 senkov 184
178 schoenebeck 35 protected:
179 schoenebeck 53 int hSocket;
180     sockaddr_in SocketAddress;
181     Sampler* pSampler;
182 schoenebeck 211 Condition Initialized;
183 schoenebeck 35
184     int Main(); ///< Implementation of virtual method from class Thread
185 senkov 170
186 schoenebeck 35 private:
187 schoenebeck 209
188 schoenebeck 35 /**
189 capela 143 * Find a created audio output device index.
190     */
191     int GetAudioOutputDeviceIndex (AudioOutputDevice *pDevice);
192 schoenebeck 209
193 senkov 155 /**
194     * Find a created midi input device index.
195     */
196     int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
197 capela 143
198 iliev 1135 EngineChannel* GetEngineChannel(uint uiSamplerChannel);
199    
200     /**
201     * Gets the specified effect send on the specified sampler channel.
202     */
203     FxSend* GetFxSend(uint uiSamplerChannel, uint FxSendID);
204    
205 schoenebeck 705 bool HasSoloChannel();
206     void MuteNonSoloChannels();
207     void UnmuteChannels();
208    
209 senkov 170 static std::map<int,String> bufferedNotifies;
210     static Mutex NotifyMutex;
211     static Mutex NotifyBufferMutex;
212 schoenebeck 210 static bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
213     static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
214     static std::vector<yyparse_param_t> Sessions;
215 senkov 170 static Mutex SubscriptionMutex;
216     static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
217     static fd_set fdSet;
218 senkov 360
219     //Protect main thread that generates real time notify messages
220     //like voice count, stream count and buffer fill
221     //from LSCP server removing engines and channels from underneath
222     static Mutex RTNotifyMutex;
223 iliev 1130
224 iliev 1133 class EventHandler : public ChannelCountListener, public AudioDeviceCountListener,
225     public MidiDeviceCountListener, public MidiInstrumentCountListener,
226     public MidiInstrumentInfoListener, public MidiInstrumentMapCountListener,
227     public MidiInstrumentMapInfoListener, public FxSendCountListener,
228     public VoiceCountListener, public StreamCountListener,
229     public BufferFillListener, public TotalVoiceCountListener {
230    
231     public:
232 iliev 1130 /**
233     * Invoked when the number of sampler channels has changed.
234     * @param NewCount The new number of sampler channels.
235     */
236     virtual void ChannelCountChanged(int NewCount);
237    
238     /**
239     * Invoked when the number of audio output devices has changed.
240     * @param NewCount The new number of audio output devices.
241     */
242     virtual void AudioDeviceCountChanged(int NewCount);
243 iliev 1133
244 iliev 1130 /**
245     * Invoked when the number of MIDI input devices has changed.
246     * @param NewCount The new number of MIDI input devices.
247     */
248     virtual void MidiDeviceCountChanged(int NewCount);
249 iliev 1133
250 iliev 1130 /**
251     * Invoked when the number of MIDI instruments has changed.
252     * @param MapId The numerical ID of the MIDI instrument map.
253     * @param NewCount The new number of MIDI instruments.
254     */
255     virtual void MidiInstrumentCountChanged(int MapId, int NewCount);
256 iliev 1133
257 iliev 1130 /**
258     * Invoked when a MIDI instrument in a MIDI instrument map is changed.
259     * @param MapId The numerical ID of the MIDI instrument map.
260     * @param Bank The index of the MIDI bank, containing the instrument.
261     * @param Program The MIDI program number of the instrument.
262     */
263     virtual void MidiInstrumentInfoChanged(int MapId, int Bank, int Program);
264 iliev 1133
265     /**
266 iliev 1130 * Invoked when the number of MIDI instrument maps has changed.
267     * @param NewCount The new number of MIDI instruments.
268     */
269     virtual void MidiInstrumentMapCountChanged(int NewCount);
270    
271     /**
272     * Invoked when the settings of a MIDI instrument map are changed.
273     * @param MapId The numerical ID of the MIDI instrument map.
274     */
275     virtual void MidiInstrumentMapInfoChanged(int MapId);
276 iliev 1133
277 iliev 1130 /**
278     * Invoked when the number of effect sends
279     * on the specified sampler channel has changed.
280     * @param ChannelId The numerical ID of the sampler channel.
281     * @param NewCount The new number of effect sends.
282     */
283     virtual void FxSendCountChanged(int ChannelId, int NewCount);
284 iliev 1133
285 iliev 1130 /**
286     * Invoked when the number of active voices
287     * on the specified sampler channel has changed.
288     * @param ChannelId The numerical ID of the sampler channel.
289     * @param NewCount The new number of active voices.
290     */
291     virtual void VoiceCountChanged(int ChannelId, int NewCount);
292    
293     /**
294     * Invoked when the number of active disk streams
295     * on the specified sampler channel has changed.
296     * @param ChannelId The numerical ID of the sampler channel.
297     * @param NewCount The new number of active disk streams.
298     */
299     virtual void StreamCountChanged(int ChannelId, int NewCount);
300    
301     /**
302     * Invoked when the fill state of the disk stream
303     * buffers on the specified sampler channel is changed.
304     * @param ChannelId The numerical ID of the sampler channel.
305     * @param FillData The buffer fill data for the specified sampler channel.
306     */
307     virtual void BufferFillChanged(int ChannelId, String FillData);
308    
309     /**
310     * Invoked when the total number of active voices is changed.
311     * @param NewCount The new number of active voices.
312     */
313     virtual void TotalVoiceCountChanged(int NewCount);
314 iliev 1133 } eventHandler;
315 schoenebeck 35 };
316    
317     #endif // __LSCPSERVER_H_

  ViewVC Help
Powered by ViewVC