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);
jack_session_flags_t flags
virtual int Deactivate()
Need to stop thread after deactivating in the server.
virtual int ClientNotifyImp(int refnum, const char *name, int notify, int sync, const char *message, int value1, int value)
Notification received from the server.
SERVER_EXPORT void jack_error(const char *fmt,...)
jack_position_bits_t valid
virtual int Activate()
We need to start thread before activating in the server, otherwise the FW driver connected to the cli...
void SetupDriverSync(bool freewheel)
bool Init()
Called once when the thread starts.
enum JackSessionFlags jack_session_flags_t
jack_session_event_type_t type
SERVER_EXPORT void jack_log(const char *fmt,...)
void(* JackSessionCallback)(jack_session_event_t *event, void *arg)