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.