20 #ifndef __JackLockedEngine__
21 #define __JackLockedEngine__
23 #include "JackEngine.h"
24 #include "JackMutex.h"
25 #include "JackTools.h"
26 #include "JackException.h"
43 #define CATCH_EXCEPTION_RETURN \
44 } catch (std::bad_alloc& e) { \
45 jack_error("Memory allocation error..."); \
48 jack_error("Unknown error..."); \
52 #define CATCH_CLOSE_EXCEPTION_RETURN \
53 } catch (std::bad_alloc& e) { \
54 jack_error("Memory allocation error..."); \
56 } catch (JackTemporaryException& e) { \
57 jack_error("JackTemporaryException : now quits..."); \
58 JackTools::KillServer(); \
61 jack_error("Unknown error..."); \
65 #define CATCH_EXCEPTION \
66 } catch (std::bad_alloc& e) { \
67 jack_error("Memory allocation error..."); \
69 jack_error("Unknown error..."); \
87 fEngine(manager, table, controler)
96 return fEngine.Open();
97 CATCH_EXCEPTION_RETURN
103 return fEngine.Close();
104 CATCH_EXCEPTION_RETURN
116 int ClientCheck(
const char* name,
int uuid,
char* name_res,
int protocol,
int options,
int* status)
120 return fEngine.ClientCheck(name, uuid, name_res, protocol, options, status);
121 CATCH_EXCEPTION_RETURN
123 int ClientExternalOpen(
const char* name,
int pid,
int uuid,
int* ref,
int* shared_engine,
int* shared_client,
int* shared_graph_manager)
127 return fEngine.ClientExternalOpen(name, pid, uuid, ref, shared_engine, shared_client, shared_graph_manager);
128 CATCH_EXCEPTION_RETURN
134 return fEngine.ClientInternalOpen(name, ref, shared_engine, shared_manager, client, wait);
135 CATCH_EXCEPTION_RETURN
138 int ClientExternalClose(
int refnum)
142 return (fEngine.CheckClient(refnum)) ? fEngine.ClientExternalClose(refnum) : -1;
143 CATCH_CLOSE_EXCEPTION_RETURN
145 int ClientInternalClose(
int refnum,
bool wait)
149 return (fEngine.CheckClient(refnum)) ? fEngine.ClientInternalClose(refnum, wait) : -1;
150 CATCH_CLOSE_EXCEPTION_RETURN
153 int ClientActivate(
int refnum,
bool is_real_time)
157 return (fEngine.CheckClient(refnum)) ? fEngine.ClientActivate(refnum, is_real_time) : -1;
158 CATCH_EXCEPTION_RETURN
160 int ClientDeactivate(
int refnum)
164 return (fEngine.CheckClient(refnum)) ? fEngine.ClientDeactivate(refnum) : -1;
165 CATCH_EXCEPTION_RETURN
169 int GetInternalClientName(
int int_ref,
char* name_res)
173 return fEngine.GetInternalClientName(int_ref, name_res);
174 CATCH_EXCEPTION_RETURN
176 int InternalClientHandle(
const char* client_name,
int* status,
int* int_ref)
180 return fEngine.InternalClientHandle(client_name, status, int_ref);
181 CATCH_EXCEPTION_RETURN
183 int InternalClientUnload(
int refnum,
int* status)
188 return fEngine.InternalClientUnload(refnum, status);
189 CATCH_EXCEPTION_RETURN
193 int PortRegister(
int refnum,
const char* name,
const char *type,
unsigned int flags,
unsigned int buffer_size, jack_port_id_t* port)
197 return (fEngine.CheckClient(refnum)) ? fEngine.PortRegister(refnum, name, type, flags, buffer_size, port) : -1;
198 CATCH_EXCEPTION_RETURN
200 int PortUnRegister(
int refnum, jack_port_id_t port)
204 return (fEngine.CheckClient(refnum)) ? fEngine.PortUnRegister(refnum, port) : -1;
205 CATCH_EXCEPTION_RETURN
208 int PortConnect(
int refnum,
const char* src,
const char* dst)
212 return (fEngine.CheckClient(refnum)) ? fEngine.PortConnect(refnum, src, dst) : -1;
213 CATCH_EXCEPTION_RETURN
215 int PortDisconnect(
int refnum,
const char* src,
const char* dst)
219 return (fEngine.CheckClient(refnum)) ? fEngine.PortDisconnect(refnum, src, dst) : -1;
220 CATCH_EXCEPTION_RETURN
223 int PortConnect(
int refnum, jack_port_id_t src, jack_port_id_t dst)
227 return (fEngine.CheckClient(refnum)) ? fEngine.PortConnect(refnum, src, dst) : -1;
228 CATCH_EXCEPTION_RETURN
230 int PortDisconnect(
int refnum, jack_port_id_t src, jack_port_id_t dst)
234 return (fEngine.CheckClient(refnum)) ? fEngine.PortDisconnect(refnum, src, dst) : -1;
235 CATCH_EXCEPTION_RETURN
238 int PortRename(
int refnum, jack_port_id_t port,
const char* name)
242 return (fEngine.CheckClient(refnum)) ? fEngine.PortRename(refnum, port, name) : -1;
243 CATCH_EXCEPTION_RETURN
246 int ComputeTotalLatencies()
250 return fEngine.ComputeTotalLatencies();
251 CATCH_EXCEPTION_RETURN
255 bool Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end)
258 return fEngine.Process(cur_cycle_begin, prev_cycle_end);
262 void NotifyXRun(jack_time_t cur_cycle_begin,
float delayed_usecs)
265 fEngine.NotifyXRun(cur_cycle_begin, delayed_usecs);
268 void NotifyXRun(
int refnum)
271 fEngine.NotifyXRun(refnum);
274 void NotifyGraphReorder()
278 fEngine.NotifyGraphReorder();
282 void NotifyBufferSize(jack_nframes_t buffer_size)
286 fEngine.NotifyBufferSize(buffer_size);
289 void NotifySampleRate(jack_nframes_t sample_rate)
293 fEngine.NotifySampleRate(sample_rate);
296 void NotifyFreewheel(
bool onoff)
300 fEngine.NotifyFreewheel(onoff);
304 void NotifyFailure(
int code,
const char* reason)
308 fEngine.NotifyFailure(code, reason);
312 int GetClientPID(
const char* name)
316 return fEngine.GetClientPID(name);
317 CATCH_EXCEPTION_RETURN
320 int GetClientRefNum(
const char* name)
324 return fEngine.GetClientRefNum(name);
325 CATCH_EXCEPTION_RETURN
332 return fEngine.NotifyQuit();
340 fEngine.SessionNotify(refnum, target, type, path, socket, result);
344 int SessionReply(
int refnum)
348 return fEngine.SessionReply(refnum);
349 CATCH_EXCEPTION_RETURN
352 int GetUUIDForClientName(
const char *client_name,
char *uuid_res)
356 return fEngine.GetUUIDForClientName(client_name, uuid_res);
357 CATCH_EXCEPTION_RETURN
359 int GetClientNameForUUID(
const char *uuid,
char *name_res)
363 return fEngine.GetClientNameForUUID(uuid, name_res);
364 CATCH_EXCEPTION_RETURN
366 int ReserveClientName(
const char *name,
const char *uuid)
370 return fEngine.ReserveClientName(name, uuid);
371 CATCH_EXCEPTION_RETURN
374 int ClientHasSessionCallback(
const char *name)
378 return fEngine.ClientHasSessionCallback(name);
379 CATCH_EXCEPTION_RETURN
Inter process synchronization using using Mach semaphore.
Locked Engine, access to methods is serialized using a mutex.
Graph manager: contains the connection manager and the port array.
Engine control in shared memory.