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
 
Locked Engine, access to methods is serialized using a mutex.
Inter process synchronization using POSIX semaphore.
Graph manager: contains the connection manager and the port array.
Engine control in shared memory.