common/JackGraphManager.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2008 Grame
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 */
  20
  21 #include "JackGraphManager.h"
  22 #include "JackConstants.h"
  23 #include "JackError.h"
  24 #include <assert.h>
  25 #include <stdlib.h>
  26 #include <algorithm>
  27 #include <regex.h>
  28
  29 namespace Jack
  30 {
  31
  32 static void AssertPort(jack_port_id_t port_index)
  33 {
  34     if (port_index >= PORT_NUM) {
  35         jack_log("JackGraphManager::AssertPort port_index = %ld", port_index);
  36         assert(port_index < PORT_NUM);
  37     }
  38 }
  39
  40 static void AssertBufferSize(jack_nframes_t buffer_size)
  41 {
  42     if (buffer_size > BUFFER_SIZE_MAX) {
  43         jack_log("JackGraphManager::AssertBufferSize frames = %ld", buffer_size);
  44         assert(buffer_size <= BUFFER_SIZE_MAX);
  45     }
  46 }
  47
  48 JackPort* JackGraphManager::GetPort(jack_port_id_t port_index)
  49 {
  50     AssertPort(port_index);
  51     return &fPortArray[port_index];
  52 }
  53
  54 float* JackGraphManager::GetBuffer(jack_port_id_t port_index)
  55 {
  56     return fPortArray[port_index].GetBuffer();
  57 }
  58
  59 // Server
  60 void JackGraphManager::InitRefNum(int refnum)
  61 {
  62     JackConnectionManager* manager = WriteNextStateStart();
  63     manager->InitRefNum(refnum);
  64     WriteNextStateStop();
  65 }
  66
  67 // RT
  68 void JackGraphManager::RunCurrentGraph()
  69 {
  70     JackConnectionManager* manager = ReadCurrentState();
  71     manager->ResetGraph(fClientTiming);
  72 }
  73
  74 // RT
  75 bool JackGraphManager::RunNextGraph()
  76 {
  77     bool res;
  78     JackConnectionManager* manager = TrySwitchState(&res);
  79     manager->ResetGraph(fClientTiming);
  80     return res;
  81 }
  82
  83 // RT
  84 bool JackGraphManager::IsFinishedGraph()
  85 {
  86     JackConnectionManager* manager = ReadCurrentState();
  87     return (manager->GetActivation(FREEWHEEL_DRIVER_REFNUM) == 0);
  88 }
  89
  90 // RT
  91 int JackGraphManager::ResumeRefNum(JackClientControl* control, JackSynchro* table)
  92 {
  93     JackConnectionManager* manager = ReadCurrentState();
  94     return manager->ResumeRefNum(control, table, fClientTiming);
  95 }
  96
  97 // RT
  98 int JackGraphManager::SuspendRefNum(JackClientControl* control, JackSynchro* table, long usec)
  99 {
 100     JackConnectionManager* manager = ReadCurrentState();
 101     return manager->SuspendRefNum(control, table, fClientTiming, usec);
 102 }
 103
 104 // Server
 105 void JackGraphManager::DirectConnect(int ref1, int ref2)
 106 {
 107     JackConnectionManager* manager = WriteNextStateStart();
 108     manager->DirectConnect(ref1, ref2);
 109     jack_log("JackGraphManager::ConnectRefNum cur_index = %ld ref1 = %ld ref2 = %ld", CurIndex(fCounter), ref1, ref2);
 110     WriteNextStateStop();
 111 }
 112
 113 // Server
 114 void JackGraphManager::DirectDisconnect(int ref1, int ref2)
 115 {
 116     JackConnectionManager* manager = WriteNextStateStart();
 117     manager->DirectDisconnect(ref1, ref2);
 118     jack_log("JackGraphManager::DisconnectRefNum cur_index = %ld ref1 = %ld ref2 = %ld", CurIndex(fCounter), ref1, ref2);
 119     WriteNextStateStop();
 120 }
 121
 122 // Server
 123 bool JackGraphManager::IsDirectConnection(int ref1, int ref2)
 124 {
 125     JackConnectionManager* manager = ReadCurrentState();
 126     return manager->IsDirectConnection(ref1, ref2);
 127 }
 128
 129 // RT
 130 void* JackGraphManager::GetBuffer(jack_port_id_t port_index, jack_nframes_t buffer_size)
 131 {
 132     AssertPort(port_index);
 133     AssertBufferSize(buffer_size);
 134
 135     JackConnectionManager* manager = ReadCurrentState();
 136     JackPort* port = GetPort(port_index);
 137
 138     // This happens when a port has just been unregistered and is still used by the RT code
 139     if (!port->IsUsed()) {
 140         jack_log("JackGraphManager::GetBuffer : port = %ld is released state", port_index);
 141         return GetBuffer(0); // port_index 0 is not used
 142     }
 143
 144     // Output port
 145     if (port->fFlags & JackPortIsOutput) {
 146         return (port->fTied != NO_PORT) ? GetBuffer(port->fTied, buffer_size) : GetBuffer(port_index);
 147     }
 148
 149     // Input port
 150     jack_int_t len = manager->Connections(port_index);
 151
 152     // No connections : return a zero-filled buffer
 153     if (len == 0) {
 154         port->ClearBuffer(buffer_size);
 155         return port->GetBuffer();
 156
 157     // One connection
 158     } else if (len == 1) {
 159         jack_port_id_t src_index = manager->GetPort(port_index, 0);
 160
 161         // Ports in same client : copy the buffer
 162         if (GetPort(src_index)->GetRefNum() == port->GetRefNum()) {
 163             void* buffers[1];
 164             buffers[0] = GetBuffer(src_index, buffer_size);
 165             port->MixBuffers(buffers, 1, buffer_size);
 166             return port->GetBuffer();
 167         // Otherwise, use zero-copy mode, just pass the buffer of the connected (output) port.
 168         } else {
 169             return GetBuffer(src_index, buffer_size);
 170         }
 171
 172     // Multiple connections : mix all buffers
 173     } else {
 174
 175         const jack_int_t* connections = manager->GetConnections(port_index);
 176         void* buffers[CONNECTION_NUM_FOR_PORT];
 177         jack_port_id_t src_index;
 178         int i;
 179
 180         for (i = 0; (i < CONNECTION_NUM_FOR_PORT) && ((src_index = connections[i]) != EMPTY); i++) {
 181             AssertPort(src_index);
 182             buffers[i] = GetBuffer(src_index, buffer_size);
 183         }
 184
 185         port->MixBuffers(buffers, i, buffer_size);
 186         return port->GetBuffer();
 187     }
 188 }
 189
 190 // Server
 191 int JackGraphManager::RequestMonitor(jack_port_id_t port_index, bool onoff) // Client
 192 {
 193     AssertPort(port_index);
 194     JackPort* port = GetPort(port_index);
 195
 196     /**
 197     jackd.h
 198         * If @ref JackPortCanMonitor is set for this @a port, turn input
 199         * monitoring on or off. Otherwise, do nothing.
 200
 201      if (!(fFlags & JackPortCanMonitor))
 202         return -1;
 203     */
 204
 205     port->RequestMonitor(onoff);
 206
 207     const jack_int_t* connections = ReadCurrentState()->GetConnections(port_index);
 208     if ((port->fFlags & JackPortIsOutput) == 0) { // ?? Taken from jack, why not (port->fFlags  & JackPortIsInput) ?
 209         jack_port_id_t src_index;
 210         for (int i = 0; (i < CONNECTION_NUM_FOR_PORT) && ((src_index = connections[i]) != EMPTY); i++) {
 211             // XXX much worse things will happen if there is a feedback loop !!!
 212             RequestMonitor(src_index, onoff);
 213         }
 214     }
 215
 216     return 0;
 217 }
 218
 219 // Client
 220 jack_nframes_t JackGraphManager::ComputeTotalLatencyAux(jack_port_id_t port_index, jack_port_id_t src_port_index, JackConnectionManager* manager, int hop_count)
 221 {
 222     const jack_int_t* connections = manager->GetConnections(port_index);
 223     jack_nframes_t max_latency = 0;
 224     jack_port_id_t dst_index;
 225
 226     if (hop_count > 8)
 227         return GetPort(port_index)->GetLatency();
 228
 229     for (int i = 0; (i < CONNECTION_NUM_FOR_PORT) && ((dst_index = connections[i]) != EMPTY); i++) {
 230         if (src_port_index != dst_index) {
 231             AssertPort(dst_index);
 232             JackPort* dst_port = GetPort(dst_index);
 233             jack_nframes_t this_latency = (dst_port->fFlags & JackPortIsTerminal)
 234                                           ? dst_port->GetLatency()
 235                                           : ComputeTotalLatencyAux(dst_index, port_index, manager, hop_count + 1);
 236             max_latency = ((max_latency > this_latency) ? max_latency : this_latency);
 237         }
 238     }
 239
 240     return max_latency + GetPort(port_index)->GetLatency();
 241 }
 242
 243 // Client
 244 int JackGraphManager::ComputeTotalLatency(jack_port_id_t port_index)
 245 {
 246     UInt16 cur_index;
 247     UInt16 next_index;
 248     JackPort* port = GetPort(port_index);
 249     AssertPort(port_index);
 250
 251     do {
 252         cur_index = GetCurrentIndex();
 253         port->fTotalLatency = ComputeTotalLatencyAux(port_index, port_index, ReadCurrentState(), 0);
 254         next_index = GetCurrentIndex();
 255     } while (cur_index != next_index); // Until a coherent state has been read
 256
 257     jack_log("JackGraphManager::GetTotalLatency port_index = %ld total latency = %ld", port_index, port->fTotalLatency);
 258     return 0;
 259 }
 260
 261 // Client
 262 int JackGraphManager::ComputeTotalLatencies()
 263 {
 264     jack_port_id_t port_index;
 265     for (port_index = FIRST_AVAILABLE_PORT; port_index < PORT_NUM; port_index++) {
 266         JackPort* port = GetPort(port_index);
 267         if (port->IsUsed())
 268             ComputeTotalLatency(port_index);
 269     }
 270     return 0;
 271 }
 272
 273 // Server
 274 void JackGraphManager::SetBufferSize(jack_nframes_t buffer_size)
 275 {
 276     jack_log("JackGraphManager::SetBufferSize size = %ld", buffer_size);
 277
 278     jack_port_id_t port_index;
 279     for (port_index = FIRST_AVAILABLE_PORT; port_index < PORT_NUM; port_index++) {
 280         JackPort* port = GetPort(port_index);
 281         if (port->IsUsed())
 282             port->ClearBuffer(buffer_size);
 283     }
 284 }
 285
 286 // Server
 287 jack_port_id_t JackGraphManager::AllocatePortAux(int refnum, const char* port_name, const char* port_type, JackPortFlags flags)
 288 {
 289     jack_port_id_t port_index;
 290
 291     // Available ports start at FIRST_AVAILABLE_PORT (= 1), otherwise a port_index of 0 is "seen" as a NULL port by the external API...
 292     for (port_index = FIRST_AVAILABLE_PORT; port_index < PORT_NUM; port_index++) {
 293         JackPort* port = GetPort(port_index);
 294         if (!port->IsUsed()) {
 295             jack_log("JackGraphManager::AllocatePortAux port_index = %ld name = %s type = %s", port_index, port_name, port_type);
 296             if (!port->Allocate(refnum, port_name, port_type, flags))
 297                 return NO_PORT;
 298             break;
 299         }
 300     }
 301
 302     return (port_index < PORT_NUM) ? port_index : NO_PORT;
 303 }
 304
 305 // Server
 306 jack_port_id_t JackGraphManager::AllocatePort(int refnum, const char* port_name, const char* port_type, JackPortFlags flags, jack_nframes_t buffer_size)
 307 {
 308     JackConnectionManager* manager = WriteNextStateStart();
 309     jack_port_id_t port_index = AllocatePortAux(refnum, port_name, port_type, flags);
 310
 311     if (port_index != NO_PORT) {
 312         JackPort* port = GetPort(port_index);
 313         assert(port);
 314         port->ClearBuffer(buffer_size);
 315
 316         int res;
 317         if (flags & JackPortIsOutput) {
 318             res = manager->AddOutputPort(refnum, port_index);
 319         } else {
 320             res = manager->AddInputPort(refnum, port_index);
 321         }
 322         // Insertion failure
 323         if (res < 0) {
 324             port->Release();
 325             port_index = NO_PORT;
 326         }
 327     }
 328
 329     WriteNextStateStop();
 330     return port_index;
 331 }
 332
 333 // Server
 334 int JackGraphManager::ReleasePort(int refnum, jack_port_id_t port_index)
 335 {
 336     JackConnectionManager* manager = WriteNextStateStart();
 337     JackPort* port = GetPort(port_index);
 338     int res;
 339
 340     if (port->fFlags & JackPortIsOutput) {
 341         DisconnectAllOutput(port_index);
 342         res = manager->RemoveOutputPort(refnum, port_index);
 343     } else {
 344         DisconnectAllInput(port_index);
 345         res = manager->RemoveInputPort(refnum, port_index);
 346     }
 347
 348     port->Release();
 349     WriteNextStateStop();
 350     return res;
 351 }
 352
 353 void JackGraphManager::GetInputPorts(int refnum, jack_int_t* res)
 354 {
 355     JackConnectionManager* manager = WriteNextStateStart();
 356     const jack_int_t* input = manager->GetInputPorts(refnum);
 357     memcpy(res, input, sizeof(jack_int_t) * PORT_NUM_FOR_CLIENT);
 358     WriteNextStateStop();
 359 }
 360
 361 void JackGraphManager::GetOutputPorts(int refnum, jack_int_t* res)
 362 {
 363     JackConnectionManager* manager = WriteNextStateStart();
 364     const jack_int_t* output = manager->GetOutputPorts(refnum);
 365     memcpy(res, output, sizeof(jack_int_t) * PORT_NUM_FOR_CLIENT);
 366     WriteNextStateStop();
 367 }
 368
 369 // Server
 370 void JackGraphManager::RemoveAllPorts(int refnum)
 371 {
 372     jack_log("JackGraphManager::RemoveAllPorts ref = %ld", refnum);
 373     JackConnectionManager* manager = WriteNextStateStart();
 374     jack_port_id_t port_index;
 375
 376     // Warning : ReleasePort shift port to left, thus we always remove the first port until the "input" table is empty
 377     const jack_int_t* input = manager->GetInputPorts(refnum);
 378     while ((port_index = input[0]) != EMPTY) {
 379         int res = ReleasePort(refnum, port_index);
 380         if (res < 0) {
 381             jack_error("JackGraphManager::RemoveAllPorts failure ref = %ld port_index = %ld", refnum, port_index);
 382             assert(true);
 383             break;
 384         }
 385     }
 386
 387     // Warning : ReleasePort shift port to left, thus we always remove the first port until the "output" table is empty
 388     const jack_int_t* output = manager->GetOutputPorts(refnum);
 389     while ((port_index = output[0]) != EMPTY) {
 390         int res = ReleasePort(refnum, port_index);
 391         if (res < 0) {
 392             jack_error("JackGraphManager::RemoveAllPorts failure ref = %ld port_index = %ld", refnum, port_index);
 393             assert(true);
 394             break;
 395         }
 396     }
 397
 398     WriteNextStateStop();
 399 }
 400
 401 // Server
 402 void JackGraphManager::DisconnectAllPorts(int refnum)
 403 {
 404     int i;
 405     jack_log("JackGraphManager::DisconnectAllPorts ref = %ld", refnum);
 406     JackConnectionManager* manager = WriteNextStateStart();
 407
 408     const jack_int_t* input = manager->GetInputPorts(refnum);
 409     for (i = 0; i < PORT_NUM_FOR_CLIENT && input[i] != EMPTY ; i++) {
 410         DisconnectAllInput(input[i]);
 411     }
 412
 413     const jack_int_t* output = manager->GetOutputPorts(refnum);
 414     for (i = 0; i < PORT_NUM_FOR_CLIENT && output[i] != EMPTY; i++) {
 415         DisconnectAllOutput(output[i]);
 416     }
 417
 418     WriteNextStateStop();
 419 }
 420
 421 // Server
 422 void JackGraphManager::DisconnectAllInput(jack_port_id_t port_index)
 423 {
 424     jack_log("JackGraphManager::DisconnectAllInput port_index = %ld", port_index);
 425     JackConnectionManager* manager = WriteNextStateStart();
 426
 427     for (int i = 0; i < PORT_NUM; i++) {
 428         if (manager->IsConnected(i, port_index)) {
 429             jack_log("JackGraphManager::Disconnect i = %ld  port_index = %ld", i, port_index);
 430             Disconnect(i, port_index);
 431         }
 432     }
 433     WriteNextStateStop();
 434 }
 435
 436 // Server
 437 void JackGraphManager::DisconnectAllOutput(jack_port_id_t port_index)
 438 {
 439     jack_log("JackGraphManager::DisconnectAllOutput port_index = %ld ", port_index);
 440     JackConnectionManager* manager = WriteNextStateStart();
 441
 442     const jack_int_t* connections = manager->GetConnections(port_index);
 443     while (connections[0] != EMPTY) {
 444         Disconnect(port_index, connections[0]); // Warning : Disconnect shift port to left
 445     }
 446     WriteNextStateStop();
 447 }
 448
 449 // Server
 450 int JackGraphManager::DisconnectAll(jack_port_id_t port_index)
 451 {
 452     AssertPort(port_index);
 453
 454     JackPort* port = GetPort(port_index);
 455     if (port->fFlags & JackPortIsOutput) {
 456         DisconnectAllOutput(port_index);
 457     } else {
 458         DisconnectAllInput(port_index);
 459     }
 460     return 0;
 461 }
 462
 463 // Server
 464 void JackGraphManager::GetConnections(jack_port_id_t port_index, jack_int_t* res)
 465 {
 466     JackConnectionManager* manager = WriteNextStateStart();
 467     const jack_int_t* connections = manager->GetConnections(port_index);
 468     memcpy(res, connections, sizeof(jack_int_t) * CONNECTION_NUM_FOR_PORT);
 469     WriteNextStateStop();
 470 }
 471
 472 // Server
 473 void JackGraphManager::Activate(int refnum)
 474 {
 475     DirectConnect(FREEWHEEL_DRIVER_REFNUM, refnum);
 476     DirectConnect(refnum, FREEWHEEL_DRIVER_REFNUM);
 477 }
 478
 479 /*
 480         Disconnection from the FW must be done in last otherwise an intermediate "unconnected"
 481         (thus unactivated) state may happen where the client is still checked for its end.
 482 */
 483
 484 // Server
 485 void JackGraphManager::Deactivate(int refnum)
 486 {
 487     // Disconnect only when needed
 488     if (IsDirectConnection(refnum, FREEWHEEL_DRIVER_REFNUM)) {
 489         DirectDisconnect(refnum, FREEWHEEL_DRIVER_REFNUM);
 490     } else {
 491         jack_log("JackServer::Deactivate client = %ld was not activated", refnum);
 492     }
 493
 494     // Disconnect only when needed
 495     if (IsDirectConnection(FREEWHEEL_DRIVER_REFNUM, refnum)) {
 496         DirectDisconnect(FREEWHEEL_DRIVER_REFNUM, refnum);
 497     } else {
 498         jack_log("JackServer::Deactivate client = %ld was not activated", refnum);
 499     }
 500 }
 501
 502 // Server
 503 int JackGraphManager::GetInputRefNum(jack_port_id_t port_index)
 504 {
 505     AssertPort(port_index);
 506     JackConnectionManager* manager = WriteNextStateStart();
 507     int res = manager->GetInputRefNum(port_index);
 508     WriteNextStateStop();
 509     return res;
 510 }
 511
 512 // Server
 513 int JackGraphManager::GetOutputRefNum(jack_port_id_t port_index)
 514 {
 515     AssertPort(port_index);
 516     JackConnectionManager* manager = WriteNextStateStart();
 517     int res = manager->GetOutputRefNum(port_index);
 518     WriteNextStateStop();
 519     return res;
 520 }
 521
 522 int JackGraphManager::Connect(jack_port_id_t port_src, jack_port_id_t port_dst)
 523 {
 524     JackConnectionManager* manager = WriteNextStateStart();
 525     jack_log("JackGraphManager::Connect port_src = %ld port_dst = %ld", port_src, port_dst);
 526     JackPort* src = GetPort(port_src);
 527     JackPort* dst = GetPort(port_dst);
 528     int res = 0;
 529
 530     if (!src->fInUse || !dst->fInUse) {
 531         if (!src->fInUse)
 532             jack_error("JackGraphManager::Connect port_src = %ld not used name = %s", port_src, GetPort(port_src)->fName);
 533         if (!dst->fInUse)
 534             jack_error("JackGraphManager::Connect port_dst = %ld not used name = %s", port_dst, GetPort(port_dst)->fName);
 535         res = -1;
 536         goto end;
 537     }
 538     if (src->fTypeId != dst->fTypeId) {
 539         jack_error("JackGraphManager::Connect different port types port_src = %ld port_dst = %ld", port_src, port_dst);
 540         res = -1;
 541         goto end;
 542     }
 543     if (manager->IsConnected(port_src, port_dst)) {
 544         jack_error("JackGraphManager::Connect already connected port_src = %ld port_dst = %ld", port_src, port_dst);
 545         res = EEXIST;
 546         goto end;
 547     }
 548
 549     res = manager->Connect(port_src, port_dst);
 550     if (res < 0) {
 551         jack_error("JackGraphManager::Connect failed port_src = %ld port_dst = %ld", port_src, port_dst);
 552         goto end;
 553     }
 554     res = manager->Connect(port_dst, port_src);
 555     if (res < 0) {
 556         jack_error("JackGraphManager::Connect failed port_dst = %ld port_src = %ld", port_dst, port_src);
 557         goto end;
 558     }
 559
 560     if (manager->IsLoopPath(port_src, port_dst)) {
 561         jack_log("JackGraphManager::Connect: LOOP detected");
 562         manager->IncFeedbackConnection(port_src, port_dst);
 563     } else {
 564         manager->IncDirectConnection(port_src, port_dst);
 565     }
 566
 567 end:
 568     WriteNextStateStop();
 569     return res;
 570 }
 571
 572 // Server
 573 int JackGraphManager::Disconnect(jack_port_id_t port_src, jack_port_id_t port_dst)
 574 {
 575     JackConnectionManager* manager = WriteNextStateStart();
 576     jack_log("JackGraphManager::Disconnect port_src = %ld port_dst = %ld", port_src, port_dst);
 577     bool in_use_src = GetPort(port_src)->fInUse;
 578     bool in_use_dst = GetPort(port_dst)->fInUse;
 579     int res = 0;
 580
 581     if (!in_use_src || !in_use_dst) {
 582         if (!in_use_src)
 583             jack_error("JackGraphManager::Disconnect: port_src = %ld not used name = %s", port_src, GetPort(port_src)->fName);
 584         if (!in_use_dst)
 585             jack_error("JackGraphManager::Disconnect: port_src = %ld not used name = %s", port_dst, GetPort(port_dst)->fName);
 586         res = -1;
 587         goto end;
 588     }
 589     if (!manager->IsConnected(port_src, port_dst)) {
 590         jack_error("JackGraphManager::Disconnect not connected port_src = %ld port_dst = %ld", port_src, port_dst);
 591         res = -1;
 592         goto end;
 593     }
 594
 595     res = manager->Disconnect(port_src, port_dst);
 596     if (res < 0) {
 597         jack_error("JackGraphManager::Disconnect failed port_src = %ld port_dst = %ld", port_src, port_dst);
 598         goto end;
 599     }
 600     res = manager->Disconnect(port_dst, port_src);
 601     if (res < 0) {
 602         jack_error("JackGraphManager::Disconnect failed port_dst = %ld port_src = %ld", port_dst, port_src);
 603         goto end;
 604     }
 605
 606     if (manager->IsFeedbackConnection(port_src, port_dst)) {
 607         jack_log("JackGraphManager::Disconnect: FEEDBACK removed");
 608         manager->DecFeedbackConnection(port_src, port_dst);
 609     } else {
 610         manager->DecDirectConnection(port_src, port_dst);
 611     }
 612
 613 end:
 614     WriteNextStateStop();
 615     return res;
 616 }
 617
 618 // Client
 619 int JackGraphManager::IsConnected(jack_port_id_t port_src, jack_port_id_t port_dst)
 620 {
 621     JackConnectionManager* manager = ReadCurrentState();
 622     return manager->IsConnected(port_src, port_dst);
 623 }
 624
 625 // Server
 626 int JackGraphManager::CheckPorts(jack_port_id_t port_src, jack_port_id_t port_dst)
 627 {
 628     JackPort* src = GetPort(port_src);
 629     JackPort* dst = GetPort(port_dst);
 630
 631     if ((dst->fFlags & JackPortIsInput) == 0) {
 632         jack_error("Destination port in attempted (dis)connection of %s and %s is not an input port", src->fName, dst->fName);
 633         return -1;
 634     }
 635
 636     if ((src->fFlags & JackPortIsOutput) == 0) {
 637         jack_error("Source port in attempted (dis)connection of %s and %s is not an output port", src->fName, dst->fName);
 638         return -1;
 639     }
 640
 641     return 0;
 642 }
 643
 644 int JackGraphManager::GetTwoPorts(const char* src_name, const char* dst_name, jack_port_id_t* port_src, jack_port_id_t* port_dst)
 645 {
 646     jack_log("JackGraphManager::CheckConnect src_name = %s dst_name = %s", src_name, dst_name);
 647
 648     if ((*port_src = GetPort(src_name)) == NO_PORT) {
 649         jack_error("Unknown source port in attempted (dis)connection src_name [%s] dst_name [%s]", src_name, dst_name);
 650         return -1;
 651     }
 652
 653     if ((*port_dst = GetPort(dst_name)) == NO_PORT) {
 654         jack_error("Unknown destination port in attempted (dis)connection src_name [%s] dst_name [%s]", src_name, dst_name);
 655         return -1;
 656     }
 657
 658     return 0;
 659 }
 660
 661 // Client : port array
 662 jack_port_id_t JackGraphManager::GetPort(const char* name)
 663 {
 664     for (int i = 0; i < PORT_NUM; i++) {
 665         JackPort* port = GetPort(i);
 666         if (port->IsUsed() && port->NameEquals(name))
 667             return i;
 668     }
 669     return NO_PORT;
 670 }
 671
 672 /*!
 673 \brief Get the connection port name array.
 674 */
 675
 676 // Client
 677 void JackGraphManager::GetConnectionsAux(JackConnectionManager* manager, const char** res, jack_port_id_t port_index)
 678 {
 679     const jack_int_t* connections = manager->GetConnections(port_index);
 680     jack_int_t index;
 681     int i;
 682
 683     // Cleanup connection array
 684     memset(res, 0, sizeof(char*) * CONNECTION_NUM_FOR_PORT);
 685
 686     for (i = 0; (i < CONNECTION_NUM_FOR_PORT) && ((index = connections[i]) != EMPTY); i++) {
 687         JackPort* port = GetPort(index);
 688         res[i] = port->fName;
 689     }
 690
 691     res[i] = NULL;
 692 }
 693
 694 /*
 695         Use the state returned by ReadCurrentState and check that the state was not changed during the read operation.
 696         The operation is lock-free since there is no intermediate state in the write operation that could cause the
 697         read to loop forever.
 698 */
 699
 700 // Client
 701 const char** JackGraphManager::GetConnections(jack_port_id_t port_index)
 702 {
 703     const char** res = (const char**)malloc(sizeof(char*) * CONNECTION_NUM_FOR_PORT);
 704     UInt16 cur_index, next_index;
 705
 706     if (!res)
 707         return NULL;
 708
 709     do {
 710         cur_index = GetCurrentIndex();
 711         GetConnectionsAux(ReadCurrentState(), res, port_index);
 712         next_index = GetCurrentIndex();
 713     } while (cur_index != next_index); // Until a coherent state has been read
 714
 715     if (res[0]) {       // at least one connection
 716         return res;
 717     } else {            // empty array, should return NULL
 718         free(res);
 719         return NULL;
 720     }
 721 }
 722
 723 // Client
 724 void JackGraphManager::GetPortsAux(const char** matching_ports, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)
 725 {
 726     int match_cnt = 0;
 727     regex_t port_regex, type_regex;
 728
 729     if (port_name_pattern && port_name_pattern[0]) {
 730         regcomp(&port_regex, port_name_pattern, REG_EXTENDED | REG_NOSUB);
 731     }
 732     if (type_name_pattern && type_name_pattern[0]) {
 733         regcomp(&type_regex, type_name_pattern, REG_EXTENDED | REG_NOSUB);
 734     }
 735
 736     // Cleanup port array
 737     memset(matching_ports, 0, sizeof(char*) * PORT_NUM);
 738
 739     for (int i = 0; i < PORT_NUM; i++) {
 740         bool matching = true;
 741         JackPort* port = GetPort(i);
 742
 743         if (port->IsUsed()) {
 744
 745             if (flags) {
 746                 if ((port->fFlags & flags) != flags) {
 747                     matching = false;
 748                 }
 749             }
 750
 751             if (matching && port_name_pattern && port_name_pattern[0]) {
 752                 if (regexec(&port_regex, port->GetName(), 0, NULL, 0)) {
 753                     matching = false;
 754                 }
 755             }
 756             if (matching && type_name_pattern && type_name_pattern[0]) {
 757                 if (regexec(&type_regex, port->GetType(), 0, NULL, 0)) {
 758                     matching = false;
 759                 }
 760             }
 761
 762             if (matching) {
 763                 matching_ports[match_cnt++] = port->fName;
 764             }
 765         }
 766     }
 767
 768     matching_ports[match_cnt] = 0;
 769
 770     if (port_name_pattern && port_name_pattern[0]) {
 771         regfree(&port_regex);
 772     }
 773     if (type_name_pattern && type_name_pattern[0]) {
 774         regfree(&type_regex);
 775     }
 776 }
 777
 778 // Client
 779 /*
 780         Check that the state was not changed during the read operation.
 781         The operation is lock-free since there is no intermediate state in the write operation that could cause the
 782         read to loop forever.
 783 */
 784 const char** JackGraphManager::GetPorts(const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)
 785 {
 786     const char** res = (const char**)malloc(sizeof(char*) * PORT_NUM);
 787     UInt16 cur_index, next_index;
 788
 789     if (!res)
 790         return NULL;
 791
 792     do {
 793         cur_index = GetCurrentIndex();
 794         GetPortsAux(res, port_name_pattern, type_name_pattern, flags);
 795         next_index = GetCurrentIndex();
 796     } while (cur_index != next_index);  // Until a coherent state has been read
 797
 798     if (res[0]) {    // at least one port
 799         return res;
 800     } else {
 801         free(res);   // empty array, should return NULL
 802         return NULL;
 803     }
 804 }
 805
 806 // Server
 807 void JackGraphManager::Save(JackConnectionManager* dst)
 808 {
 809     JackConnectionManager* manager = WriteNextStateStart();
 810     memcpy(dst, manager, sizeof(JackConnectionManager));
 811     WriteNextStateStop();
 812 }
 813
 814 // Server
 815 void JackGraphManager::Restore(JackConnectionManager* src)
 816 {
 817     JackConnectionManager* manager = WriteNextStateStart();
 818     memcpy(manager, src, sizeof(JackConnectionManager));
 819     WriteNextStateStop();
 820 }
 821
 822 } // end of namespace
 823
 824