Jack2  1.9.13
JackClient.h
1 /*
2 Copyright (C) 2001 Paul Davis
3 Copyright (C) 2004-2008 Grame
4 
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
9 
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
14 
15 You should have received a copy of the GNU Lesser General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 
19 */
20 
21 #ifndef __JackClient__
22 #define __JackClient__
23 
24 #include "JackClientInterface.h"
25 #include "JackThread.h"
26 #include "JackConstants.h"
27 #include "JackSynchro.h"
28 #include "JackPlatformPlug.h"
29 #include "JackChannel.h"
30 #include "JackRequest.h"
31 #include "JackMetadata.h"
32 #include "varargs.h"
33 #include <list>
34 
35 namespace Jack
36 {
37 
38 class JackGraphManager;
39 class JackServer;
40 class JackEngine;
41 struct JackClientControl;
42 struct JackEngineControl;
43 
48 class SERVER_EXPORT JackClient : public JackClientInterface, public JackRunnableInterface
49 {
50  friend class JackDebugClient;
51 
52  protected:
53 
54  JackProcessCallback fProcess;
55  JackGraphOrderCallback fGraphOrder;
56  JackXRunCallback fXrun;
57  JackShutdownCallback fShutdown;
58  JackInfoShutdownCallback fInfoShutdown;
59  JackThreadInitCallback fInit;
60  JackBufferSizeCallback fBufferSize;
61  JackSampleRateCallback fSampleRate;
62  JackClientRegistrationCallback fClientRegistration;
63  JackFreewheelCallback fFreewheel;
64  JackPortRegistrationCallback fPortRegistration;
65  JackPortConnectCallback fPortConnect;
66  JackPortRenameCallback fPortRename;
67  JackTimebaseCallback fTimebase;
68  JackSyncCallback fSync;
69  JackThreadCallback fThreadFun;
70  JackSessionCallback fSession;
71  JackLatencyCallback fLatency;
72  JackPropertyChangeCallback fPropertyChange;
73 
74  void* fProcessArg;
75  void* fGraphOrderArg;
76  void* fXrunArg;
77  void* fShutdownArg;
78  void* fInfoShutdownArg;
79  void* fInitArg;
80  void* fBufferSizeArg;
81  void* fSampleRateArg;
82  void* fClientRegistrationArg;
83  void* fFreewheelArg;
84  void* fPortRegistrationArg;
85  void* fPortConnectArg;
86  void* fPortRenameArg;
87  void* fTimebaseArg;
88  void* fSyncArg;
89  void* fThreadFunArg;
90  void* fSessionArg;
91  void* fLatencyArg;
92  void* fPropertyChangeArg;
93 
94  char fServerName[JACK_SERVER_NAME_SIZE+1];
95 
96  JackThread fThread;
97  detail::JackClientChannelInterface* fChannel;
98  JackSynchro* fSynchroTable;
99  std::list<jack_port_id_t> fPortList;
100 
101  JackSessionReply fSessionReply;
102 
103  int StartThread();
104  void SetupDriverSync(bool freewheel);
105  bool IsActive();
106 
107  void CallSyncCallback();
108  void CallTimebaseCallback();
109 
110  virtual int ClientNotifyImp(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value);
111 
112  inline void DummyCycle();
113  inline void ExecuteThread();
114  inline bool WaitSync();
115  inline void SignalSync();
116  inline int CallProcessCallback();
117  inline void End();
118  inline void Error();
119  inline jack_nframes_t CycleWaitAux();
120  inline void CycleSignalAux(int status);
121  inline void CallSyncCallbackAux();
122  inline void CallTimebaseCallbackAux();
123  inline int ActivateAux();
124  inline void InitAux();
125  inline void SetupRealTime();
126 
127  int HandleLatencyCallback(int status);
128 
129  public:
130 
131  JackClient(JackSynchro* table);
132  virtual ~JackClient();
133 
134  char* GetServerName() { return fServerName; }
135 
136  virtual int Open(const char* server_name, const char* name, jack_uuid_t uuid, jack_options_t options, jack_status_t* status) = 0;
137  virtual int Close();
138 
139  virtual JackGraphManager* GetGraphManager() const = 0;
140  virtual JackEngineControl* GetEngineControl() const = 0;
141 
142  // Notifications
143  virtual int ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);
144 
145  virtual int Activate();
146  virtual int Deactivate();
147 
148  // Context
149  virtual int SetBufferSize(jack_nframes_t buffer_size);
150  virtual int SetFreeWheel(int onoff);
151  virtual int ComputeTotalLatencies();
152  virtual void ShutDown(jack_status_t code, const char* message);
153  virtual jack_native_thread_t GetThreadID();
154 
155  // Port management
156  virtual int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
157  virtual int PortUnRegister(jack_port_id_t port);
158 
159  virtual int PortConnect(const char* src, const char* dst);
160  virtual int PortDisconnect(const char* src, const char* dst);
161  virtual int PortDisconnect(jack_port_id_t src);
162 
163  virtual int PortIsMine(jack_port_id_t port_index);
164  virtual int PortRename(jack_port_id_t port_index, const char* name);
165 
166  // Transport
167  virtual int ReleaseTimebase();
168  virtual int SetSyncCallback(JackSyncCallback sync_callback, void* arg);
169  virtual int SetSyncTimeout(jack_time_t timeout);
170  virtual int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);
171  virtual void TransportLocate(jack_nframes_t frame);
172  virtual jack_transport_state_t TransportQuery(jack_position_t* pos);
173  virtual jack_nframes_t GetCurrentTransportFrame();
174  virtual int TransportReposition(const jack_position_t* pos);
175  virtual void TransportStart();
176  virtual void TransportStop();
177 
178  // Callbacks
179  virtual void OnShutdown(JackShutdownCallback callback, void *arg);
180  virtual void OnInfoShutdown(JackInfoShutdownCallback callback, void *arg);
181  virtual int SetProcessCallback(JackProcessCallback callback, void* arg);
182  virtual int SetXRunCallback(JackXRunCallback callback, void* arg);
183  virtual int SetInitCallback(JackThreadInitCallback callback, void* arg);
184  virtual int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);
185  virtual int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);
186  virtual int SetSampleRateCallback(JackBufferSizeCallback callback, void* arg);
187  virtual int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg);
188  virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
189  virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
190  virtual int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
191  virtual int SetPortRenameCallback(JackPortRenameCallback callback, void *arg);
192  virtual int SetSessionCallback(JackSessionCallback callback, void *arg);
193  virtual int SetLatencyCallback(JackLatencyCallback callback, void *arg);
194  virtual int SetPropertyChangeCallback(JackPropertyChangeCallback callback, void* arg);
195 
196  // Internal clients
197  virtual char* GetInternalClientName(int ref);
198  virtual int InternalClientHandle(const char* client_name, jack_status_t* status);
199  virtual int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va);
200  virtual void InternalClientUnload(int ref, jack_status_t* status);
201 
202  // RT Thread
203  jack_nframes_t CycleWait();
204  void CycleSignal(int status);
205  virtual int SetProcessThread(JackThreadCallback fun, void *arg);
206 
207  // Session API
208  virtual jack_session_command_t* SessionNotify(const char* target, jack_session_event_type_t type, const char* path);
209  virtual int SessionReply(jack_session_event_t* ev);
210  virtual char* GetUUIDForClientName(const char* client_name);
211  virtual char* GetClientNameByUUID(const char* uuid);
212  virtual int ReserveClientName(const char* client_name, const char* uuid);
213  virtual int ClientHasSessionCallback(const char* client_name);
214 
215  // Metadata API
216  virtual int PropertyChangeNotify(jack_uuid_t subject, const char* key, jack_property_change_t change);
217 
218  // JackRunnableInterface interface
219  bool Init();
220  bool Execute();
221 };
222 
223 } // end of namespace
224 
225 #endif
_jack_position
Definition: types.h:554
Jack::detail::JackClientChannelInterface
Inter process channel for server/client bidirectionnal communication : request and (receiving) notifi...
Definition: JackChannel.h:91
jack_varargs_t
Definition: varargs.h:34
Jack::JackRunnableInterface
The base class for runnable objects, that have an Init and Execute method to be called in a threa...
Definition: JackThread.h:34
_jack_session_event
Definition: JackSession.h:45
Jack::JackPosixSemaphore
Inter process synchronization using POSIX semaphore.
Definition: JackPosixSemaphore.h:36
JackPropertyChangeCallback
void(* JackPropertyChangeCallback)(jack_uuid_t subject, const char *key, jack_property_change_t change, void *arg)
Definition: metadata.h:209
Jack::JackGraphManager
Graph manager: contains the connection manager and the port array.
Definition: JackGraphManager.h:40
jack_session_command_t
Definition: JackSession.h:59
Jack::JackDebugClient
A "decorator" debug client to validate API use.
Definition: JackDebugClient.h:49
Jack::JackEngineControl
Engine control in shared memory.
Definition: JackEngineControl.h:49
Jack::JackClient::fChannel
detail::JackClientChannelInterface * fChannel
Definition: JackClient.h:97
JackSessionCallback
void(* JackSessionCallback)(jack_session_event_t *event, void *arg)
Definition: session.h:162
Jack::JackClient
The base class for clients: share part of the implementation for JackInternalClient and JackLibClient...
Definition: JackClient.h:48
Jack::JackMachThread
Darwin threads. Real-time threads are actually "time constraint" threads.
Definition: JackMachThread.h:92
Generated by   doxygen 1.8.6