Jack2  1.9.9
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 "varargs.h"
32 #include <list>
33 
34 namespace Jack
35 {
36 
37 class JackGraphManager;
38 class JackServer;
39 class JackEngine;
40 struct JackClientControl;
41 struct JackEngineControl;
42 
47 class SERVER_EXPORT JackClient : public JackClientInterface, public JackRunnableInterface
48 {
49  friend class JackDebugClient;
50 
51  protected:
52 
53  JackProcessCallback fProcess;
54  JackGraphOrderCallback fGraphOrder;
55  JackXRunCallback fXrun;
56  JackShutdownCallback fShutdown;
57  JackInfoShutdownCallback fInfoShutdown;
58  JackThreadInitCallback fInit;
59  JackBufferSizeCallback fBufferSize;
60  JackSampleRateCallback fSampleRate;
61  JackClientRegistrationCallback fClientRegistration;
62  JackFreewheelCallback fFreewheel;
63  JackPortRegistrationCallback fPortRegistration;
64  JackPortConnectCallback fPortConnect;
65  JackPortRenameCallback fPortRename;
66  JackTimebaseCallback fTimebase;
67  JackSyncCallback fSync;
68  JackThreadCallback fThreadFun;
69  JackSessionCallback fSession;
70  JackLatencyCallback fLatency;
71 
72  void* fProcessArg;
73  void* fGraphOrderArg;
74  void* fXrunArg;
75  void* fShutdownArg;
76  void* fInfoShutdownArg;
77  void* fInitArg;
78  void* fBufferSizeArg;
79  void* fSampleRateArg;
80  void* fClientRegistrationArg;
81  void* fFreewheelArg;
82  void* fPortRegistrationArg;
83  void* fPortConnectArg;
84  void* fPortRenameArg;
85  void* fTimebaseArg;
86  void* fSyncArg;
87  void* fThreadFunArg;
88  void* fSessionArg;
89  void* fLatencyArg;
90  char fServerName[JACK_SERVER_CONTROL_NAME_SIZE];
91 
92  JackThread fThread;
94  JackSynchro* fSynchroTable;
95  std::list<jack_port_id_t> fPortList;
96 
97  JackSessionReply fSessionReply;
98 
99  int StartThread();
100  void SetupDriverSync(bool freewheel);
101  bool IsActive();
102 
103  void CallSyncCallback();
104  void CallTimebaseCallback();
105 
106  virtual int ClientNotifyImp(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value);
107 
108  inline void DummyCycle();
109  inline void ExecuteThread();
110  inline bool WaitSync();
111  inline void SignalSync();
112  inline int CallProcessCallback();
113  inline void End();
114  inline void Error();
115  inline jack_nframes_t CycleWaitAux();
116  inline void CycleSignalAux(int status);
117  inline void CallSyncCallbackAux();
118  inline void CallTimebaseCallbackAux();
119  inline int ActivateAux();
120  inline void InitAux();
121 
122  int HandleLatencyCallback(int status);
123 
124  public:
125 
126  JackClient();
127  JackClient(JackSynchro* table);
128  virtual ~JackClient();
129 
130  virtual int Open(const char* server_name, const char* name, int uuid, jack_options_t options, jack_status_t* status) = 0;
131  virtual int Close();
132 
133  virtual JackGraphManager* GetGraphManager() const = 0;
134  virtual JackEngineControl* GetEngineControl() const = 0;
135 
136  // Notifications
137  virtual int ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);
138 
139  virtual int Activate();
140  virtual int Deactivate();
141 
142  // Context
143  virtual int SetBufferSize(jack_nframes_t buffer_size);
144  virtual int SetFreeWheel(int onoff);
145  virtual int ComputeTotalLatencies();
146  virtual void ShutDown();
147  virtual jack_native_thread_t GetThreadID();
148 
149  // Port management
150  virtual int PortRegister(const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
151  virtual int PortUnRegister(jack_port_id_t port);
152 
153  virtual int PortConnect(const char* src, const char* dst);
154  virtual int PortDisconnect(const char* src, const char* dst);
155  virtual int PortDisconnect(jack_port_id_t src);
156 
157  virtual int PortIsMine(jack_port_id_t port_index);
158  virtual int PortRename(jack_port_id_t port_index, const char* name);
159 
160  // Transport
161  virtual int ReleaseTimebase();
162  virtual int SetSyncCallback(JackSyncCallback sync_callback, void* arg);
163  virtual int SetSyncTimeout(jack_time_t timeout);
164  virtual int SetTimebaseCallback(int conditional, JackTimebaseCallback timebase_callback, void* arg);
165  virtual void TransportLocate(jack_nframes_t frame);
166  virtual jack_transport_state_t TransportQuery(jack_position_t* pos);
167  virtual jack_nframes_t GetCurrentTransportFrame();
168  virtual int TransportReposition(const jack_position_t* pos);
169  virtual void TransportStart();
170  virtual void TransportStop();
171 
172  // Callbacks
173  virtual void OnShutdown(JackShutdownCallback callback, void *arg);
174  virtual void OnInfoShutdown(JackInfoShutdownCallback callback, void *arg);
175  virtual int SetProcessCallback(JackProcessCallback callback, void* arg);
176  virtual int SetXRunCallback(JackXRunCallback callback, void* arg);
177  virtual int SetInitCallback(JackThreadInitCallback callback, void* arg);
178  virtual int SetGraphOrderCallback(JackGraphOrderCallback callback, void* arg);
179  virtual int SetBufferSizeCallback(JackBufferSizeCallback callback, void* arg);
180  virtual int SetSampleRateCallback(JackBufferSizeCallback callback, void* arg);
181  virtual int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg);
182  virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
183  virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
184  virtual int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
185  virtual int SetPortRenameCallback(JackPortRenameCallback callback, void *arg);
186  virtual int SetSessionCallback(JackSessionCallback callback, void *arg);
187  virtual int SetLatencyCallback(JackLatencyCallback callback, void *arg);
188 
189  // Internal clients
190  virtual char* GetInternalClientName(int ref);
191  virtual int InternalClientHandle(const char* client_name, jack_status_t* status);
192  virtual int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va);
193  virtual void InternalClientUnload(int ref, jack_status_t* status);
194 
195  // RT Thread
196  jack_nframes_t CycleWait();
197  void CycleSignal(int status);
198  virtual int SetProcessThread(JackThreadCallback fun, void *arg);
199 
200  // Session API
201  virtual jack_session_command_t* SessionNotify(const char* target, jack_session_event_type_t type, const char* path);
202  virtual int SessionReply(jack_session_event_t* ev);
203  virtual char* GetUUIDForClientName(const char* client_name);
204  virtual char* GetClientNameByUUID(const char* uuid);
205  virtual int ReserveClientName(const char* client_name, const char* uuid);
206  virtual int ClientHasSessionCallback(const char* client_name);
207 
208  // JackRunnableInterface interface
209  bool Init();
210  bool Execute();
211 };
212 
213 } // end of namespace
214 
215 #endif
Inter process channel for server/client bidirectionnal communication : request and (receiving) notifi...
Definition: JackChannel.h:90
Inter process synchronization using using Mach semaphore.
The base class for runnable objects, that have an Init and Execute method to be called in a threa...
Definition: JackThread.h:34
Graph manager: contains the connection manager and the port array.
A &quot;decorator&quot; debug client to validate API use.
Engine control in shared memory.
detail::JackClientChannelInterface * fChannel
Definition: JackClient.h:93
void(* JackSessionCallback)(jack_session_event_t *event, void *arg)
Definition: session.h:162
The base class for clients: share part of the implementation for JackInternalClient and JackLibClient...
Definition: JackClient.h:47
Darwin threads. Real-time threads are actually &quot;time constraint&quot; threads.