20 #ifndef __JackInternalClientChannel__    21 #define __JackInternalClientChannel__    23 #include "JackChannel.h"    47         void ClientCheck(
const char* name, 
int uuid, 
char* name_res, 
int protocol, 
int options, 
int* status, 
int* result, 
int open)
    49             *result = fEngine->ClientCheck(name, uuid, name_res, protocol, options, status);
    53             *result = fEngine->ClientInternalOpen(name, ref, shared_engine, shared_manager, client, 
true);
    55         void ClientClose(
int refnum, 
int* result)
    57             *result = fEngine->ClientInternalClose(refnum, 
true);
    60         void ClientActivate(
int refnum, 
int is_real_time, 
int* result)
    62             *result = fEngine->ClientActivate(refnum, is_real_time);
    64         void ClientDeactivate(
int refnum, 
int* result)
    66             *result = fEngine->ClientDeactivate(refnum);
    69         void PortRegister(
int refnum, 
const char* name, 
const char* type, 
unsigned int flags, 
unsigned int buffer_size, 
unsigned int* port_index, 
int* result)
    71             *result = fEngine->PortRegister(refnum, name, type, flags, buffer_size, port_index);
    73         void PortUnRegister(
int refnum, jack_port_id_t port_index, 
int* result)
    75             *result = fEngine->PortUnRegister(refnum, port_index);
    77         void PortConnect(
int refnum, 
const char* src, 
const char* dst, 
int* result)
    79             *result = fEngine->PortConnect(refnum, src, dst);
    81         void PortDisconnect(
int refnum, 
const char* src, 
const char* dst, 
int* result)
    83             *result = fEngine->PortDisconnect(refnum, src, dst);
    85         void PortConnect(
int refnum, jack_port_id_t src, jack_port_id_t dst, 
int* result)
    87             *result = fEngine->PortConnect(refnum, src, dst);
    89         void PortDisconnect(
int refnum, jack_port_id_t src, jack_port_id_t dst, 
int* result)
    91             *result = fEngine->PortDisconnect(refnum, src, dst);
    93         void PortRename(
int refnum, jack_port_id_t port, 
const char* name, 
int* result)
    95             *result = fEngine->PortRename(refnum, port, name);
    98         void SetBufferSize(jack_nframes_t buffer_size, 
int* result)
   100             *result = fServer->SetBufferSize(buffer_size);
   102         void SetFreewheel(
int onoff, 
int* result)
   104             *result = fServer->SetFreewheel(onoff);
   106         void ComputeTotalLatencies(
int* result)
   108             *result = fEngine->ComputeTotalLatencies();
   111         void ReleaseTimebase(
int refnum, 
int* result)
   113             *result = fServer->ReleaseTimebase(refnum);
   116         void SetTimebaseCallback(
int refnum, 
int conditional, 
int* result)
   118             *result = fServer->SetTimebaseCallback(refnum, conditional);
   121         void GetInternalClientName(
int refnum, 
int int_ref, 
char* name_res, 
int* result)
   123             *result = fEngine->GetInternalClientName(int_ref, name_res);
   126         void InternalClientHandle(
int refnum, 
const char* client_name, 
int* status, 
int* int_ref, 
int* result)
   128             *result = fEngine->InternalClientHandle(client_name, status, int_ref);
   131         void InternalClientLoad(
int refnum, 
const char* client_name, 
const char* so_name, 
const char* objet_data, 
int options, 
int* status, 
int* int_ref, 
int uuid, 
int* result)
   133             *result = fServer->InternalClientLoad1(client_name, so_name, objet_data, options, int_ref, uuid, status);
   136         void InternalClientUnload(
int refnum, 
int int_ref, 
int* status, 
int* result)
   138             *result = fEngine->InternalClientUnload(int_ref, status);
   141         void SessionNotify(
int refnum, 
const char *target, jack_session_event_type_t type, 
const char *path, 
jack_session_command_t** result)
   144             fEngine->SessionNotify(refnum, target, type, path, NULL, &res);
   150             *result = res->GetCommands();
   154         void SessionReply(
int refnum, 
int* result)
   156             *result = fEngine->SessionReply(refnum);
   159         void GetUUIDForClientName(
int refnum, 
const char* client_name, 
char* uuid_res, 
int* result)
   161             *result = fEngine->GetUUIDForClientName(client_name, uuid_res);
   164         void GetClientNameForUUID(
int refnum, 
const char* uuid, 
char* name_res, 
int* result)
   166             *result = fEngine->GetClientNameForUUID(uuid, name_res);
   169         void ReserveClientName(
int refnum, 
const char* client_name, 
const char *uuid, 
int* result)
   171             *result = fEngine->ReserveClientName(client_name, uuid);
   174         void ClientHasSessionCallback(
const char* client_name, 
int* result)
   176             *result = fEngine->ClientHasSessionCallback(client_name);
 Inter process channel for server/client bidirectionnal communication : request and (receiving) notifi...
JackClientChannel for server internal clients.
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.