25 #include "JackSystemDeps.h"
26 #include "JackLockedEngine.h"
27 #include "JackExternalClient.h"
28 #include "JackInternalClient.h"
29 #include "JackEngineControl.h"
30 #include "JackClientControl.h"
31 #include "JackServerGlobals.h"
32 #include "JackGlobals.h"
33 #include "JackChannel.h"
34 #include "JackError.h"
39 JackEngine::JackEngine(JackGraphManager* manager,
41 JackEngineControl* control)
42 : JackLockAble(control->fServerName),
43 fSignal(control->fServerName)
45 fGraphManager = manager;
46 fSynchroTable = table;
47 fEngineControl = control;
48 for (
int i = 0; i < CLIENT_NUM; i++) {
49 fClientTable[i] = NULL;
53 fSessionPendingReplies = 0;
54 fSessionTransaction = NULL;
55 fSessionResult = NULL;
58 JackEngine::~JackEngine()
61 int JackEngine::Open()
66 if (fChannel.Open(fEngineControl->fServerName) < 0) {
74 int JackEngine::Close()
80 for (
int i = fEngineControl->fDriverNum; i < CLIENT_NUM; i++) {
81 if (JackLoadableInternalClient* loadable_client = dynamic_cast<JackLoadableInternalClient*>(fClientTable[i])) {
82 jack_log(
"JackEngine::Close loadable client = %s", loadable_client->GetClientControl()->fName);
83 loadable_client->Close();
84 fClientTable[i] = NULL;
85 delete loadable_client;
86 }
else if (JackExternalClient* external_client = dynamic_cast<JackExternalClient*>(fClientTable[i])) {
87 jack_log(
"JackEngine::Close external client = %s", external_client->GetClientControl()->fName);
88 external_client->Close();
89 fClientTable[i] = NULL;
90 delete external_client;
97 void JackEngine::ShutDown()
102 for (
int i = fEngineControl->fDriverNum; i < CLIENT_NUM; i++) {
103 if (JackLoadableInternalClient* loadable_client = dynamic_cast<JackLoadableInternalClient*>(fClientTable[i])) {
104 jack_log(
"JackEngine::ShutDown loadable client = %s", loadable_client->GetClientControl()->fName);
105 loadable_client->ShutDown();
111 void JackEngine::NotifyQuit()
113 fChannel.NotifyQuit();
120 int JackEngine::AllocateRefnum()
122 for (
int i = 0; i < CLIENT_NUM; i++) {
123 if (!fClientTable[i]) {
124 jack_log(
"JackEngine::AllocateRefNum ref = %ld", i);
131 void JackEngine::ReleaseRefnum(
int ref)
133 fClientTable[ref] = NULL;
135 if (fEngineControl->fTemporary) {
137 for (i = fEngineControl->fDriverNum; i < CLIENT_NUM; i++) {
138 if (fClientTable[i]) {
142 if (i == CLIENT_NUM) {
144 jack_log(
"JackEngine::ReleaseRefnum server quit");
145 fEngineControl->fTemporary =
false;
146 throw JackTemporaryException();
155 void JackEngine::ProcessNext(jack_time_t cur_cycle_begin)
157 fLastSwitchUsecs = cur_cycle_begin;
158 if (fGraphManager->RunNextGraph()) {
159 fChannel.Notify(ALL_CLIENTS, kGraphOrderCallback, 0);
164 void JackEngine::ProcessCurrent(jack_time_t cur_cycle_begin)
166 if (cur_cycle_begin < fLastSwitchUsecs + 2 * fEngineControl->fPeriodUsecs) {
167 CheckXRun(cur_cycle_begin);
169 fGraphManager->RunCurrentGraph();
172 bool JackEngine::Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end)
177 fEngineControl->CycleBegin(fClientTable, fGraphManager, cur_cycle_begin, prev_cycle_end);
180 if (fGraphManager->IsFinishedGraph()) {
181 ProcessNext(cur_cycle_begin);
184 jack_log(
"Process: graph not finished!");
185 if (cur_cycle_begin > fLastSwitchUsecs + fEngineControl->fTimeOutUsecs) {
186 jack_log(
"Process: switch to next state delta = %ld",
long(cur_cycle_begin - fLastSwitchUsecs));
187 ProcessNext(cur_cycle_begin);
190 jack_log(
"Process: waiting to switch delta = %ld",
long(cur_cycle_begin - fLastSwitchUsecs));
191 ProcessCurrent(cur_cycle_begin);
197 fEngineControl->CycleEnd(fClientTable);
206 static const char* State2String(jack_client_state_t state)
210 return "NotTriggered";
222 void JackEngine::CheckXRun(jack_time_t callback_usecs)
224 for (
int i = fEngineControl->fDriverNum; i < CLIENT_NUM; i++) {
225 JackClientInterface* client = fClientTable[i];
226 if (client && client->GetClientControl()->fActive) {
227 JackClientTiming* timing = fGraphManager->GetClientTiming(i);
228 jack_client_state_t status = timing->fStatus;
229 jack_time_t finished_date = timing->fFinishedAt;
231 if (status != NotTriggered && status != Finished) {
232 jack_error(
"JackEngine::XRun: client = %s was not finished, state = %s", client->GetClientControl()->fName, State2String(status));
233 fChannel.Notify(ALL_CLIENTS, kXRunCallback, 0);
236 if (status == Finished && (
long)(finished_date - callback_usecs) > 0) {
237 jack_error(
"JackEngine::XRun: client %s finished after current callback", client->GetClientControl()->fName);
238 fChannel.Notify(ALL_CLIENTS, kXRunCallback, 0);
244 int JackEngine::ComputeTotalLatencies()
246 std::vector<jack_int_t> sorted;
247 std::vector<jack_int_t>::iterator it;
248 std::vector<jack_int_t>::reverse_iterator rit;
250 fGraphManager->TopologicalSort(sorted);
256 for (it = sorted.begin(); it != sorted.end(); it++) {
257 NotifyClient(*it, kLatencyCallback,
true,
"", 0, 0);
262 for (rit = sorted.rbegin(); rit != sorted.rend(); rit++) {
263 NotifyClient(*rit, kLatencyCallback,
true,
"", 1, 0);
273 int JackEngine::ClientNotify(JackClientInterface* client,
int refnum,
const char* name,
int notify,
int sync,
const char* message,
int value1,
int value2)
279 if (!client->GetClientControl()->fCallback[notify]) {
280 jack_log(
"JackEngine::ClientNotify: no callback for notification = %ld", notify);
287 if (dynamic_cast<JackExternalClient*>(client)) {
288 ret = client->ClientNotify(refnum, name, notify, sync, message, value1, value2);
292 ret = client->ClientNotify(refnum, name, notify, sync, message, value1, value2);
299 jack_error(
"NotifyClient fails name = %s notification = %ld val1 = %ld val2 = %ld", name, notify, value1, value2);
304 void JackEngine::NotifyClient(
int refnum,
int event,
int sync,
const char* message,
int value1,
int value2)
306 JackClientInterface* client = fClientTable[refnum];
308 ClientNotify(client, refnum, client->GetClientControl()->fName, event, sync, message, value1, value2);
312 void JackEngine::NotifyClients(
int event,
int sync,
const char* message,
int value1,
int value2)
314 for (
int i = 0; i < CLIENT_NUM; i++) {
315 NotifyClient(i, event, sync, message, value1, value2);
319 int JackEngine::NotifyAddClient(JackClientInterface* new_client,
const char* new_name,
int refnum)
321 jack_log(
"JackEngine::NotifyAddClient: name = %s", new_name);
324 for (
int i = 0; i < CLIENT_NUM; i++) {
325 JackClientInterface* old_client = fClientTable[i];
326 if (old_client && old_client != new_client) {
327 char* old_name = old_client->GetClientControl()->fName;
328 if (ClientNotify(old_client, refnum, new_name, kAddClient,
false,
"", 0, 0) < 0) {
329 jack_error(
"NotifyAddClient old_client fails name = %s", old_name);
332 if (ClientNotify(new_client, i, old_name, kAddClient,
true,
"", 0, 0) < 0) {
333 jack_error(
"NotifyAddClient new_client fails name = %s", new_name);
342 void JackEngine::NotifyRemoveClient(
const char* name,
int refnum)
345 for (
int i = 0; i < CLIENT_NUM; i++) {
346 ClientNotify(fClientTable[i], refnum, name, kRemoveClient,
false,
"", 0, 0);
351 void JackEngine::NotifyXRun(jack_time_t callback_usecs,
float delayed_usecs)
354 fEngineControl->NotifyXRun(callback_usecs, delayed_usecs);
355 fChannel.Notify(ALL_CLIENTS, kXRunCallback, 0);
358 void JackEngine::NotifyXRun(
int refnum)
360 if (refnum == ALL_CLIENTS) {
361 NotifyClients(kXRunCallback,
false,
"", 0, 0);
363 NotifyClient(refnum, kXRunCallback,
false,
"", 0, 0);
367 void JackEngine::NotifyGraphReorder()
369 ComputeTotalLatencies();
370 NotifyClients(kGraphOrderCallback,
false,
"", 0, 0);
373 void JackEngine::NotifyBufferSize(jack_nframes_t buffer_size)
375 NotifyClients(kBufferSizeCallback,
true,
"", buffer_size, 0);
378 void JackEngine::NotifySampleRate(jack_nframes_t sample_rate)
380 NotifyClients(kSampleRateCallback,
true,
"", sample_rate, 0);
383 void JackEngine::NotifyFailure(
int code,
const char* reason)
385 NotifyClients(kShutDownCallback,
false, reason, code, 0);
388 void JackEngine::NotifyFreewheel(
bool onoff)
392 fEngineControl->fSavedRealTime = fEngineControl->fRealTime;
393 fEngineControl->fRealTime =
false;
396 fEngineControl->fRealTime = fEngineControl->fSavedRealTime;
397 fEngineControl->fSavedRealTime =
false;
399 NotifyClients((onoff ? kStartFreewheelCallback : kStopFreewheelCallback),
true,
"", 0, 0);
402 void JackEngine::NotifyPortRegistation(jack_port_id_t port_index,
bool onoff)
404 NotifyClients((onoff ? kPortRegistrationOnCallback : kPortRegistrationOffCallback),
false,
"", port_index, 0);
407 void JackEngine::NotifyPortRename(jack_port_id_t port,
const char* old_name)
409 NotifyClients(kPortRenameCallback,
false, old_name, port, 0);
412 void JackEngine::NotifyPortConnect(jack_port_id_t src, jack_port_id_t dst,
bool onoff)
414 NotifyClients((onoff ? kPortConnectCallback : kPortDisconnectCallback),
false,
"", src, dst);
417 void JackEngine::NotifyActivate(
int refnum)
419 NotifyClient(refnum, kActivateClient,
true,
"", 0, 0);
426 int JackEngine::GetInternalClientName(
int refnum,
char* name_res)
428 JackClientInterface* client = fClientTable[refnum];
429 strncpy(name_res, client->GetClientControl()->fName, JACK_CLIENT_NAME_SIZE);
433 int JackEngine::InternalClientHandle(
const char* client_name,
int* status,
int* int_ref)
438 for (
int i = 0; i < CLIENT_NUM; i++) {
439 JackClientInterface* client = fClientTable[i];
440 if (client && dynamic_cast<JackLoadableInternalClient*>(client) && (strcmp(client->GetClientControl()->fName, client_name) == 0)) {
441 jack_log(
"InternalClientHandle found client name = %s ref = %ld", client_name, i);
447 *status |= (JackNoSuchClient | JackFailure);
451 int JackEngine::InternalClientUnload(
int refnum,
int* status)
453 JackClientInterface* client = fClientTable[refnum];
455 int res = client->Close();
460 *status = (JackNoSuchClient | JackFailure);
469 int JackEngine::ClientCheck(
const char* name,
int uuid,
char* name_res,
int protocol,
int options,
int* status)
473 strcpy(name_res, name);
475 jack_log(
"Check protocol client = %ld server = %ld", protocol, JACK_PROTOCOL_VERSION);
477 if (protocol != JACK_PROTOCOL_VERSION) {
478 *status |= (JackFailure | JackVersionError);
479 jack_error(
"JACK protocol mismatch (%d vs %d)", protocol, JACK_PROTOCOL_VERSION);
483 std::map<int,std::string>::iterator res = fReservationMap.find(uuid);
485 if (res != fReservationMap.end()) {
486 strncpy(name_res, res->second.c_str(), JACK_CLIENT_NAME_SIZE);
487 }
else if (ClientCheckName(name)) {
489 *status |= JackNameNotUnique;
491 if (options & JackUseExactName) {
492 jack_error(
"cannot create new client; %s already exists", name);
493 *status |= JackFailure;
497 if (GenerateUniqueName(name_res)) {
498 *status |= JackFailure;
506 bool JackEngine::GenerateUniqueName(
char* name)
509 int length = strlen(name);
511 if (length > JACK_CLIENT_NAME_SIZE - 4) {
512 jack_error(
"%s exists and is too long to make unique", name);
517 name[length++] =
'-';
524 while (ClientCheckName(name)) {
525 if (name[ones] ==
'9') {
526 if (name[tens] ==
'9') {
527 jack_error(
"client %s has 99 extra instances already", name);
539 bool JackEngine::ClientCheckName(
const char* name)
541 for (
int i = 0; i < CLIENT_NUM; i++) {
542 JackClientInterface* client = fClientTable[i];
543 if (client && (strcmp(client->GetClientControl()->fName, name) == 0)) {
548 for (std::map<int,std::string>::iterator i = fReservationMap.begin(); i != fReservationMap.end(); i++) {
549 if (i->second == name) {
557 int JackEngine::GetNewUUID()
562 void JackEngine::EnsureUUID(
int uuid)
564 if (uuid > fMaxUUID) {
568 for (
int i = 0; i < CLIENT_NUM; i++) {
569 JackClientInterface* client = fClientTable[i];
570 if (client && (client->GetClientControl()->fSessionID == uuid)) {
571 client->GetClientControl()->fSessionID = GetNewUUID();
576 int JackEngine::GetClientPID(
const char* name)
578 for (
int i = 0; i < CLIENT_NUM; i++) {
579 JackClientInterface* client = fClientTable[i];
580 if (client && (strcmp(client->GetClientControl()->fName, name) == 0)) {
581 return client->GetClientControl()->fPID;
588 int JackEngine::GetClientRefNum(
const char* name)
590 for (
int i = 0; i < CLIENT_NUM; i++) {
591 JackClientInterface* client = fClientTable[i];
592 if (client && (strcmp(client->GetClientControl()->fName, name) == 0)) {
593 return client->GetClientControl()->fRefNum;
601 int JackEngine::ClientExternalOpen(
const char* name,
int pid,
int uuid,
int* ref,
int* shared_engine,
int* shared_client,
int* shared_graph_manager)
603 char real_name[JACK_CLIENT_NAME_SIZE + 1];
607 strncpy(real_name, name, JACK_CLIENT_NAME_SIZE);
609 std::map<int, std::string>::iterator res = fReservationMap.find(uuid);
610 if (res != fReservationMap.end()) {
611 strncpy(real_name, res->second.c_str(), JACK_CLIENT_NAME_SIZE);
612 fReservationMap.erase(uuid);
614 strncpy(real_name, name, JACK_CLIENT_NAME_SIZE);
619 jack_log(
"JackEngine::ClientExternalOpen: uuid = %d, name = %s ", uuid, real_name);
621 int refnum = AllocateRefnum();
627 JackExternalClient* client =
new JackExternalClient();
629 if (!fSynchroTable[refnum].Allocate(real_name, fEngineControl->fServerName, 0)) {
634 if (client->Open(real_name, pid, refnum, uuid, shared_client) < 0) {
639 if (!fSignal.LockedTimedWait(DRIVER_OPEN_TIMEOUT * 1000000)) {
645 fClientTable[refnum] = client;
647 if (NotifyAddClient(client, real_name, refnum) < 0) {
652 fGraphManager->InitRefNum(refnum);
653 fEngineControl->ResetRollingUsecs();
654 *shared_engine = fEngineControl->GetShmIndex();
655 *shared_graph_manager = fGraphManager->GetShmIndex();
661 fSynchroTable[refnum].Destroy();
662 fClientTable[refnum] = 0;
669 int JackEngine::ClientInternalOpen(
const char* name,
int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client,
bool wait)
671 jack_log(
"JackEngine::ClientInternalOpen: name = %s", name);
673 int refnum = AllocateRefnum();
679 if (!fSynchroTable[refnum].Allocate(name, fEngineControl->fServerName, 0)) {
684 if (wait && !fSignal.LockedTimedWait(DRIVER_OPEN_TIMEOUT * 1000000)) {
690 fClientTable[refnum] = client;
692 if (NotifyAddClient(client, name, refnum) < 0) {
697 fGraphManager->InitRefNum(refnum);
698 fEngineControl->ResetRollingUsecs();
699 *shared_engine = fEngineControl;
700 *shared_manager = fGraphManager;
706 fSynchroTable[refnum].Destroy();
707 fClientTable[refnum] = 0;
712 int JackEngine::ClientExternalClose(
int refnum)
714 jack_log(
"JackEngine::ClientExternalClose ref = %ld", refnum);
715 JackClientInterface* client = fClientTable[refnum];
716 int res = ClientCloseAux(refnum,
true);
723 int JackEngine::ClientInternalClose(
int refnum,
bool wait)
725 jack_log(
"JackEngine::ClientInternalClose ref = %ld", refnum);
726 return ClientCloseAux(refnum, wait);
729 int JackEngine::ClientCloseAux(
int refnum,
bool wait)
731 jack_log(
"JackEngine::ClientCloseAux ref = %ld", refnum);
733 JackClientInterface* client = fClientTable[refnum];
734 fEngineControl->fTransport.ResetTimebase(refnum);
737 jack_int_t ports[PORT_NUM_FOR_CLIENT];
740 fGraphManager->GetInputPorts(refnum, ports);
741 for (i = 0; (i < PORT_NUM_FOR_CLIENT) && (ports[i] != EMPTY); i++) {
742 PortUnRegister(refnum, ports[i]);
745 fGraphManager->GetOutputPorts(refnum, ports);
746 for (i = 0; (i < PORT_NUM_FOR_CLIENT) && (ports[i] != EMPTY); i++) {
747 PortUnRegister(refnum, ports[i]);
751 ReleaseRefnum(refnum);
754 fGraphManager->RemoveAllPorts(refnum);
758 if (!fSignal.LockedTimedWait(fEngineControl->fTimeOutUsecs * 2)) {
759 jack_error(
"JackEngine::ClientCloseAux wait error ref = %ld", refnum);
764 NotifyRemoveClient(client->GetClientControl()->fName, client->GetClientControl()->fRefNum);
767 fSynchroTable[refnum].Destroy();
768 fEngineControl->ResetRollingUsecs();
772 int JackEngine::ClientActivate(
int refnum,
bool is_real_time)
774 JackClientInterface* client = fClientTable[refnum];
775 jack_log(
"JackEngine::ClientActivate ref = %ld name = %s", refnum, client->GetClientControl()->fName);
778 fGraphManager->Activate(refnum);
782 if (!fSignal.LockedTimedWait(fEngineControl->fTimeOutUsecs * 10)) {
783 jack_error(
"JackEngine::ClientActivate wait error ref = %ld name = %s", refnum, client->GetClientControl()->fName);
786 jack_int_t input_ports[PORT_NUM_FOR_CLIENT];
787 jack_int_t output_ports[PORT_NUM_FOR_CLIENT];
788 fGraphManager->GetInputPorts(refnum, input_ports);
789 fGraphManager->GetOutputPorts(refnum, output_ports);
792 NotifyActivate(refnum);
795 for (
int i = 0; (i < PORT_NUM_FOR_CLIENT) && (input_ports[i] != EMPTY); i++) {
796 NotifyPortRegistation(input_ports[i],
true);
798 for (
int i = 0; (i < PORT_NUM_FOR_CLIENT) && (output_ports[i] != EMPTY); i++) {
799 NotifyPortRegistation(output_ports[i],
true);
807 int JackEngine::ClientDeactivate(
int refnum)
809 JackClientInterface* client = fClientTable[refnum];
810 jack_log(
"JackEngine::ClientDeactivate ref = %ld name = %s", refnum, client->GetClientControl()->fName);
812 jack_int_t input_ports[PORT_NUM_FOR_CLIENT];
813 jack_int_t output_ports[PORT_NUM_FOR_CLIENT];
814 fGraphManager->GetInputPorts(refnum, input_ports);
815 fGraphManager->GetOutputPorts(refnum, output_ports);
818 for (
int i = 0; (i < PORT_NUM_FOR_CLIENT) && (input_ports[i] != EMPTY); i++) {
819 PortDisconnect(refnum, input_ports[i], ALL_PORTS);
821 for (
int i = 0; (i < PORT_NUM_FOR_CLIENT) && (output_ports[i] != EMPTY); i++) {
822 PortDisconnect(refnum, output_ports[i], ALL_PORTS);
826 for (
int i = 0; (i < PORT_NUM_FOR_CLIENT) && (input_ports[i] != EMPTY); i++) {
827 NotifyPortRegistation(input_ports[i],
false);
829 for (
int i = 0; (i < PORT_NUM_FOR_CLIENT) && (output_ports[i] != EMPTY); i++) {
830 NotifyPortRegistation(output_ports[i],
false);
833 fGraphManager->Deactivate(refnum);
834 fLastSwitchUsecs = 0;
837 if (!fSignal.LockedTimedWait(fEngineControl->fTimeOutUsecs * 10)) {
838 jack_error(
"JackEngine::ClientDeactivate wait error ref = %ld name = %s", refnum, client->GetClientControl()->fName);
849 int JackEngine::PortRegister(
int refnum,
const char* name,
const char *type,
unsigned int flags,
unsigned int buffer_size, jack_port_id_t* port_index)
851 jack_log(
"JackEngine::PortRegister ref = %ld name = %s type = %s flags = %d buffer_size = %d", refnum, name, type, flags, buffer_size);
852 JackClientInterface* client = fClientTable[refnum];
855 if (fGraphManager->GetPort(name) != NO_PORT) {
856 jack_error(
"port_name \"%s\" already exists", name);
861 *port_index = fGraphManager->AllocatePort(refnum, name, type, (JackPortFlags)flags, fEngineControl->fBufferSize);
862 if (*port_index != NO_PORT) {
863 if (client->GetClientControl()->fActive) {
864 NotifyPortRegistation(*port_index,
true);
872 int JackEngine::PortUnRegister(
int refnum, jack_port_id_t port_index)
874 jack_log(
"JackEngine::PortUnRegister ref = %ld port_index = %ld", refnum, port_index);
875 JackClientInterface* client = fClientTable[refnum];
878 PortDisconnect(refnum, port_index, ALL_PORTS);
880 if (fGraphManager->ReleasePort(refnum, port_index) == 0) {
881 if (client->GetClientControl()->fActive) {
882 NotifyPortRegistation(port_index,
false);
890 int JackEngine::PortConnect(
int refnum,
const char* src,
const char* dst)
892 jack_log(
"JackEngine::PortConnect src = %s dst = %s", src, dst);
893 jack_port_id_t port_src, port_dst;
895 return (fGraphManager->GetTwoPorts(src, dst, &port_src, &port_dst) < 0)
897 : PortConnect(refnum, port_src, port_dst);
900 int JackEngine::PortConnect(
int refnum, jack_port_id_t src, jack_port_id_t dst)
902 jack_log(
"JackEngine::PortConnect src = %d dst = %d", src, dst);
903 JackClientInterface* client;
906 if (fGraphManager->CheckPorts(src, dst) < 0) {
910 ref = fGraphManager->GetOutputRefNum(src);
912 client = fClientTable[ref];
914 if (!client->GetClientControl()->fActive) {
915 jack_error(
"Cannot connect ports owned by inactive clients:"
916 " \"%s\" is not active", client->GetClientControl()->fName);
920 ref = fGraphManager->GetInputRefNum(dst);
922 client = fClientTable[ref];
924 if (!client->GetClientControl()->fActive) {
925 jack_error(
"Cannot connect ports owned by inactive clients:"
926 " \"%s\" is not active", client->GetClientControl()->fName);
930 int res = fGraphManager->Connect(src, dst);
932 NotifyPortConnect(src, dst,
true);
937 int JackEngine::PortDisconnect(
int refnum,
const char* src,
const char* dst)
939 jack_log(
"JackEngine::PortDisconnect src = %s dst = %s", src, dst);
940 jack_port_id_t port_src, port_dst;
942 return (fGraphManager->GetTwoPorts(src, dst, &port_src, &port_dst) < 0)
944 : PortDisconnect(refnum, port_src, port_dst);
947 int JackEngine::PortDisconnect(
int refnum, jack_port_id_t src, jack_port_id_t dst)
949 jack_log(
"JackEngine::PortDisconnect src = %d dst = %d", src, dst);
951 if (dst == ALL_PORTS) {
953 jack_int_t connections[CONNECTION_NUM_FOR_PORT];
954 fGraphManager->GetConnections(src, connections);
956 JackPort* port = fGraphManager->GetPort(src);
958 if (port->GetFlags() & JackPortIsOutput) {
959 for (
int i = 0; (i < CONNECTION_NUM_FOR_PORT) && (connections[i] != EMPTY); i++) {
960 if (PortDisconnect(refnum, src, connections[i]) != 0) {
965 for (
int i = 0; (i < CONNECTION_NUM_FOR_PORT) && (connections[i] != EMPTY); i++) {
966 if (PortDisconnect(refnum, connections[i], src) != 0) {
973 }
else if (fGraphManager->CheckPorts(src, dst) < 0) {
975 }
else if (fGraphManager->Disconnect(src, dst) == 0) {
977 NotifyPortConnect(src, dst,
false);
984 int JackEngine::PortRename(
int refnum, jack_port_id_t port,
const char* name)
986 char old_name[REAL_JACK_PORT_NAME_SIZE];
987 strcpy(old_name, fGraphManager->GetPort(port)->GetName());
988 fGraphManager->GetPort(port)->SetName(name);
989 NotifyPortRename(port, old_name);
997 void JackEngine::SessionNotify(
int refnum,
const char *target, jack_session_event_type_t type,
const char *path, detail::JackChannelTransactionInterface *socket, JackSessionNotifyResult** result)
999 if (fSessionPendingReplies != 0) {
1000 JackSessionNotifyResult res(-1);
1002 jack_log(
"JackEngine::SessionNotify ... busy");
1003 if (result != NULL) {
1009 for (
int i = 0; i < CLIENT_NUM; i++) {
1010 JackClientInterface* client = fClientTable[i];
1011 if (client && (client->GetClientControl()->fSessionID < 0)) {
1012 client->GetClientControl()->fSessionID = GetNewUUID();
1015 fSessionResult =
new JackSessionNotifyResult();
1017 for (
int i = 0; i < CLIENT_NUM; i++) {
1018 JackClientInterface* client = fClientTable[i];
1019 if (client && client->GetClientControl()->fCallback[kSessionCallback]) {
1022 if (target != NULL && strlen(target) != 0) {
1023 if (strcmp(target, client->GetClientControl()->fName)) {
1028 char path_buf[JACK_PORT_NAME_SIZE];
1029 snprintf(path_buf,
sizeof(path_buf),
"%s%s%c", path, client->GetClientControl()->fName, DIR_SEPARATOR);
1031 int res = JackTools::MkDir(path_buf);
1033 jack_error(
"JackEngine::SessionNotify: can not create session directory '%s'", path_buf);
1036 int result = client->ClientNotify(i, client->GetClientControl()->fName, kSessionCallback,
true, path_buf, (int)type, 0);
1038 if (result == kPendingSessionReply) {
1039 fSessionPendingReplies += 1;
1040 }
else if (result == kImmediateSessionReply) {
1041 char uuid_buf[JACK_UUID_SIZE];
1042 snprintf(uuid_buf,
sizeof(uuid_buf),
"%d", client->GetClientControl()->fSessionID);
1043 fSessionResult->fCommandList.push_back(JackSessionCommand(uuid_buf,
1044 client->GetClientControl()->fName,
1045 client->GetClientControl()->fSessionCommand,
1046 client->GetClientControl()->fSessionFlags));
1051 if (result != NULL) {
1052 *result = fSessionResult;
1055 if (fSessionPendingReplies == 0) {
1056 fSessionResult->Write(socket);
1057 if (result == NULL) {
1058 delete fSessionResult;
1060 fSessionResult = NULL;
1062 fSessionTransaction = socket;
1066 int JackEngine::SessionReply(
int refnum)
1068 JackClientInterface* client = fClientTable[refnum];
1069 char uuid_buf[JACK_UUID_SIZE];
1070 snprintf(uuid_buf,
sizeof(uuid_buf),
"%d", client->GetClientControl()->fSessionID);
1071 fSessionResult->fCommandList.push_back(JackSessionCommand(uuid_buf,
1072 client->GetClientControl()->fName,
1073 client->GetClientControl()->fSessionCommand,
1074 client->GetClientControl()->fSessionFlags));
1075 fSessionPendingReplies -= 1;
1077 if (fSessionPendingReplies == 0) {
1078 fSessionResult->Write(fSessionTransaction);
1079 if (fSessionTransaction != NULL) {
1080 delete fSessionResult;
1082 fSessionResult = NULL;
1088 int JackEngine::GetUUIDForClientName(
const char *client_name,
char *uuid_res)
1090 for (
int i = 0; i < CLIENT_NUM; i++) {
1091 JackClientInterface* client = fClientTable[i];
1093 if (client && (strcmp(client_name, client->GetClientControl()->fName) == 0)) {
1094 snprintf(uuid_res, JACK_UUID_SIZE,
"%d", client->GetClientControl()->fSessionID);
1102 int JackEngine::GetClientNameForUUID(
const char *uuid,
char *name_res)
1104 for (
int i = 0; i < CLIENT_NUM; i++) {
1105 JackClientInterface* client = fClientTable[i];
1111 char uuid_buf[JACK_UUID_SIZE];
1112 snprintf(uuid_buf, JACK_UUID_SIZE,
"%d", client->GetClientControl()->fSessionID);
1114 if (strcmp(uuid,uuid_buf) == 0) {
1115 strncpy(name_res, client->GetClientControl()->fName, JACK_CLIENT_NAME_SIZE);
1123 int JackEngine::ReserveClientName(
const char *name,
const char *uuid)
1125 jack_log(
"JackEngine::ReserveClientName ( name = %s, uuid = %s )", name, uuid);
1127 if (ClientCheckName(name)) {
1132 EnsureUUID(atoi(uuid));
1133 fReservationMap[atoi(uuid)] = name;
1137 int JackEngine::ClientHasSessionCallback(
const char *name)
1139 JackClientInterface* client = NULL;
1140 for (
int i = 0; i < CLIENT_NUM; i++) {
1141 client = fClientTable[i];
1142 if (client && (strcmp(client->GetClientControl()->fName, name) == 0)) {
1148 return client->GetClientControl()->fCallback[kSessionCallback];
SERVER_EXPORT void jack_error(const char *fmt,...)
SERVER_EXPORT void jack_log(const char *fmt,...)