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 <iostream>
  26 #include <assert.h>
  27
  28 namespace Jack
  29 {
  30
  31 JackConnectionManager::JackConnectionManager()
  32 {
  33     int i;
  34     jack_log("JackConnectionManager::InitConnections size = %ld ", sizeof(JackConnectionManager));
  35
  36     for (i = 0; i < PORT_NUM; i++) {
  37         fConnection[i].Init();
  38     }
  39
  40     fLoopFeedback.Init();
  41
  42     jack_log("JackConnectionManager::InitClients");
  43     for (i = 0; i < CLIENT_NUM; i++) {
  44         InitRefNum(i);
  45     }
  46 }
  47
  48 JackConnectionManager::~JackConnectionManager()
  49 {}
  50
  51 //--------------
  52 // Internal API
  53 //--------------
  54
  55 bool JackConnectionManager::IsLoopPathAux(int ref1, int ref2) const
  56 {
  57     jack_log("JackConnectionManager::IsLoopPathAux ref1 = %ld ref2 = %ld", ref1, ref2);
  58
  59     if (ref1 < GetEngineControl()->fDriverNum || ref2 < GetEngineControl()->fDriverNum) {
  60         return false;
  61     } else if (ref1 == ref2) {  // Same refnum
  62         return true;
  63     } else {
  64         jack_int_t output[CLIENT_NUM];
  65         fConnectionRef.GetOutputTable(ref1, output);
  66
  67         if (fConnectionRef.IsInsideTable(ref2, output)) { // If ref2 is contained in the outputs of ref1
  68             return true;
  69         } else {
  70             for (int i = 0; i < CLIENT_NUM && output[i] != EMPTY; i++) { // Otherwise recurse for all ref1 outputs
  71                 if (IsLoopPathAux(output[i], ref2))
  72                     return true; // Stop when a path is found
  73             }
  74             return false;
  75         }
  76     }
  77 }
  78
  79 //--------------
  80 // External API
  81 //--------------
  82
  83 /*!
  84 \brief Connect port_src to port_dst.
  85 */
  86 int JackConnectionManager::Connect(jack_port_id_t port_src, jack_port_id_t port_dst)
  87 {
  88     jack_log("JackConnectionManager::Connect port_src = %ld port_dst = %ld", port_src, port_dst);
  89
  90     if (fConnection[port_src].AddItem(port_dst)) {
  91         return 0;
  92     } else {
  93         jack_error("Connection table is full !!");
  94         return -1;
  95     }
  96 }
  97
  98 /*!
  99 \brief Disconnect port_src from port_dst.
 100 */
 101 int JackConnectionManager::Disconnect(jack_port_id_t port_src, jack_port_id_t port_dst)
 102 {
 103     jack_log("JackConnectionManager::Disconnect port_src = %ld port_dst = %ld", port_src, port_dst);
 104
 105     if (fConnection[port_src].RemoveItem(port_dst)) {
 106         return 0;
 107     } else {
 108         jack_error("Connection not found !!");
 109         return -1;
 110     }
 111 }
 112
 113 /*!
 114 \brief Check if port_src and port_dst are connected.
 115 */
 116 bool JackConnectionManager::IsConnected(jack_port_id_t port_src, jack_port_id_t port_dst) const
 117 {
 118     return fConnection[port_src].CheckItem(port_dst);
 119 }
 120
 121 /*!
 122 \brief Get the connection port array.
 123 */
 124 const jack_int_t* JackConnectionManager::GetConnections(jack_port_id_t port_index) const
 125 {
 126     return fConnection[port_index].GetItems();
 127 }
 128
 129 //------------------------
 130 // Client port management
 131 //------------------------
 132
 133 /*!
 134 \brief Add an input port to a client.
 135 */
 136 int JackConnectionManager::AddInputPort(int refnum, jack_port_id_t port_index)
 137 {
 138     if (fInputPort[refnum].AddItem(port_index)) {
 139         jack_log("JackConnectionManager::AddInputPort ref = %ld port = %ld", refnum, port_index);
 140         return 0;
 141     } else {
 142         jack_error("Maximum number of input ports is reached for application ref = %ld", refnum);
 143         return -1;
 144     }
 145 }
 146
 147 /*!
 148 \brief Add an output port to a client.
 149 */
 150 int JackConnectionManager::AddOutputPort(int refnum, jack_port_id_t port_index)
 151 {
 152     if (fOutputPort[refnum].AddItem(port_index)) {
 153         jack_log("JackConnectionManager::AddOutputPort ref = %ld port = %ld", refnum, port_index);
 154         return 0;
 155     } else {
 156         jack_error("Maximum number of output ports is reached for application ref = %ld", refnum);
 157         return -1;
 158     }
 159 }
 160
 161 /*!
 162 \brief Remove an input port from a client.
 163 */
 164 int JackConnectionManager::RemoveInputPort(int refnum, jack_port_id_t port_index)
 165 {
 166     jack_log("JackConnectionManager::RemoveInputPort ref = %ld port_index = %ld ", refnum, port_index);
 167
 168     if (fInputPort[refnum].RemoveItem(port_index)) {
 169         return 0;
 170     } else {
 171         jack_error("Input port index = %ld not found for application ref = %ld", port_index, refnum);
 172         return -1;
 173     }
 174 }
 175
 176 /*!
 177 \brief Remove an output port from a client.
 178 */
 179 int JackConnectionManager::RemoveOutputPort(int refnum, jack_port_id_t port_index)
 180 {
 181     jack_log("JackConnectionManager::RemoveOutputPort ref = %ld port_index = %ld ", refnum, port_index);
 182
 183     if (fOutputPort[refnum].RemoveItem(port_index)) {
 184         return 0;
 185     } else {
 186         jack_error("Output port index = %ld not found for application ref = %ld", port_index, refnum);
 187         return -1;
 188     }
 189 }
 190
 191 /*!
 192 \brief Get the input port array of a given refnum.
 193 */
 194 const jack_int_t* JackConnectionManager::GetInputPorts(int refnum)
 195 {
 196     return fInputPort[refnum].GetItems();
 197 }
 198
 199 /*!
 200 \brief Get the output port array of a given refnum.
 201 */
 202 const jack_int_t* JackConnectionManager::GetOutputPorts(int refnum)
 203 {
 204     return fOutputPort[refnum].GetItems();
 205 }
 206
 207 /*!
 208 \brief Init the refnum.
 209 */
 210 void JackConnectionManager::InitRefNum(int refnum)
 211 {
 212     fInputPort[refnum].Init();
 213     fOutputPort[refnum].Init();
 214     fConnectionRef.Init(refnum);
 215     fInputCounter[refnum].SetValue(0);
 216 }
 217
 218 /*!
 219 \brief Reset all clients activation.
 220 */
 221 void JackConnectionManager::ResetGraph(JackClientTiming* timing)
 222 {
 223     // Reset activation counter : must be done *before* starting to resume clients
 224     for (int i = 0; i < CLIENT_NUM; i++) {
 225         fInputCounter[i].Reset();
 226         timing[i].fStatus = NotTriggered;
 227     }
 228 }
 229
 230 /*!
 231 \brief Wait on the input synchro.
 232 */
 233 int JackConnectionManager::SuspendRefNum(JackClientControl* control, JackSynchro* table, JackClientTiming* timing, long time_out_usec)
 234 {
 235     bool res;
 236     if ((res = table[control->fRefNum].TimedWait(time_out_usec))) {
 237         timing[control->fRefNum].fStatus = Running;
 238         timing[control->fRefNum].fAwakeAt = GetMicroSeconds();
 239     }
 240     return (res) ? 0 : -1;
 241 }
 242
 243 /*!
 244 \brief Signal clients connected to the given client.
 245 */
 246 int JackConnectionManager::ResumeRefNum(JackClientControl* control, JackSynchro* table, JackClientTiming* timing)
 247 {
 248     jack_time_t current_date = GetMicroSeconds();
 249     const jack_int_t* outputRef = fConnectionRef.GetItems(control->fRefNum);
 250     int res = 0;
 251
 252     // Update state and timestamp of current client
 253     timing[control->fRefNum].fStatus = Finished;
 254     timing[control->fRefNum].fFinishedAt = current_date;
 255
 256     for (int i = 0; i < CLIENT_NUM; i++) {
 257
 258         // Signal connected clients or drivers
 259         if (outputRef[i] > 0) {
 260
 261             // Update state and timestamp of destination clients
 262             timing[i].fStatus = Triggered;
 263             timing[i].fSignaledAt = current_date;
 264
 265             if (!fInputCounter[i].Signal(table + i, control)) {
 266                 jack_log("JackConnectionManager::ResumeRefNum error: ref = %ld output = %ld ", control->fRefNum, i);
 267                 res = -1;
 268             }
 269         }
 270     }
 271
 272     return res;
 273 }
 274
 275 /*!
 276 \brief Increment the number of ports between 2 clients, if the 2 clients become connected, then the Activation counter is updated.
 277 */
 278 void JackConnectionManager::IncDirectConnection(jack_port_id_t port_src, jack_port_id_t port_dst)
 279 {
 280     int ref1 = GetOutputRefNum(port_src);
 281     int ref2 = GetInputRefNum(port_dst);
 282
 283     assert(ref1 >= 0 && ref2 >= 0);
 284
 285     DirectConnect(ref1, ref2);
 286     jack_log("JackConnectionManager::IncConnectionRef: ref1 = %ld ref2 = %ld", ref1, ref2);
 287 }
 288
 289 /*!
 290 \brief Decrement the number of ports between 2 clients, if the 2 clients become disconnected, then the Activation counter is updated.
 291 */
 292 void JackConnectionManager::DecDirectConnection(jack_port_id_t port_src, jack_port_id_t port_dst)
 293 {
 294     int ref1 = GetOutputRefNum(port_src);
 295     int ref2 = GetInputRefNum(port_dst);
 296
 297     assert(ref1 >= 0 && ref2 >= 0);
 298
 299     DirectDisconnect(ref1, ref2);
 300     jack_log("JackConnectionManager::DecConnectionRef: ref1 = %ld ref2 = %ld", ref1, ref2);
 301 }
 302
 303 /*!
 304 \brief Directly connect 2 reference numbers.
 305 */
 306 void JackConnectionManager::DirectConnect(int ref1, int ref2)
 307 {
 308     assert(ref1 >= 0 && ref2 >= 0);
 309
 310     if (fConnectionRef.IncItem(ref1, ref2) == 1) { // First connection between client ref1 and client ref2
 311         jack_log("JackConnectionManager::DirectConnect first: ref1 = %ld ref2 = %ld", ref1, ref2);
 312         fInputCounter[ref2].IncValue();
 313     }
 314 }
 315
 316 /*!
 317 \brief Directly disconnect 2 reference numbers.
 318 */
 319 void JackConnectionManager::DirectDisconnect(int ref1, int ref2)
 320 {
 321     assert(ref1 >= 0 && ref2 >= 0);
 322
 323     if (fConnectionRef.DecItem(ref1, ref2) == 0) { // Last connection between client ref1 and client ref2
 324         jack_log("JackConnectionManager::DirectDisconnect last: ref1 = %ld ref2 = %ld", ref1, ref2);
 325         fInputCounter[ref2].DecValue();
 326     }
 327 }
 328
 329 /*!
 330 \brief Returns the connections state between 2 refnum.
 331 */
 332 bool JackConnectionManager::IsDirectConnection(int ref1, int ref2) const
 333 {
 334     assert(ref1 >= 0 && ref2 >= 0);
 335     return (fConnectionRef.GetItemCount(ref1, ref2) > 0);
 336 }
 337
 338 /*!
 339 \brief Get the client refnum of a given input port.
 340 */
 341 int JackConnectionManager::GetInputRefNum(jack_port_id_t port_index) const
 342 {
 343     for (int i = 0; i < CLIENT_NUM; i++) {
 344         if (fInputPort[i].CheckItem(port_index))
 345             return i;
 346     }
 347
 348     return -1;
 349 }
 350
 351 /*!
 352 \brief Get the client refnum of a given ouput port.
 353 */
 354 int JackConnectionManager::GetOutputRefNum(jack_port_id_t port_index) const
 355 {
 356     for (int i = 0; i < CLIENT_NUM; i++) {
 357         if (fOutputPort[i].CheckItem(port_index))
 358             return i;
 359     }
 360
 361     return -1;
 362 }
 363
 364 /*!
 365 \brief Test is a connection path exists between port_src and port_dst.
 366 */
 367 bool JackConnectionManager::IsLoopPath(jack_port_id_t port_src, jack_port_id_t port_dst) const
 368 {
 369     return IsLoopPathAux(GetInputRefNum(port_dst), GetOutputRefNum(port_src));
 370 }
 371
 372 bool JackConnectionManager::IsFeedbackConnection(jack_port_id_t port_src, jack_port_id_t port_dst) const
 373 {
 374     return (fLoopFeedback.GetConnectionIndex(GetOutputRefNum(port_src), GetInputRefNum(port_dst)) >= 0);
 375 }
 376
 377 bool JackConnectionManager::IncFeedbackConnection(jack_port_id_t port_src, jack_port_id_t port_dst)
 378 {
 379     int ref1 = GetOutputRefNum(port_src);
 380     int ref2 = GetInputRefNum(port_dst);
 381
 382     // Add an activation connection in the other direction
 383     jack_log("JackConnectionManager::IncFeedbackConnection ref1 = %ld ref2 = %ld", ref1, ref2);
 384     assert(ref1 >= 0 && ref2 >= 0);
 385
 386     if (ref1 != ref2)
 387         DirectConnect(ref2, ref1);
 388
 389     return fLoopFeedback.IncConnection(ref1, ref2); // Add the feedback connection
 390 }
 391
 392 bool JackConnectionManager::DecFeedbackConnection(jack_port_id_t port_src, jack_port_id_t port_dst)
 393 {
 394     int ref1 = GetOutputRefNum(port_src);
 395     int ref2 = GetInputRefNum(port_dst);
 396
 397     // Remove an activation connection in the other direction
 398     jack_log("JackConnectionManager::DecFeedbackConnection ref1 = %ld ref2 = %ld", ref1, ref2);
 399     assert(ref1 >= 0 && ref2 >= 0);
 400
 401     if (ref1 != ref2)
 402         DirectDisconnect(ref2, ref1);
 403
 404     return fLoopFeedback.DecConnection(ref1, ref2); // Remove the feedback connection
 405 }
 406
 407 } // end of namespace
 408
 409