21 #include "JackSystemDeps.h"
22 #include "JackGraphManager.h"
23 #include "JackClientControl.h"
24 #include "JackEngineControl.h"
25 #include "JackGlobals.h"
26 #include "JackChannel.h"
27 #include "JackTransportEngine.h"
28 #include "driver_interface.h"
29 #include "JackLibGlobals.h"
41 #define IsRealTime() ((fProcess != NULL) | (fThreadFun != NULL) | (fSync != NULL) | (fTimebase != NULL))
43 JackClient::JackClient():fThread(this)
46 JackClient::JackClient(JackSynchro* table):fThread(this)
48 fSynchroTable = table;
56 fClientRegistration = NULL;
58 fPortRegistration = NULL;
68 fGraphOrderArg = NULL;
71 fInfoShutdownArg = NULL;
73 fBufferSizeArg = NULL;
75 fClientRegistrationArg = NULL;
76 fPortRegistrationArg = NULL;
77 fPortConnectArg = NULL;
78 fPortRenameArg = NULL;
85 fSessionReply = kPendingSessionReply;
88 JackClient::~JackClient()
91 void JackClient::ShutDown()
96 fInfoShutdown(JackFailure,
"JACK server has been closed", fInfoShutdownArg);
98 }
else if (fShutdown) {
99 fShutdown(fShutdownArg);
104 int JackClient::Close()
106 jack_log(
"JackClient::Close ref = %ld", GetClientControl()->fRefNum);
113 if (JackGlobals::fServerRunning) {
114 fChannel->ClientClose(GetClientControl()->fRefNum, &result);
116 jack_log(
"JackClient::Close server is shutdown");
120 fSynchroTable[GetClientControl()->fRefNum].Disconnect();
121 JackGlobals::fClientTable[GetClientControl()->fRefNum] = NULL;
125 bool JackClient::IsActive()
127 return (GetClientControl()) ? GetClientControl()->fActive :
false;
130 jack_native_thread_t JackClient::GetThreadID()
132 return fThread.GetThreadID();
142 if (!freewheel && !GetEngineControl()->fSyncMode) {
143 jack_log(
"JackClient::SetupDriverSync driver sem in flush mode");
144 for (
int i = 0; i < GetEngineControl()->fDriverNum; i++) {
145 fSynchroTable[i].SetFlush(
true);
148 jack_log(
"JackClient::SetupDriverSync driver sem in normal mode");
149 for (
int i = 0; i < GetEngineControl()->fDriverNum; i++)
150 fSynchroTable[i].SetFlush(
false);
163 int JackClient::ClientNotify(
int refnum,
const char* name,
int notify,
int sync,
const char* message,
int value1,
int value2)
167 jack_log(
"JackClient::ClientNotify ref = %ld name = %s notify = %ld", refnum, name, notify);
173 res = ClientNotifyImp(refnum, name, notify, sync, message, value1, value2);
177 res = ClientNotifyImp(refnum, name, notify, sync, message, value1, value2);
180 case kActivateClient:
181 jack_log(
"JackClient::kActivateClient name = %s ref = %ld ", name, refnum);
195 jack_log(
"JackClient::kAddClient fName = %s name = %s", GetClientControl()->fName, name);
196 if (fClientRegistration && strcmp(GetClientControl()->fName, name) != 0) {
197 fClientRegistration(name, 1, fClientRegistrationArg);
202 jack_log(
"JackClient::kRemoveClient fName = %s name = %s", GetClientControl()->fName, name);
203 if (fClientRegistration && strcmp(GetClientControl()->fName, name) != 0) {
204 fClientRegistration(name, 0, fClientRegistrationArg);
208 case kBufferSizeCallback:
209 jack_log(
"JackClient::kBufferSizeCallback buffer_size = %ld", value1);
211 res = fBufferSize(value1, fBufferSizeArg);
215 case kSampleRateCallback:
216 jack_log(
"JackClient::kSampleRateCallback sample_rate = %ld", value1);
218 res = fSampleRate(value1, fSampleRateArg);
222 case kGraphOrderCallback:
223 jack_log(
"JackClient::kGraphOrderCallback");
225 res = fGraphOrder(fGraphOrderArg);
229 case kStartFreewheelCallback:
230 jack_log(
"JackClient::kStartFreewheel");
231 SetupDriverSync(
true);
232 fThread.DropRealTime();
234 fFreewheel(1, fFreewheelArg);
238 case kStopFreewheelCallback:
239 jack_log(
"JackClient::kStopFreewheel");
240 SetupDriverSync(
false);
242 fFreewheel(0, fFreewheelArg);
244 if (GetEngineControl()->fRealTime) {
245 if (fThread.AcquireRealTime() < 0) {
246 jack_error(
"JackClient::AcquireRealTime error");
251 case kPortRegistrationOnCallback:
252 jack_log(
"JackClient::kPortRegistrationOn port_index = %ld", value1);
253 if (fPortRegistration) {
254 fPortRegistration(value1, 1, fPortRegistrationArg);
258 case kPortRegistrationOffCallback:
259 jack_log(
"JackClient::kPortRegistrationOff port_index = %ld ", value1);
260 if (fPortRegistration) {
261 fPortRegistration(value1, 0, fPortRegistrationArg);
265 case kPortConnectCallback:
266 jack_log(
"JackClient::kPortConnectCallback src = %ld dst = %ld", value1, value2);
268 fPortConnect(value1, value2, 1, fPortConnectArg);
272 case kPortDisconnectCallback:
273 jack_log(
"JackClient::kPortDisconnectCallback src = %ld dst = %ld", value1, value2);
275 fPortConnect(value1, value2, 0, fPortConnectArg);
279 case kPortRenameCallback:
280 jack_log(
"JackClient::kPortRenameCallback port = %ld", value1);
282 fPortRename(value1, message, GetGraphManager()->GetPort(value1)->GetName(), fPortRenameArg);
287 jack_log(
"JackClient::kXRunCallback");
289 res = fXrun(fXrunArg);
293 case kShutDownCallback:
294 jack_log(
"JackClient::kShutDownCallback");
296 fInfoShutdown((jack_status_t)value1, message, fInfoShutdownArg);
297 fInfoShutdown = NULL;
301 case kSessionCallback:
302 jack_log(
"JackClient::kSessionCallback");
305 char uuid_buf[JACK_UUID_SIZE];
306 event->
type = (jack_session_event_type_t)value1;
307 event->session_dir = strdup(message);
308 event->command_line = NULL;
310 snprintf(uuid_buf,
sizeof(uuid_buf),
"%d", GetClientControl()->fSessionID);
311 event->client_uuid = strdup(uuid_buf);
312 fSessionReply = kPendingSessionReply;
314 fSession(event, fSessionArg);
319 case kLatencyCallback:
320 res = HandleLatencyCallback(value1);
328 int JackClient::HandleLatencyCallback(
int status)
330 jack_latency_callback_mode_t mode = (status == 0) ? JackCaptureLatency : JackPlaybackLatency;
336 list<jack_port_id_t>::iterator it;
338 for (it = fPortList.begin(); it != fPortList.end(); it++) {
339 JackPort* port = GetGraphManager()->GetPort(*it);
340 if ((port->GetFlags() & JackPortIsOutput) && (mode == JackPlaybackLatency)) {
341 GetGraphManager()->RecalculateLatency(*it, mode);
343 if ((port->GetFlags() & JackPortIsInput) && (mode == JackCaptureLatency)) {
344 GetGraphManager()->RecalculateLatency(*it, mode);
354 if (mode == JackPlaybackLatency) {
357 for (it = fPortList.begin(); it != fPortList.end(); it++) {
358 JackPort* port = GetGraphManager()->GetPort(*it);
359 if (port->GetFlags() & JackPortIsOutput) {
361 port->GetLatencyRange(mode, &other_latency);
362 if (other_latency.
max > latency.
max) {
363 latency.
max = other_latency.
max;
365 if (other_latency.
min < latency.
min) {
366 latency.
min = other_latency.
min;
371 if (latency.
min == UINT32_MAX) {
377 for (it = fPortList.begin(); it != fPortList.end(); it++) {
378 JackPort* port = GetGraphManager()->GetPort(*it);
379 if (port->GetFlags() & JackPortIsInput) {
380 port->SetLatencyRange(mode, &latency);
384 if (mode == JackCaptureLatency) {
387 for (it = fPortList.begin(); it != fPortList.end(); it++) {
388 JackPort* port = GetGraphManager()->GetPort(*it);
389 if (port->GetFlags() & JackPortIsInput) {
391 port->GetLatencyRange(mode, &other_latency);
392 if (other_latency.
max > latency.
max) {
393 latency.
max = other_latency.
max;
395 if (other_latency.
min < latency.
min) {
396 latency.
min = other_latency.
min;
401 if (latency.
min == UINT32_MAX) {
407 for (it = fPortList.begin(); it != fPortList.end(); it++) {
408 JackPort* port = GetGraphManager()->GetPort(*it);
409 if (port->GetFlags() & JackPortIsOutput) {
410 port->SetLatencyRange(mode, &latency);
420 fLatency(mode, fLatencyArg);
437 if (StartThread() < 0) {
446 GetClientControl()->fActive =
true;
449 GetClientControl()->fTransportSync =
true;
450 GetClientControl()->fTransportTimebase =
true;
453 GetClientControl()->fCallback[kRealTimeCallback] = IsRealTime();
454 fChannel->ClientActivate(GetClientControl()->fRefNum, IsRealTime(), &result);
468 GetClientControl()->fActive =
false;
471 GetClientControl()->fTransportSync =
false;
472 GetClientControl()->fTransportTimebase =
false;
476 fChannel->ClientDeactivate(GetClientControl()->fRefNum, &result);
477 jack_log(
"JackClient::Deactivate res = %ld", result);
490 void JackClient::InitAux()
493 jack_log(
"JackClient::Init calling client thread init callback");
510 jack_log(
"JackClient::kBufferSizeCallback buffer_size = %ld", GetEngineControl()->fBufferSize);
512 fBufferSize(GetEngineControl()->fBufferSize, fBufferSizeArg);
519 if (!jack_tls_set(JackGlobals::fRealTimeThread,
this)) {
520 jack_error(
"Failed to set thread realtime key");
523 if (GetEngineControl()->fRealTime) {
524 set_threaded_log_function();
528 if (GetEngineControl()->fRealTime) {
529 if (fThread.AcquireSelfRealTime(GetEngineControl()->fClientPriority) < 0) {
530 jack_error(
"JackClient::AcquireSelfRealTime error");
537 int JackClient::StartThread()
539 jack_log(
"JackClient::StartThread : period = %ld computation = %ld constraint = %ld",
540 long(int64_t(GetEngineControl()->fPeriod) / 1000.0f),
541 long(int64_t(GetEngineControl()->fComputation) / 1000.0f),
542 long(int64_t(GetEngineControl()->fConstraint) / 1000.0f));
545 fThread.SetParams(GetEngineControl()->fPeriod, GetEngineControl()->fComputation, GetEngineControl()->fConstraint);
547 if (fThread.StartSync() < 0) {
565 fThreadFun(fThreadFunArg);
572 void JackClient::DummyCycle()
578 inline void JackClient::ExecuteThread()
582 CycleSignalAux(CallProcessCallback());
586 inline jack_nframes_t JackClient::CycleWaitAux()
591 CallSyncCallbackAux();
592 return GetEngineControl()->fBufferSize;
595 inline void JackClient::CycleSignalAux(
int status)
598 CallTimebaseCallbackAux();
606 jack_nframes_t JackClient::CycleWait()
608 return CycleWaitAux();
611 void JackClient::CycleSignal(
int status)
613 CycleSignalAux(status);
616 inline int JackClient::CallProcessCallback()
618 return (fProcess != NULL) ? fProcess(GetEngineControl()->fBufferSize, fProcessArg) : 0;
621 inline bool JackClient::WaitSync()
624 if (GetGraphManager()->SuspendRefNum(GetClientControl(), fSynchroTable, 0x7FFFFFFF) < 0) {
632 inline void JackClient::SignalSync()
635 if (GetGraphManager()->ResumeRefNum(GetClientControl(), fSynchroTable) < 0) {
640 inline void JackClient::End()
642 jack_log(
"JackClient::Execute end name = %s", GetClientControl()->fName);
645 fThread.DropSelfRealTime();
646 GetClientControl()->fActive =
false;
647 fChannel->ClientDeactivate(GetClientControl()->fRefNum, &result);
651 inline void JackClient::Error()
653 jack_error(
"JackClient::Execute error name = %s", GetClientControl()->fName);
656 fThread.DropSelfRealTime();
657 GetClientControl()->fActive =
false;
658 fChannel->ClientDeactivate(GetClientControl()->fRefNum, &result);
667 int JackClient::PortRegister(
const char* port_name,
const char* port_type,
unsigned long flags,
unsigned long buffer_size)
670 string port_name_str = string(port_name);
671 if (port_name_str.size() == 0) {
677 string name = string(GetClientControl()->fName) + string(
":") + port_name_str;
678 if (name.size() >= REAL_JACK_PORT_NAME_SIZE) {
679 jack_error(
"\"%s:%s\" is too long to be used as a JACK port name.\n"
680 "Please use %lu characters or less",
681 GetClientControl()->fName,
683 JACK_PORT_NAME_SIZE - 1);
688 jack_port_id_t port_index = NO_PORT;
689 fChannel->PortRegister(GetClientControl()->fRefNum, name.c_str(), port_type, flags, buffer_size, &port_index, &result);
692 jack_log(
"JackClient::PortRegister ref = %ld name = %s type = %s port_index = %ld", GetClientControl()->fRefNum, name.c_str(), port_type, port_index);
693 fPortList.push_back(port_index);
700 int JackClient::PortUnRegister(jack_port_id_t port_index)
702 jack_log(
"JackClient::PortUnRegister port_index = %ld", port_index);
703 list<jack_port_id_t>::iterator it = find(fPortList.begin(), fPortList.end(), port_index);
705 if (it != fPortList.end()) {
708 fChannel->PortUnRegister(GetClientControl()->fRefNum, port_index, &result);
711 jack_error(
"unregistering a port %ld that is not own by the client", port_index);
716 int JackClient::PortConnect(
const char* src,
const char* dst)
718 jack_log(
"JackClient::Connect src = %s dst = %s", src, dst);
720 fChannel->PortConnect(GetClientControl()->fRefNum, src, dst, &result);
724 int JackClient::PortDisconnect(
const char* src,
const char* dst)
726 jack_log(
"JackClient::Disconnect src = %s dst = %s", src, dst);
728 fChannel->PortDisconnect(GetClientControl()->fRefNum, src, dst, &result);
732 int JackClient::PortDisconnect(jack_port_id_t src)
734 jack_log(
"JackClient::PortDisconnect src = %ld", src);
736 fChannel->PortDisconnect(GetClientControl()->fRefNum, src, ALL_PORTS, &result);
740 int JackClient::PortIsMine(jack_port_id_t port_index)
742 JackPort* port = GetGraphManager()->GetPort(port_index);
743 return GetClientControl()->fRefNum == port->GetRefNum();
746 int JackClient::PortRename(jack_port_id_t port_index,
const char* name)
749 fChannel->PortRename(GetClientControl()->fRefNum, port_index, name, &result);
757 int JackClient::SetBufferSize(jack_nframes_t buffer_size)
760 fChannel->SetBufferSize(buffer_size, &result);
764 int JackClient::SetFreeWheel(
int onoff)
767 fChannel->SetFreewheel(onoff, &result);
771 int JackClient::ComputeTotalLatencies()
774 fChannel->ComputeTotalLatencies(&result);
782 inline int JackClient::ActivateAux()
785 if (IsActive() && fThread.GetStatus() != JackThread::kRunning) {
787 jack_log(
"JackClient::ActivateAux");
790 if (StartThread() < 0) {
795 GetClientControl()->fCallback[kRealTimeCallback] = IsRealTime();
796 fChannel->ClientActivate(GetClientControl()->fRefNum, IsRealTime(), &result);
804 int JackClient::ReleaseTimebase()
807 fChannel->ReleaseTimebase(GetClientControl()->fRefNum, &result);
809 GetClientControl()->fTransportTimebase =
false;
817 int JackClient::SetSyncCallback(JackSyncCallback sync_callback,
void* arg)
819 GetClientControl()->fTransportSync = (fSync != NULL);
821 fSync = sync_callback;
822 return ActivateAux();
825 int JackClient::SetTimebaseCallback(
int conditional, JackTimebaseCallback timebase_callback,
void* arg)
828 fChannel->SetTimebaseCallback(GetClientControl()->fRefNum, conditional, &result);
831 GetClientControl()->fTransportTimebase =
true;
832 fTimebase = timebase_callback;
834 return ActivateAux();
842 int JackClient::SetSyncTimeout(jack_time_t timeout)
844 GetEngineControl()->fTransport.SetSyncTimeout(timeout);
850 void JackClient::TransportLocate(jack_nframes_t frame)
854 pos.
valid = (jack_position_bits_t)0;
855 jack_log(
"JackClient::TransportLocate pos = %ld", pos.
frame);
856 GetEngineControl()->fTransport.RequestNewPos(&pos);
862 jack_log(
"JackClient::TransportReposition pos = %ld", pos->
frame);
863 if (tmp.
valid & ~JACK_POSITION_MASK) {
866 GetEngineControl()->fTransport.RequestNewPos(&tmp);
871 jack_transport_state_t JackClient::TransportQuery(
jack_position_t* pos)
873 return GetEngineControl()->fTransport.Query(pos);
876 jack_nframes_t JackClient::GetCurrentTransportFrame()
878 return GetEngineControl()->fTransport.GetCurrentFrame();
882 void JackClient::TransportStart()
884 GetEngineControl()->fTransport.SetCommand(TransportCommandStart);
888 void JackClient::TransportStop()
890 GetEngineControl()->fTransport.SetCommand(TransportCommandStop);
896 void JackClient::CallSyncCallback()
898 CallSyncCallbackAux();
901 inline void JackClient::CallSyncCallbackAux()
903 if (GetClientControl()->fTransportSync) {
905 JackTransportEngine& transport = GetEngineControl()->fTransport;
907 jack_transport_state_t transport_state = transport.GetState();
910 if (fSync(transport_state, cur_pos, fSyncArg)) {
911 GetClientControl()->fTransportState = JackTransportRolling;
912 GetClientControl()->fTransportSync =
false;
915 GetClientControl()->fTransportState = JackTransportRolling;
916 GetClientControl()->fTransportSync =
false;
921 void JackClient::CallTimebaseCallback()
923 CallTimebaseCallbackAux();
926 inline void JackClient::CallTimebaseCallbackAux()
928 JackTransportEngine& transport = GetEngineControl()->fTransport;
932 transport.GetTimebaseMaster(master, unused);
934 if (GetClientControl()->fRefNum == master && fTimebase) {
936 jack_transport_state_t transport_state = transport.GetState();
939 if (GetClientControl()->fTransportTimebase) {
940 fTimebase(transport_state, GetEngineControl()->fBufferSize, cur_pos,
true, fTimebaseArg);
941 GetClientControl()->fTransportTimebase =
false;
942 }
else if (transport_state == JackTransportRolling) {
943 fTimebase(transport_state, GetEngineControl()->fBufferSize, cur_pos,
false, fTimebaseArg);
946 transport.WriteNextStateStop(1);
954 void JackClient::OnShutdown(JackShutdownCallback callback,
void *arg)
957 jack_error(
"You cannot set callbacks on an active client");
960 fShutdown = callback;
964 void JackClient::OnInfoShutdown(JackInfoShutdownCallback callback,
void *arg)
967 jack_error(
"You cannot set callbacks on an active client");
969 GetClientControl()->fCallback[kShutDownCallback] = (callback != NULL);
970 fInfoShutdownArg = arg;
971 fInfoShutdown = callback;
975 int JackClient::SetProcessCallback(JackProcessCallback callback,
void *arg)
978 jack_error(
"You cannot set callbacks on an active client");
980 }
else if (fThreadFun) {
981 jack_error (
"A thread callback has already been setup, both models cannot be used at the same time!");
990 int JackClient::SetXRunCallback(JackXRunCallback callback,
void *arg)
993 jack_error(
"You cannot set callbacks on an active client");
996 GetClientControl()->fCallback[kXRunCallback] = (callback != NULL);
1003 int JackClient::SetInitCallback(JackThreadInitCallback callback,
void *arg)
1006 jack_error(
"You cannot set callbacks on an active client");
1012 return JackMessageBuffer::fInstance->SetInitCallback(callback, arg);
1016 int JackClient::SetGraphOrderCallback(JackGraphOrderCallback callback,
void *arg)
1019 jack_error(
"You cannot set callbacks on an active client");
1022 GetClientControl()->fCallback[kGraphOrderCallback] = (callback != NULL);
1023 fGraphOrder = callback;
1024 fGraphOrderArg = arg;
1029 int JackClient::SetBufferSizeCallback(JackBufferSizeCallback callback,
void *arg)
1032 jack_error(
"You cannot set callbacks on an active client");
1035 GetClientControl()->fCallback[kBufferSizeCallback] = (callback != NULL);
1036 fBufferSizeArg = arg;
1037 fBufferSize = callback;
1042 int JackClient::SetSampleRateCallback(JackSampleRateCallback callback,
void *arg)
1045 jack_error(
"You cannot set callbacks on an active client");
1048 GetClientControl()->fCallback[kSampleRateCallback] = (callback != NULL);
1049 fSampleRateArg = arg;
1050 fSampleRate = callback;
1053 callback(GetEngineControl()->fSampleRate, arg);
1059 int JackClient::SetClientRegistrationCallback(JackClientRegistrationCallback callback,
void* arg)
1062 jack_error(
"You cannot set callbacks on an active client");
1066 fClientRegistrationArg = arg;
1067 fClientRegistration = callback;
1072 int JackClient::SetFreewheelCallback(JackFreewheelCallback callback,
void *arg)
1075 jack_error(
"You cannot set callbacks on an active client");
1078 GetClientControl()->fCallback[kStartFreewheelCallback] = (callback != NULL);
1079 GetClientControl()->fCallback[kStopFreewheelCallback] = (callback != NULL);
1080 fFreewheelArg = arg;
1081 fFreewheel = callback;
1086 int JackClient::SetPortRegistrationCallback(JackPortRegistrationCallback callback,
void *arg)
1089 jack_error(
"You cannot set callbacks on an active client");
1092 GetClientControl()->fCallback[kPortRegistrationOnCallback] = (callback != NULL);
1093 GetClientControl()->fCallback[kPortRegistrationOffCallback] = (callback != NULL);
1094 fPortRegistrationArg = arg;
1095 fPortRegistration = callback;
1100 int JackClient::SetPortConnectCallback(JackPortConnectCallback callback,
void *arg)
1103 jack_error(
"You cannot set callbacks on an active client");
1106 GetClientControl()->fCallback[kPortConnectCallback] = (callback != NULL);
1107 GetClientControl()->fCallback[kPortDisconnectCallback] = (callback != NULL);
1108 fPortConnectArg = arg;
1109 fPortConnect = callback;
1114 int JackClient::SetPortRenameCallback(JackPortRenameCallback callback,
void *arg)
1117 jack_error(
"You cannot set callbacks on an active client");
1120 GetClientControl()->fCallback[kPortRenameCallback] = (callback != NULL);
1121 fPortRenameArg = arg;
1122 fPortRename = callback;
1127 int JackClient::SetProcessThread(JackThreadCallback fun,
void *arg)
1130 jack_error(
"You cannot set callbacks on an active client");
1132 }
else if (fProcess) {
1133 jack_error(
"A process callback has already been setup, both models cannot be used at the same time!");
1137 fThreadFunArg = arg;
1145 jack_error(
"You cannot set callbacks on an active client");
1148 GetClientControl()->fCallback[kSessionCallback] = (callback != NULL);
1150 fSession = callback;
1155 int JackClient::SetLatencyCallback(JackLatencyCallback callback,
void *arg)
1158 jack_error(
"You cannot set callbacks on an active client");
1163 fLatency = callback;
1172 char* JackClient::GetInternalClientName(
int ref)
1174 char name_res[JACK_CLIENT_NAME_SIZE + 1];
1176 fChannel->GetInternalClientName(GetClientControl()->fRefNum, ref, name_res, &result);
1177 return (result < 0) ? NULL : strdup(name_res);
1180 int JackClient::InternalClientHandle(
const char* client_name, jack_status_t* status)
1182 int int_ref, result = -1;
1183 fChannel->InternalClientHandle(GetClientControl()->fRefNum, client_name, (
int*)status, &int_ref, &result);
1187 int JackClient::InternalClientLoad(
const char* client_name, jack_options_t options, jack_status_t* status,
jack_varargs_t* va)
1189 if (strlen(client_name) >= JACK_CLIENT_NAME_SIZE) {
1190 jack_error (
"\"%s\" is too long for a JACK client name.\n"
1191 "Please use %lu characters or less.",
1192 client_name, JACK_CLIENT_NAME_SIZE);
1196 if (va->load_name && (strlen(va->load_name) >= JACK_PATH_MAX)) {
1197 jack_error(
"\"%s\" is too long for a shared object name.\n"
1198 "Please use %lu characters or less.",
1199 va->load_name, JACK_PATH_MAX);
1200 int my_status1 = *status | (JackFailure | JackInvalidOption);
1201 *status = (jack_status_t)my_status1;
1205 if (va->load_init && (strlen(va->load_init) >= JACK_LOAD_INIT_LIMIT)) {
1206 jack_error (
"\"%s\" is too long for internal client init "
1207 "string.\nPlease use %lu characters or less.",
1208 va->load_init, JACK_LOAD_INIT_LIMIT);
1209 int my_status1 = *status | (JackFailure | JackInvalidOption);
1210 *status = (jack_status_t)my_status1;
1214 int int_ref, result = -1;
1215 fChannel->InternalClientLoad(GetClientControl()->fRefNum, client_name, va->load_name, va->load_init, options, (
int*)status, &int_ref, -1, &result);
1219 void JackClient::InternalClientUnload(
int ref, jack_status_t* status)
1222 fChannel->InternalClientUnload(GetClientControl()->fRefNum, ref, (
int*)status, &result);
1229 jack_session_command_t* JackClient::SessionNotify(
const char* target, jack_session_event_type_t type,
const char* path)
1232 fChannel->SessionNotify(GetClientControl()->fRefNum, target, type, path, &res);
1239 strncpy(GetClientControl()->fSessionCommand, ev->
command_line,
sizeof(GetClientControl()->fSessionCommand));
1241 GetClientControl()->fSessionCommand[0] =
'\0';
1244 GetClientControl()->fSessionFlags = ev->
flags;
1246 jack_log(
"JackClient::SessionReply... we are here");
1247 if (fChannel->IsChannelThread()) {
1248 jack_log(
"JackClient::SessionReply... in callback reply");
1250 fSessionReply = kImmediateSessionReply;
1254 jack_log(
"JackClient::SessionReply... out of cb");
1257 fChannel->SessionReply(GetClientControl()->fRefNum, &result);
1261 char* JackClient::GetUUIDForClientName(
const char* client_name)
1263 char uuid_res[JACK_UUID_SIZE];
1265 fChannel->GetUUIDForClientName(GetClientControl()->fRefNum, client_name, uuid_res, &result);
1266 return (result) ? NULL : strdup(uuid_res);
1269 char* JackClient::GetClientNameByUUID(
const char* uuid)
1271 char name_res[JACK_CLIENT_NAME_SIZE + 1];
1273 fChannel->GetClientNameForUUID(GetClientControl()->fRefNum, uuid, name_res, &result);
1274 return (result) ? NULL : strdup(name_res);
1277 int JackClient::ReserveClientName(
const char* client_name,
const char* uuid)
1280 fChannel->ReserveClientName( GetClientControl()->fRefNum, client_name, uuid, &result);
1284 int JackClient::ClientHasSessionCallback(
const char* client_name)
1287 fChannel->ClientHasSessionCallback(client_name, &result);