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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 159 by capela, Tue Jun 29 21:11:50 2004 UTC revision 170 by senkov, Sat Jul 3 20:08:07 2004 UTC
# Line 26  Line 26 
26  #include <unistd.h>  #include <unistd.h>
27  #include <sys/types.h>  #include <sys/types.h>
28  #include <sys/socket.h>  #include <sys/socket.h>
29    #include <sys/select.h>
30    #include <sys/time.h>
31  #include <netinet/in.h>  #include <netinet/in.h>
32  #include <netinet/tcp.h>  #include <netinet/tcp.h>
33  #include <arpa/inet.h>  #include <arpa/inet.h>
34  #include <netdb.h>  #include <netdb.h>
35    
36    #include <list>
37    
38  #include "lscp.h"  #include "lscp.h"
39  #include "lscpparser.h"  #include "lscpparser.h"
40    #include "lscp.h"
41    #include "lscpevent.h"
42  #include "../Sampler.h"  #include "../Sampler.h"
43  #include "../common/Thread.h"  #include "../common/Thread.h"
44    #include "../common/Mutex.h"
45    
46  /// TCP Port on which the server should listen for connection requests.  /// TCP Port on which the server should listen for connection requests.
47  #define LSCP_PORT 8888  #define LSCP_PORT 8888
48    
49  using namespace LinuxSampler;  using namespace LinuxSampler;
50    
 /// Handle for a client connection (FIXME: doesn't work for more than one network connections of course, thus has to be included to the yyparse() parameters instead).  
 extern int hSession;  
   
51  // External references to the main scanner and parser functions  // External references to the main scanner and parser functions
52  extern int yyparse(void* YYPARSE_PARAM);  extern int yyparse(void* YYPARSE_PARAM);
53  extern int yylex_init(yyscan_t* scanner);  extern int yylex_init(yyscan_t* scanner);
# Line 109  class LSCPServer : public Thread { Line 113  class LSCPServer : public Thread {
113          String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);          String SetMIDIInput(uint MIDIDeviceId, uint MIDIPort, uint MIDIChannel, uint uiSamplerChannel);
114          String SetVolume(double Volume, uint uiSamplerChannel);          String SetVolume(double Volume, uint uiSamplerChannel);
115          String ResetChannel(uint uiSamplerChannel);          String ResetChannel(uint uiSamplerChannel);
116          String SubscribeNotification(event_t Event);          String SubscribeNotification(LSCPEvent::event_t);
117          String UnsubscribeNotification(event_t Event);          String UnsubscribeNotification(LSCPEvent::event_t);
118          void   AnswerClient(String ReturnMessage);          void   AnswerClient(String ReturnMessage);
119    
120            static int currentSocket;
121            static std::map<int,String> bufferedCommands;
122      protected:      protected:
123          int            hSocket;          int            hSocket;
124          sockaddr_in    SocketAddress;          sockaddr_in    SocketAddress;
125          Sampler*       pSampler;          Sampler*       pSampler;
126    
127          int Main(); ///< Implementation of virtual method from class Thread          int Main(); ///< Implementation of virtual method from class Thread
128    
129            static void SendLSCPNotify( LSCPEvent Event );
130    
131      private:      private:
132                    
133          /**          /**
# Line 130  class LSCPServer : public Thread { Line 140  class LSCPServer : public Thread {
140           */           */
141          int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);          int GetMidiInputDeviceIndex (MidiInputDevice *pDevice);
142    
143          /**          static std::map<int,String> bufferedNotifies;
144           * Converts a result_t structure into a valid LSCP answer message.          static Mutex NotifyMutex;
145           */          static Mutex NotifyBufferMutex;
146          inline String ConvertResult(result_t result) {          static bool GetLSCPCommand( std::vector<int>::iterator iter );
147              switch (result.type) {          static void CloseConnection( std::vector<int>::iterator iter );
148                  case result_type_success: {          static std::vector<int> hSessions;
149                      return "OK\r\n";          static Mutex SubscriptionMutex;
150                  }          static std::map< LSCPEvent::event_t, std::list<int> > eventSubscriptions;
151                  case result_type_warning: {          static fd_set fdSet;
                     std::stringstream ss;  
                     ss << "WRN:" << result.code << ":" << result.message << "\r\n";  
                     return ss.str();  
                 }  
                 case result_type_error: {  
                     std::stringstream ss;  
                     ss << "ERR:" << result.code << ":" << result.message << "\r\n";  
                     return ss.str();  
                 }  
             }  
         }  
   
         template<class T> inline String ToString(T o) {  
             std::stringstream ss;  
             ss << o;  
             return ss.str();  
         }  
152  };  };
153    
   
154  /**  /**
155   * Instrument loader thread for the LinuxSampler Control Protocol (LSCP).   * Instrument loader thread for the LinuxSampler Control Protocol (LSCP).
156   */   */

Legend:
Removed from v.159  
changed lines
  Added in v.170

  ViewVC Help
Powered by ViewVC