common/JackConnectionManager.cpp

   1 /*
   2 Copyright (C) 2004-2008 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU Lesser General Public License as published by
   6 the Free Software Foundation; either version 2.1 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU Lesser General Public License for more details.
  13
  14 You should have received a copy of the GNU Lesser General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18 */
  19
  20 #include "JackConnectionManager.h"
  21 #include "JackClientControl.h"
  22 #include "JackEngineControl.h"
  23 #include "JackGlobals.h"
  24 #include "JackError.h"
  25 #include <set>
  26 #include <iostream>
  27 #include <assert.h>
  28
  29 namespace Jack
  30 {
  31
  32 JackConnectionManager::JackConnectionManager()
  33 {
  34     int i;
  35     static_assert(offsetof(JackConnectionManager, fInputCounter) % sizeof(UInt32) == 0,
  36                   "fInputCounter must be aligned within JackConnectionManager");
  37
  38     jack_log("JackConnectionManager::InitConnections size = %ld ", sizeof(JackConnectionManager));
  39
  40     for (i = 0; i < PORT_NUM_MAX; i++) {
  41         fConnection[i].Init();
  42     }
  43
  44     fLoopFeedback.Init();
  45
  46     jack_log("JackConnectionManager::InitClients");
  47     for (i = 0; i < CLIENT_NUM; i++) {
  48         InitRefNum(i);
  49     }
  50 }
  51
  52 JackConnectionManager::~JackConnectionManager()
  53 {}
  54
  55 //--------------
  56 // Internal API
  57 //--------------
  58
  59 bool JackConnectionManager::IsLoopPathAux(int ref1, int ref2) const
  60 {
  61     jack_log("JackConnectionManager::IsLoopPathAux ref1 = %ld ref2 = %ld", ref1, ref2);
  62
  63     if (ref1 < GetEngineControl()->fDriverNum || ref2 < GetEngineControl()->fDriverNum) {
  64         return false;
  65     } else if (ref1 == ref2) {  // Same refnum
  66         return true;
  67     } else {
  68         jack_int_t output[CLIENT_NUM];
  69         fConnectionRef.GetOutputTable(ref1, output);
  70
  71         if (fConnectionRef.IsInsideTable(ref2, output)) { // If ref2 is contained in the outputs of ref1
  72             return true;
  73         } else {
  74             for (int i = 0; i < CLIENT_NUM && output[i] != EMPTY; i++) { // Otherwise recurse for all ref1 outputs
  75                 if (IsLoopPathAux(output[i], ref2)) {
  76                     return true; // Stop when a path is found
  77                 }
  78             }
  79             return false;
  80         }
  81     }
  82 }
  83
  84 //--------------
  85 // External API
  86 //--------------
  87
  88 /*!
  89 \brief Connect port_src to port_dst.
  90 */
  91 int JackConnectionManager::Connect(jack_port_id_t port_src, jack_port_id_t port_dst)
  92 {
  93     jack_log("JackConnectionManager::Connect port_src = %ld port_dst = %ld", port_src, port_dst);
  94
  95     if (fConnection[port_src].AddItem(port_dst)) {
  96         return 0;
  97     } else {
  98         jack_error("Connection table is full !!");
  99         return -1;
 100     }
 101 }
 102
 103 /*!
 104 \brief Disconnect port_src from port_dst.
 105 */
 106 int JackConnectionManager::Disconnect(jack_port_id_t port_src, jack_port_id_t port_dst)
 107 {
 108     jack_log("JackConnectionManager::Disconnect port_src = %ld port_dst = %ld", port_src, port_dst);
 109
 110     if (fConnection[port_src].RemoveItem(port_dst)) {
 111         return 0;
 112     } else {
 113         jack_error("Connection not found !!");
 114         return -1;
 115     }
 116 }
 117
 118 /*!
 119 \brief Check if port_src and port_dst are connected.
 120 */
 121 bool JackConnectionManager::IsConnected(jack_port_id_t port_src, jack_port_id_t port_dst) const
 122 {
 123     return fConnection[port_src].CheckItem(port_dst);
 124 }
 125
 126 /*!
 127 \brief Get the connection port array.
 128 */
 129 const jack_int_t* JackConnectionManager::GetConnections(jack_port_id_t port_index) const
 130 {
 131     return fConnection[port_index].GetItems();
 132 }
 133
 134 //------------------------
 135 // Client port management
 136 //------------------------
 137
 138 /*!
 139 \brief Add an input port to a client.
 140 */
 141 int JackConnectionManager::AddInputPort(int refnum, jack_port_id_t port_index)
 142 {
 143     if (fInputPort[refnum].AddItem(port_index)) {
 144         jack_log("JackConnectionManager::AddInputPort ref = %ld port = %ld", refnum, port_index);
 145         return 0;
 146     } else {
 147         jack_error("Maximum number of input ports is reached for application ref = %ld", refnum);
 148         return -1;
 149     }
 150 }
 151
 152 /*!
 153 \brief Add an output port to a client.
 154 */
 155 int JackConnectionManager::AddOutputPort(int refnum, jack_port_id_t port_index)
 156 {
 157     if (fOutputPort[refnum].AddItem(port_index)) {
 158         jack_log("JackConnectionManager::AddOutputPort ref = %ld port = %ld", refnum, port_index);
 159         return 0;
 160     } else {
 161         jack_error("Maximum number of output ports is reached for application ref = %ld", refnum);
 162         return -1;
 163     }
 164 }
 165
 166 /*!
 167 \brief Remove an input port from a client.
 168 */
 169 int JackConnectionManager::RemoveInputPort(int refnum, jack_port_id_t port_index)
 170 {
 171     jack_log("JackConnectionManager::RemoveInputPort ref = %ld port_index = %ld ", refnum, port_index);
 172
 173     if (fInputPort[refnum].RemoveItem(port_index)) {
 174         return 0;
 175     } else {
 176         jack_error("Input port index = %ld not found for application ref = %ld", port_index, refnum);
 177         return -1;
 178     }
 179 }
 180
 181 /*!
 182 \brief Remove an output port from a client.
 183 */
 184 int JackConnectionManager::RemoveOutputPort(int refnum, jack_port_id_t port_index)
 185 {
 186     jack_log("JackConnectionManager::RemoveOutputPort ref = %ld port_index = %ld ", refnum, port_index);
 187
 188     if (fOutputPort[refnum].RemoveItem(port_index)) {
 189         return 0;
 190     } else {
 191         jack_error("Output port index = %ld not found for application ref = %ld", port_index, refnum);
 192         return -1;
 193     }
 194 }
 195
 196 /*!
 197 \brief Get the input port array of a given refnum.
 198 */
 199 const jack_int_t* JackConnectionManager::GetInputPorts(int refnum)
 200 {
 201     return fInputPort[refnum].GetItems();
 202 }
 203
 204 /*!
 205 \brief Get the output port array of a given refnum.
 206 */
 207 const jack_int_t* JackConnectionManager::GetOutputPorts(int refnum)
 208 {
 209     return fOutputPort[refnum].GetItems();
 210 }
 211
 212 /*!
 213 \brief Init the refnum.
 214 */
 215 void JackConnectionManager::InitRefNum(int refnum)
 216 {
 217     fInputPort[refnum].Init();
 218     fOutputPort[refnum].Init();
 219     fConnectionRef.Init(refnum);
 220     fInputCounter[refnum].SetValue(0);
 221 }
 222
 223 /*!
 224 \brief Reset all clients activation.
 225 */
 226 void JackConnectionManager::ResetGraph(JackClientTiming* timing)
 227 {
 228     // Reset activation counter : must be done *before* starting to resume clients
 229     for (int i = 0; i < CLIENT_NUM; i++) {
 230         fInputCounter[i].Reset();
 231         timing[i].fStatus = NotTriggered;
 232     }
 233 }
 234
 235 /*!
 236 \brief Wait on the input synchro.
 237 */
 238 int JackConnectionManager::SuspendRefNum(JackClientControl* control, JackSynchro* table, JackClientTiming* timing, long time_out_usec)
 239 {
 240     bool res;
 241     if ((res = table[control->fRefNum].TimedWait(time_out_usec))) {
 242         timing[control->fRefNum].fStatus = Running;
 243         timing[control->fRefNum].fAwakeAt = GetMicroSeconds();
 244     }
 245     return (res) ? 0 : -1;
 246 }
 247
 248 /*!
 249 \brief Signal clients connected to the given client.
 250 */
 251 int JackConnectionManager::ResumeRefNum(JackClientControl* control, JackSynchro* table, JackClientTiming* timing)
 252 {
 253     jack_time_t current_date = GetMicroSeconds();
 254     const jack_int_t* output_ref = fConnectionRef.GetItems(control->fRefNum);
 255     int res = 0;
 256
 257     // Update state and timestamp of current client
 258     timing[control->fRefNum].fStatus = Finished;
 259     timing[control->fRefNum].fFinishedAt = current_date;
 260
 261     for (int i = 0; i < CLIENT_NUM; i++) {
 262
 263         // Signal connected clients or drivers
 264         if (output_ref[i] > 0) {
 265
 266             // Update state and timestamp of destination clients
 267             timing[i].fStatus = Triggered;
 268             timing[i].fSignaledAt = current_date;
 269
 270             if (!fInputCounter[i].Signal(table + i, control)) {
 271                 jack_log("JackConnectionManager::ResumeRefNum error: ref = %ld output = %ld ", control->fRefNum, i);
 272                 res = -1;
 273             }
 274         }
 275     }
 276
 277     return res;
 278 }
 279
 280 static bool HasNoConnection(jack_int_t* table)
 281 {
 282     for (int ref = 0; ref < CLIENT_NUM; ref++) {
 283         if (table[ref] > 0) return false;
 284     }
 285     return true;
 286 }
 287
 288 // Using http://en.wikipedia.org/wiki/Topological_sorting
 289
 290 void JackConnectionManager::TopologicalSort(std::vector<jack_int_t>& sorted)
 291 {
 292     JackFixedMatrix<CLIENT_NUM>* tmp = new JackFixedMatrix<CLIENT_NUM>;
 293     std::set<jack_int_t> level;
 294
 295     fConnectionRef.Copy(*tmp);
 296
 297     // Inputs of the graph
 298     level.insert(AUDIO_DRIVER_REFNUM);
 299     level.insert(FREEWHEEL_DRIVER_REFNUM);
 300
 301     while (level.size() > 0) {
 302         jack_int_t refnum = *level.begin();
 303         sorted.push_back(refnum);
 304         level.erase(level.begin());
 305         const jack_int_t* output_ref1 = tmp->GetItems(refnum);
 306         for (int dst = 0; dst < CLIENT_NUM; dst++) {
 307             if (output_ref1[dst] > 0) {
 308                 tmp->ClearItem(refnum, dst);
 309                 jack_int_t output_ref2[CLIENT_NUM];
 310                 tmp->GetOutputTable1(dst, output_ref2);
 311                 if (HasNoConnection(output_ref2)) {
 312                     level.insert(dst);
 313                 }
 314             }
 315         }
 316     }
 317
 318     delete tmp;
 319 }
 320
 321 /*!
 322 \brief Increment the number of ports between 2 clients, if the 2 clients become connected, then the Activation counter is updated.
 323 */
 324 void JackConnectionManager::IncDirectConnection(jack_port_id_t port_src, jack_port_id_t port_dst)
 325 {
 326     int ref1 = GetOutputRefNum(port_src);
 327     int ref2 = GetInputRefNum(port_dst);
 328
 329     assert(ref1 >= 0 && ref2 >= 0);
 330
 331     DirectConnect(ref1, ref2);
 332     jack_log("JackConnectionManager::IncConnectionRef: ref1 = %ld ref2 = %ld", ref1, ref2);
 333 }
 334
 335 /*!
 336 \brief Decrement the number of ports between 2 clients, if the 2 clients become disconnected, then the Activation counter is updated.
 337 */
 338 void JackConnectionManager::DecDirectConnection(jack_port_id_t port_src, jack_port_id_t port_dst)
 339 {
 340     int ref1 = GetOutputRefNum(port_src);
 341     int ref2 = GetInputRefNum(port_dst);
 342
 343     assert(ref1 >= 0 && ref2 >= 0);
 344
 345     DirectDisconnect(ref1, ref2);
 346     jack_log("JackConnectionManager::DecConnectionRef: ref1 = %ld ref2 = %ld", ref1, ref2);
 347 }
 348
 349 /*!
 350 \brief Directly connect 2 reference numbers.
 351 */
 352 void JackConnectionManager::DirectConnect(int ref1, int ref2)
 353 {
 354     assert(ref1 >= 0 && ref2 >= 0);
 355
 356     if (fConnectionRef.IncItem(ref1, ref2) == 1) { // First connection between client ref1 and client ref2
 357         jack_log("JackConnectionManager::DirectConnect first: ref1 = %ld ref2 = %ld", ref1, ref2);
 358         fInputCounter[ref2].IncValue();
 359     }
 360 }
 361
 362 /*!
 363 \brief Directly disconnect 2 reference numbers.
 364 */
 365 void JackConnectionManager::DirectDisconnect(int ref1, int ref2)
 366 {
 367     assert(ref1 >= 0 && ref2 >= 0);
 368
 369     if (fConnectionRef.DecItem(ref1, ref2) == 0) { // Last connection between client ref1 and client ref2
 370         jack_log("JackConnectionManager::DirectDisconnect last: ref1 = %ld ref2 = %ld", ref1, ref2);
 371         fInputCounter[ref2].DecValue();
 372     }
 373 }
 374
 375 /*!
 376 \brief Returns the connections state between 2 refnum.
 377 */
 378 bool JackConnectionManager::IsDirectConnection(int ref1, int ref2) const
 379 {
 380     assert(ref1 >= 0 && ref2 >= 0);
 381     return (fConnectionRef.GetItemCount(ref1, ref2) > 0);
 382 }
 383
 384 /*!
 385 \brief Get the client refnum of a given input port.
 386 */
 387 int JackConnectionManager::GetInputRefNum(jack_port_id_t port_index) const
 388 {
 389     for (int i = 0; i < CLIENT_NUM; i++) {
 390         if (fInputPort[i].CheckItem(port_index)) {
 391             return i;
 392         }
 393     }
 394
 395     return -1;
 396 }
 397
 398 /*!
 399 \brief Get the client refnum of a given output port.
 400 */
 401 int JackConnectionManager::GetOutputRefNum(jack_port_id_t port_index) const
 402 {
 403     for (int i = 0; i < CLIENT_NUM; i++) {
 404         if (fOutputPort[i].CheckItem(port_index)) {
 405             return i;
 406         }
 407     }
 408
 409     return -1;
 410 }
 411
 412 /*!
 413 \brief Test is a connection path exists between port_src and port_dst.
 414 */
 415 bool JackConnectionManager::IsLoopPath(jack_port_id_t port_src, jack_port_id_t port_dst) const
 416 {
 417     return IsLoopPathAux(GetInputRefNum(port_dst), GetOutputRefNum(port_src));
 418 }
 419
 420 bool JackConnectionManager::IsFeedbackConnection(jack_port_id_t port_src, jack_port_id_t port_dst) const
 421 {
 422     return (fLoopFeedback.GetConnectionIndex(GetOutputRefNum(port_src), GetInputRefNum(port_dst)) >= 0);
 423 }
 424
 425 bool JackConnectionManager::IncFeedbackConnection(jack_port_id_t port_src, jack_port_id_t port_dst)
 426 {
 427     int ref1 = GetOutputRefNum(port_src);
 428     int ref2 = GetInputRefNum(port_dst);
 429
 430     // Add an activation connection in the other direction
 431     jack_log("JackConnectionManager::IncFeedbackConnection ref1 = %ld ref2 = %ld", ref1, ref2);
 432     assert(ref1 >= 0 && ref2 >= 0);
 433
 434     if (ref1 != ref2) {
 435         DirectConnect(ref2, ref1);
 436     }
 437
 438     return fLoopFeedback.IncConnection(ref1, ref2); // Add the feedback connection
 439 }
 440
 441 bool JackConnectionManager::DecFeedbackConnection(jack_port_id_t port_src, jack_port_id_t port_dst)
 442 {
 443     int ref1 = GetOutputRefNum(port_src);
 444     int ref2 = GetInputRefNum(port_dst);
 445
 446     // Remove an activation connection in the other direction
 447     jack_log("JackConnectionManager::DecFeedbackConnection ref1 = %ld ref2 = %ld", ref1, ref2);
 448     assert(ref1 >= 0 && ref2 >= 0);
 449
 450     if (ref1 != ref2) {
 451         DirectDisconnect(ref2, ref1);
 452     }
 453
 454     return fLoopFeedback.DecConnection(ref1, ref2); // Remove the feedback connection
 455 }
 456
 457 } // end of namespace
 458
 459