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, self_connect_mode)
92 bool Lock() {
return fEngine.Lock(); }
93 bool Unlock() {
return fEngine.Unlock(); }
94 bool Trylock() {
return fEngine.Trylock(); }
100 return fEngine.Open();
101 CATCH_EXCEPTION_RETURN
107 return fEngine.Close();
108 CATCH_EXCEPTION_RETURN
112 int ClientCheck(
const char* name,
int uuid,
char* name_res,
int protocol,
int options,
int* status)
116 return fEngine.ClientCheck(name, uuid, name_res, protocol, options, status);
117 CATCH_EXCEPTION_RETURN
119 int ClientExternalOpen(
const char* name,
int pid,
int uuid,
int* ref,
int* shared_engine,
int* shared_client,
int* shared_graph_manager)
123 return fEngine.ClientExternalOpen(name, pid, uuid, ref, shared_engine, shared_client, shared_graph_manager);
124 CATCH_EXCEPTION_RETURN
130 return fEngine.ClientInternalOpen(name, ref, shared_engine, shared_manager, client, wait);
131 CATCH_EXCEPTION_RETURN
134 int ClientExternalClose(
int refnum)
138 return (fEngine.CheckClient(refnum)) ? fEngine.ClientExternalClose(refnum) : -1;
139 CATCH_CLOSE_EXCEPTION_RETURN
141 int ClientInternalClose(
int refnum,
bool wait)
145 return (fEngine.CheckClient(refnum)) ? fEngine.ClientInternalClose(refnum, wait) : -1;
146 CATCH_CLOSE_EXCEPTION_RETURN
149 int ClientActivate(
int refnum,
bool is_real_time)
153 return (fEngine.CheckClient(refnum)) ? fEngine.ClientActivate(refnum, is_real_time) : -1;
154 CATCH_EXCEPTION_RETURN
156 int ClientDeactivate(
int refnum)
160 return (fEngine.CheckClient(refnum)) ? fEngine.ClientDeactivate(refnum) : -1;
161 CATCH_EXCEPTION_RETURN
163 void ClientKill(
int refnum)
167 fEngine.ClientKill(refnum);
172 int GetInternalClientName(
int int_ref,
char* name_res)
176 return fEngine.GetInternalClientName(int_ref, name_res);
177 CATCH_EXCEPTION_RETURN
179 int InternalClientHandle(
const char* client_name,
int* status,
int* int_ref)
183 return fEngine.InternalClientHandle(client_name, status, int_ref);
184 CATCH_EXCEPTION_RETURN
186 int InternalClientUnload(
int refnum,
int* status)
191 return fEngine.InternalClientUnload(refnum, status);
192 CATCH_EXCEPTION_RETURN
196 int PortRegister(
int refnum,
const char* name,
const char *type,
unsigned int flags,
unsigned int buffer_size, jack_port_id_t* port)
200 return (fEngine.CheckClient(refnum)) ? fEngine.PortRegister(refnum, name, type, flags, buffer_size, port) : -1;
201 CATCH_EXCEPTION_RETURN
203 int PortUnRegister(
int refnum, jack_port_id_t port)
207 return (fEngine.CheckClient(refnum)) ? fEngine.PortUnRegister(refnum, port) : -1;
208 CATCH_EXCEPTION_RETURN
211 int PortConnect(
int refnum,
const char* src,
const char* dst)
215 return (fEngine.CheckClient(refnum)) ? fEngine.PortConnect(refnum, src, dst) : -1;
216 CATCH_EXCEPTION_RETURN
218 int PortDisconnect(
int refnum,
const char* src,
const char* dst)
222 return (fEngine.CheckClient(refnum)) ? fEngine.PortDisconnect(refnum, src, dst) : -1;
223 CATCH_EXCEPTION_RETURN
226 int PortConnect(
int refnum, jack_port_id_t src, jack_port_id_t dst)
230 return (fEngine.CheckClient(refnum)) ? fEngine.PortConnect(refnum, src, dst) : -1;
231 CATCH_EXCEPTION_RETURN
233 int PortDisconnect(
int refnum, jack_port_id_t src, jack_port_id_t dst)
237 return (fEngine.CheckClient(refnum)) ? fEngine.PortDisconnect(refnum, src, dst) : -1;
238 CATCH_EXCEPTION_RETURN
241 int PortRename(
int refnum, jack_port_id_t port,
const char* name)
245 return (fEngine.CheckClient(refnum)) ? fEngine.PortRename(refnum, port, name) : -1;
246 CATCH_EXCEPTION_RETURN
249 int ComputeTotalLatencies()
253 return fEngine.ComputeTotalLatencies();
254 CATCH_EXCEPTION_RETURN
258 bool Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end)
261 return fEngine.Process(cur_cycle_begin, prev_cycle_end);
265 void NotifyDriverXRun()
268 fEngine.NotifyDriverXRun();
271 void NotifyClientXRun(
int refnum)
275 fEngine.NotifyClientXRun(refnum);
279 void NotifyGraphReorder()
283 fEngine.NotifyGraphReorder();
287 void NotifyBufferSize(jack_nframes_t buffer_size)
291 fEngine.NotifyBufferSize(buffer_size);
294 void NotifySampleRate(jack_nframes_t sample_rate)
298 fEngine.NotifySampleRate(sample_rate);
301 void NotifyFreewheel(
bool onoff)
305 fEngine.NotifyFreewheel(onoff);
309 void NotifyFailure(
int code,
const char* reason)
313 fEngine.NotifyFailure(code, reason);
317 int GetClientPID(
const char* name)
321 return fEngine.GetClientPID(name);
322 CATCH_EXCEPTION_RETURN
325 int GetClientRefNum(
const char* name)
329 return fEngine.GetClientRefNum(name);
330 CATCH_EXCEPTION_RETURN
337 return fEngine.NotifyQuit();
345 fEngine.SessionNotify(refnum, target, type, path, socket, result);
349 int SessionReply(
int refnum)
353 return fEngine.SessionReply(refnum);
354 CATCH_EXCEPTION_RETURN
357 int GetUUIDForClientName(
const char *client_name,
char *uuid_res)
361 return fEngine.GetUUIDForClientName(client_name, uuid_res);
362 CATCH_EXCEPTION_RETURN
364 int GetClientNameForUUID(
const char *uuid,
char *name_res)
368 return fEngine.GetClientNameForUUID(uuid, name_res);
369 CATCH_EXCEPTION_RETURN
371 int ReserveClientName(
const char *name,
const char *uuid)
375 return fEngine.ReserveClientName(name, uuid);
376 CATCH_EXCEPTION_RETURN
379 int ClientHasSessionCallback(
const char *name)
383 return fEngine.ClientHasSessionCallback(name);
384 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.