/[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 411 - (hide annotations) (download) (as text)
Sat Feb 26 02:01:14 2005 UTC (19 years, 1 month ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 8826 byte(s)
* design change: using now one sampler engine instance and one disk thread
  instance for all sampler channels that are connected to the same audio
  output device (and are using the same engine type of course)
* added EngineFactory / EngineChannelFactory to remove the annoying build
  dependencies e.g. of the lscpserver to the actual sampler engine
  implementations
* bumped version to 0.3.0 (current CVS state is still quite broken,
  previous, stable CVS version was tagged as "v0_2_0" and is also available
  as source tarball)

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 385 * Copyright (C) 2005 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 385 #include "lscpinstrumentloader.h"
44 schoenebeck 53 #include "../Sampler.h"
45     #include "../common/Thread.h"
46 senkov 170 #include "../common/Mutex.h"
47 schoenebeck 211 #include "../common/Condition.h"
48 schoenebeck 35
49     /// TCP Port on which the server should listen for connection requests.
50     #define LSCP_PORT 8888
51    
52 schoenebeck 227 /// try up to 3 minutes to bind server socket
53     #define LSCP_SERVER_BIND_TIMEOUT 180
54    
55 schoenebeck 53 using namespace LinuxSampler;
56    
57 schoenebeck 35 // External references to the main scanner and parser functions
58     extern int yyparse(void* YYPARSE_PARAM);
59 schoenebeck 219 extern void restart(yyparse_param_t* pparam, int& yychar);
60 schoenebeck 35
61     /**
62     * Network server for the LinuxSampler Control Protocol (LSCP).
63     */
64     class LSCPServer : public Thread {
65     public:
66 schoenebeck 53 LSCPServer(Sampler* pSampler);
67 schoenebeck 211 int WaitUntilInitialized(long TimeoutSeconds = 0L, long TimeoutNanoSeconds = 0L);
68 schoenebeck 35
69     // Methods called by the parser
70 schoenebeck 123 String DestroyAudioOutputDevice(uint DeviceIndex);
71 senkov 155 String DestroyMidiInputDevice(uint DeviceIndex);
72 capela 137 String LoadInstrument(String Filename, uint uiInstrument, uint uiSamplerChannel, bool bBackground = false);
73 schoenebeck 411 String SetEngineType(String EngineName, uint uiSamplerChannel);
74 schoenebeck 35 String GetChannels();
75 schoenebeck 209 String ListChannels();
76 schoenebeck 35 String AddChannel();
77 schoenebeck 53 String RemoveChannel(uint uiSamplerChannel);
78 schoenebeck 35 String GetAvailableEngines();
79     String GetEngineInfo(String EngineName);
80 schoenebeck 53 String GetChannelInfo(uint uiSamplerChannel);
81     String GetVoiceCount(uint uiSamplerChannel);
82     String GetStreamCount(uint uiSamplerChannel);
83     String GetBufferFill(fill_response_t ResponseType, uint uiSamplerChannel);
84 schoenebeck 123 String GetAvailableAudioOutputDrivers();
85 senkov 155 String GetAvailableMidiInputDrivers();
86 schoenebeck 123 String GetAudioOutputDriverInfo(String Driver);
87 senkov 155 String GetMidiInputDriverInfo(String Driver);
88 schoenebeck 123 #ifdef __GNUC__
89     typedef std::map<String,String> StringMap; // nasty workaround for a GCC bug (see GCC bug #15980, #57)
90     String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
91 senkov 155 String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = StringMap());
92 senkov 140 String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = StringMap());
93 senkov 155 String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = StringMap());
94 schoenebeck 123 #else
95     String GetAudioOutputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
96 senkov 155 String GetMidiInputDriverParameterInfo(String Driver, String Parameter, std::map<String,String> DependencyList = std::map<String,String>());
97 senkov 140 String CreateAudioOutputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
98 senkov 155 String CreateMidiInputDevice(String Driver, std::map<String,String> Parameters = std::map<String,String>());
99 schoenebeck 123 #endif // __GNUC__
100     String GetAudioOutputDeviceCount();
101 senkov 155 String GetMidiInputDeviceCount();
102 schoenebeck 123 String GetAudioOutputDevices();
103 senkov 155 String GetMidiInputDevices();
104 schoenebeck 123 String GetAudioOutputDeviceInfo(uint DeviceIndex);
105 senkov 155 String GetMidiInputDeviceInfo(uint DeviceIndex);
106     String GetMidiInputPortInfo(uint DeviceIndex, uint PortIndex);
107 senkov 185 String GetMidiInputPortParameterInfo(uint DeviceId, uint PortId, String ParameterName);
108 schoenebeck 123 String GetAudioOutputChannelInfo(uint DeviceId, uint ChannelId);
109     String GetAudioOutputChannelParameterInfo(uint DeviceId, uint ChannelId, String ParameterName);
110     String SetAudioOutputChannelParameter(uint DeviceId, uint ChannelId, String ParamKey, String ParamVal);
111     String SetAudioOutputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
112 senkov 155 String SetMidiInputDeviceParameter(uint DeviceIndex, String ParamKey, String ParamVal);
113 capela 159 String SetMidiInputPortParameter(uint DeviceIndex, uint PortIndex, String ParamKey, String ParamVal);
114 schoenebeck 123 String SetAudioOutputChannel(uint ChannelAudioOutputChannel, uint AudioOutputDeviceInputChannel, uint uiSamplerChannel);
115 capela 159 String SetAudioOutputDevice(uint AudioDeviceId, uint SamplerChannel);
116 capela 143 String SetAudioOutputType(String AudioOutputDriver, uint uiSamplerChannel);
117 capela 159 String SetMIDIInputPort(uint MIDIPort, uint uiSamplerChannel);
118     String SetMIDIInputChannel(uint MIDIChannel, uint uiSamplerChannel);
119     String SetMIDIInputDevice(uint MIDIDeviceId, uint uiSamplerChannel);
120 schoenebeck 123 String SetMIDIInputType(String MidiInputDriver, uint uiSamplerChannel);
121 capela 159 String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);
122 schoenebeck 225 String SetVolume(double dVolume, uint uiSamplerChannel);
123 schoenebeck 53 String ResetChannel(uint uiSamplerChannel);
124 schoenebeck 212 String ResetSampler();
125 senkov 170 String SubscribeNotification(LSCPEvent::event_t);
126     String UnsubscribeNotification(LSCPEvent::event_t);
127 senkov 397 String QueryDatabase(String query);
128 schoenebeck 210 String SetEcho(yyparse_param_t* pSession, double boolean_value);
129 schoenebeck 35 void AnswerClient(String ReturnMessage);
130 senkov 170
131     static int currentSocket;
132     static std::map<int,String> bufferedCommands;
133 senkov 184
134     static void SendLSCPNotify( LSCPEvent Event );
135 senkov 360 static int EventSubscribers( std::list<LSCPEvent::event_t> events );
136     static void LockRTNotify( void ) { RTNotifyMutex.Lock(); }
137     static void UnlockRTNotify( void ) { RTNotifyMutex.Unlock(); }
138 senkov 184
139 schoenebeck 35 protected:
140 schoenebeck 53 int hSocket;
141     sockaddr_in SocketAddress;
142     Sampler* pSampler;
143 schoenebeck 211 Condition Initialized;
144 schoenebeck 385 LSCPInstrumentLoader InstrumentLoader; ///< thread responsible for loading instruments in the background
145 schoenebeck 35
146     int Main(); ///< Implementation of virtual method from class Thread
147 senkov 170
148 schoenebeck 35 private:
149 schoenebeck 209
150 schoenebeck 35 /**
151 capela 143 * Find a created audio output device index.
152     */
153     int GetAudioOutputDeviceIndex (AudioOutputDevice *pDevice);
154 schoenebeck 209
155 senkov 155 /**
156     * Find a created midi input device index.
157     */
158     int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
159 capela 143
160 senkov 170 static std::map<int,String> bufferedNotifies;
161     static Mutex NotifyMutex;
162     static Mutex NotifyBufferMutex;
163 schoenebeck 210 static bool GetLSCPCommand( std::vector<yyparse_param_t>::iterator iter );
164     static void CloseConnection( std::vector<yyparse_param_t>::iterator iter );
165     static std::vector<yyparse_param_t> Sessions;
166 senkov 170 static Mutex SubscriptionMutex;
167     static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
168     static fd_set fdSet;
169 senkov 360
170     //Protect main thread that generates real time notify messages
171     //like voice count, stream count and buffer fill
172     //from LSCP server removing engines and channels from underneath
173     static Mutex RTNotifyMutex;
174 schoenebeck 35 };
175    
176     #endif // __LSCPSERVER_H_

  ViewVC Help
Powered by ViewVC