source/modules/water/processors/AudioProcessorGraph.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the Water library.
   5    Copyright (c) 2015 ROLI Ltd.
   6    Copyright (C) 2017-2022 Filipe Coelho <falktx@falktx.com>
   7
   8    Permission is granted to use this software under the terms of the GNU
   9    General Public License as published by the Free Software Foundation;
  10    either version 2 of the License, or any later version.
  11
  12    This program is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14    FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  15
  16    For a full copy of the GNU General Public License see the doc/GPL.txt file.
  17
  18   ==============================================================================
  19 */
  20
  21 #include "AudioProcessorGraph.h"
  22 #include "../containers/SortedSet.h"
  23
  24 namespace water {
  25
  26 //==============================================================================
  27 namespace GraphRenderingOps
  28 {
  29
  30 struct AudioGraphRenderingOpBase
  31 {
  32     AudioGraphRenderingOpBase() noexcept {}
  33     virtual ~AudioGraphRenderingOpBase() {}
  34
  35     virtual void perform (AudioSampleBuffer& sharedAudioBufferChans,
  36                           AudioSampleBuffer& sharedCVBufferChans,
  37                           const OwnedArray<MidiBuffer>& sharedMidiBuffers,
  38                           const int numSamples) = 0;
  39 };
  40
  41 // use CRTP
  42 template <class Child>
  43 struct AudioGraphRenderingOp  : public AudioGraphRenderingOpBase
  44 {
  45     void perform (AudioSampleBuffer& sharedAudioBufferChans,
  46                   AudioSampleBuffer& sharedCVBufferChans,
  47                   const OwnedArray<MidiBuffer>& sharedMidiBuffers,
  48                   const int numSamples) override
  49     {
  50         static_cast<Child*> (this)->perform (sharedAudioBufferChans,
  51                                              sharedCVBufferChans,
  52                                              sharedMidiBuffers,
  53                                              numSamples);
  54     }
  55 };
  56
  57 //==============================================================================
  58 struct ClearChannelOp  : public AudioGraphRenderingOp<ClearChannelOp>
  59 {
  60     ClearChannelOp (const int channel, const bool cv) noexcept
  61         : channelNum (channel), isCV (cv) {}
  62
  63     void perform (AudioSampleBuffer& sharedAudioBufferChans,
  64                   AudioSampleBuffer& sharedCVBufferChans,
  65                   const OwnedArray<MidiBuffer>&,
  66                   const int numSamples)
  67     {
  68         if (isCV)
  69             sharedCVBufferChans.clear (channelNum, 0, numSamples);
  70         else
  71             sharedAudioBufferChans.clear (channelNum, 0, numSamples);
  72     }
  73
  74     const int channelNum;
  75     const bool isCV;
  76
  77     CARLA_DECLARE_NON_COPYABLE (ClearChannelOp)
  78 };
  79
  80 //==============================================================================
  81 struct CopyChannelOp  : public AudioGraphRenderingOp<CopyChannelOp>
  82 {
  83     CopyChannelOp (const int srcChan, const int dstChan, const bool cv) noexcept
  84         : srcChannelNum (srcChan), dstChannelNum (dstChan), isCV (cv) {}
  85
  86     void perform (AudioSampleBuffer& sharedAudioBufferChans,
  87                   AudioSampleBuffer& sharedCVBufferChans,
  88                   const OwnedArray<MidiBuffer>&,
  89                   const int numSamples)
  90     {
  91         if (isCV)
  92             sharedCVBufferChans.copyFrom (dstChannelNum, 0, sharedCVBufferChans, srcChannelNum, 0, numSamples);
  93         else
  94             sharedAudioBufferChans.copyFrom (dstChannelNum, 0, sharedAudioBufferChans, srcChannelNum, 0, numSamples);
  95     }
  96
  97     const int srcChannelNum, dstChannelNum;
  98     const bool isCV;
  99
 100     CARLA_DECLARE_NON_COPYABLE (CopyChannelOp)
 101 };
 102
 103 //==============================================================================
 104 struct AddChannelOp  : public AudioGraphRenderingOp<AddChannelOp>
 105 {
 106     AddChannelOp (const int srcChan, const int dstChan, const bool cv) noexcept
 107         : srcChannelNum (srcChan), dstChannelNum (dstChan), isCV (cv) {}
 108
 109     void perform (AudioSampleBuffer& sharedAudioBufferChans,
 110                   AudioSampleBuffer& sharedCVBufferChans,
 111                   const OwnedArray<MidiBuffer>&,
 112                   const int numSamples)
 113     {
 114         if (isCV)
 115             sharedCVBufferChans.addFrom (dstChannelNum, 0, sharedCVBufferChans, srcChannelNum, 0, numSamples);
 116         else
 117             sharedAudioBufferChans.addFrom (dstChannelNum, 0, sharedAudioBufferChans, srcChannelNum, 0, numSamples);
 118     }
 119
 120     const int srcChannelNum, dstChannelNum;
 121     const bool isCV;
 122
 123     CARLA_DECLARE_NON_COPYABLE (AddChannelOp)
 124 };
 125
 126 //==============================================================================
 127 struct ClearMidiBufferOp  : public AudioGraphRenderingOp<ClearMidiBufferOp>
 128 {
 129     ClearMidiBufferOp (const int buffer) noexcept  : bufferNum (buffer)  {}
 130
 131     void perform (AudioSampleBuffer&, AudioSampleBuffer&,
 132                   const OwnedArray<MidiBuffer>& sharedMidiBuffers,
 133                   const int)
 134     {
 135         sharedMidiBuffers.getUnchecked (bufferNum)->clear();
 136     }
 137
 138     const int bufferNum;
 139
 140     CARLA_DECLARE_NON_COPYABLE (ClearMidiBufferOp)
 141 };
 142
 143 //==============================================================================
 144 struct CopyMidiBufferOp  : public AudioGraphRenderingOp<CopyMidiBufferOp>
 145 {
 146     CopyMidiBufferOp (const int srcBuffer, const int dstBuffer) noexcept
 147         : srcBufferNum (srcBuffer), dstBufferNum (dstBuffer)
 148     {}
 149
 150     void perform (AudioSampleBuffer&, AudioSampleBuffer&,
 151                   const OwnedArray<MidiBuffer>& sharedMidiBuffers,
 152                   const int)
 153     {
 154         *sharedMidiBuffers.getUnchecked (dstBufferNum) = *sharedMidiBuffers.getUnchecked (srcBufferNum);
 155     }
 156
 157     const int srcBufferNum, dstBufferNum;
 158
 159     CARLA_DECLARE_NON_COPYABLE (CopyMidiBufferOp)
 160 };
 161
 162 //==============================================================================
 163 struct AddMidiBufferOp  : public AudioGraphRenderingOp<AddMidiBufferOp>
 164 {
 165     AddMidiBufferOp (const int srcBuffer, const int dstBuffer)
 166         : srcBufferNum (srcBuffer), dstBufferNum (dstBuffer)
 167     {}
 168
 169     void perform (AudioSampleBuffer&, AudioSampleBuffer&,
 170                   const OwnedArray<MidiBuffer>& sharedMidiBuffers,
 171                   const int numSamples)
 172     {
 173         sharedMidiBuffers.getUnchecked (dstBufferNum)
 174             ->addEvents (*sharedMidiBuffers.getUnchecked (srcBufferNum), 0, numSamples, 0);
 175     }
 176
 177     const int srcBufferNum, dstBufferNum;
 178
 179     CARLA_DECLARE_NON_COPYABLE (AddMidiBufferOp)
 180 };
 181
 182 //==============================================================================
 183 struct DelayChannelOp  : public AudioGraphRenderingOp<DelayChannelOp>
 184 {
 185     DelayChannelOp (const int chan, const int delaySize, const bool cv)
 186         : channel (chan),
 187           bufferSize (delaySize + 1),
 188           readIndex (0), writeIndex (delaySize),
 189           isCV (cv)
 190     {
 191         buffer.calloc ((size_t) bufferSize);
 192     }
 193
 194     void perform (AudioSampleBuffer& sharedAudioBufferChans,
 195                   AudioSampleBuffer& sharedCVBufferChans,
 196                   const OwnedArray<MidiBuffer>&,
 197                   const int numSamples)
 198     {
 199         float* data = isCV
 200                     ? sharedCVBufferChans.getWritePointer (channel, 0)
 201                     : sharedAudioBufferChans.getWritePointer (channel, 0);
 202         HeapBlock<float>& block = buffer;
 203
 204         for (int i = numSamples; --i >= 0;)
 205         {
 206             block [writeIndex] = *data;
 207             *data++ = block [readIndex];
 208
 209             if (++readIndex  >= bufferSize) readIndex = 0;
 210             if (++writeIndex >= bufferSize) writeIndex = 0;
 211         }
 212     }
 213
 214 private:
 215     HeapBlock<float> buffer;
 216     const int channel, bufferSize;
 217     int readIndex, writeIndex;
 218     const bool isCV;
 219
 220     CARLA_DECLARE_NON_COPYABLE (DelayChannelOp)
 221 };
 222
 223 //==============================================================================
 224 struct ProcessBufferOp   : public AudioGraphRenderingOp<ProcessBufferOp>
 225 {
 226     ProcessBufferOp (const AudioProcessorGraph::Node::Ptr& n,
 227                      const Array<uint>& audioChannelsUsed,
 228                      const uint totalNumChans,
 229                      const Array<uint>& cvInChannelsUsed,
 230                      const Array<uint>& cvOutChannelsUsed,
 231                      const int midiBuffer)
 232         : node (n),
 233           processor (n->getProcessor()),
 234           audioChannelsToUse (audioChannelsUsed),
 235           cvInChannelsToUse (cvInChannelsUsed),
 236           cvOutChannelsToUse (cvOutChannelsUsed),
 237           totalAudioChans (jmax (1U, totalNumChans)),
 238           totalCVIns (cvInChannelsUsed.size()),
 239           totalCVOuts (cvOutChannelsUsed.size()),
 240           midiBufferToUse (midiBuffer)
 241     {
 242         audioChannels.calloc (totalAudioChans);
 243         cvInChannels.calloc (totalCVIns);
 244         cvOutChannels.calloc (totalCVOuts);
 245
 246         while (audioChannelsToUse.size() < static_cast<int>(totalAudioChans))
 247             audioChannelsToUse.add (0);
 248     }
 249
 250     void perform (AudioSampleBuffer& sharedAudioBufferChans,
 251                   AudioSampleBuffer& sharedCVBufferChans,
 252                   const OwnedArray<MidiBuffer>& sharedMidiBuffers,
 253                   const int numSamples)
 254     {
 255         HeapBlock<float*>& audioChannelsCopy = audioChannels;
 256         HeapBlock<float*>& cvInChannelsCopy  = cvInChannels;
 257         HeapBlock<float*>& cvOutChannelsCopy = cvOutChannels;
 258
 259         for (uint i = 0; i < totalAudioChans; ++i)
 260             audioChannelsCopy[i] = sharedAudioBufferChans.getWritePointer (audioChannelsToUse.getUnchecked (i), 0);
 261
 262         for (uint i = 0; i < totalCVIns; ++i)
 263             cvInChannels[i] = sharedCVBufferChans.getWritePointer (cvInChannelsToUse.getUnchecked (i), 0);
 264
 265         for (uint i = 0; i < totalCVOuts; ++i)
 266             cvOutChannels[i] = sharedCVBufferChans.getWritePointer (cvOutChannelsToUse.getUnchecked (i), 0);
 267
 268         AudioSampleBuffer audioBuffer (audioChannelsCopy, totalAudioChans, numSamples);
 269         AudioSampleBuffer cvInBuffer  (cvInChannelsCopy, totalCVIns, numSamples);
 270         AudioSampleBuffer cvOutBuffer (cvOutChannelsCopy, totalCVOuts, numSamples);
 271
 272         if (processor->isSuspended())
 273         {
 274             audioBuffer.clear();
 275             cvOutBuffer.clear();
 276         }
 277         else
 278         {
 279             const CarlaRecursiveMutexLocker cml (processor->getCallbackLock());
 280
 281             callProcess (audioBuffer, cvInBuffer, cvOutBuffer, *sharedMidiBuffers.getUnchecked (midiBufferToUse));
 282         }
 283     }
 284
 285     void callProcess (AudioSampleBuffer& audioBuffer,
 286                       AudioSampleBuffer& cvInBuffer,
 287                       AudioSampleBuffer& cvOutBuffer,
 288                       MidiBuffer& midiMessages)
 289     {
 290         processor->processBlockWithCV (audioBuffer, cvInBuffer, cvOutBuffer, midiMessages);
 291     }
 292
 293     const AudioProcessorGraph::Node::Ptr node;
 294     AudioProcessor* const processor;
 295
 296 private:
 297     Array<uint> audioChannelsToUse;
 298     Array<uint> cvInChannelsToUse;
 299     Array<uint> cvOutChannelsToUse;
 300     HeapBlock<float*> audioChannels;
 301     HeapBlock<float*> cvInChannels;
 302     HeapBlock<float*> cvOutChannels;
 303     AudioSampleBuffer tempBuffer;
 304     const uint totalAudioChans;
 305     const uint totalCVIns;
 306     const uint totalCVOuts;
 307     const int midiBufferToUse;
 308
 309     CARLA_DECLARE_NON_COPYABLE (ProcessBufferOp)
 310 };
 311
 312 //==============================================================================
 313 /** Used to calculate the correct sequence of rendering ops needed, based on
 314     the best re-use of shared buffers at each stage.
 315 */
 316 struct RenderingOpSequenceCalculator
 317 {
 318     RenderingOpSequenceCalculator (AudioProcessorGraph& g,
 319                                    const Array<AudioProcessorGraph::Node*>& nodes,
 320                                    Array<void*>& renderingOps)
 321         : graph (g),
 322           orderedNodes (nodes),
 323           totalLatency (0)
 324     {
 325         audioNodeIds.add ((uint32) zeroNodeID); // first buffer is read-only zeros
 326         audioChannels.add (0);
 327
 328         cvNodeIds.add ((uint32) zeroNodeID);
 329         cvChannels.add (0);
 330
 331         midiNodeIds.add ((uint32) zeroNodeID);
 332
 333         for (int i = 0; i < orderedNodes.size(); ++i)
 334         {
 335             createRenderingOpsForNode (*orderedNodes.getUnchecked(i), renderingOps, i);
 336             markAnyUnusedBuffersAsFree (i);
 337         }
 338
 339         graph.setLatencySamples (totalLatency);
 340     }
 341
 342     int getNumAudioBuffersNeeded() const noexcept    { return audioNodeIds.size(); }
 343     int getNumCVBuffersNeeded() const noexcept       { return cvNodeIds.size(); }
 344     int getNumMidiBuffersNeeded() const noexcept     { return midiNodeIds.size(); }
 345
 346 private:
 347     //==============================================================================
 348     AudioProcessorGraph& graph;
 349     const Array<AudioProcessorGraph::Node*>& orderedNodes;
 350     Array<uint> audioChannels, cvChannels;
 351     Array<uint32> audioNodeIds, cvNodeIds, midiNodeIds;
 352
 353     enum { freeNodeID = 0xffffffff, zeroNodeID = 0xfffffffe, anonymousNodeID = 0xfffffffd };
 354
 355     static bool isNodeBusy (uint32 nodeID) noexcept     { return nodeID != freeNodeID; }
 356
 357     Array<uint32> nodeDelayIDs;
 358     Array<int> nodeDelays;
 359     int totalLatency;
 360
 361     int getNodeDelay (const uint32 nodeID) const        { return nodeDelays [nodeDelayIDs.indexOf (nodeID)]; }
 362
 363     void setNodeDelay (const uint32 nodeID, const int latency)
 364     {
 365         const int index = nodeDelayIDs.indexOf (nodeID);
 366
 367         if (index >= 0)
 368         {
 369             nodeDelays.set (index, latency);
 370         }
 371         else
 372         {
 373             nodeDelayIDs.add (nodeID);
 374             nodeDelays.add (latency);
 375         }
 376     }
 377
 378     int getInputLatencyForNode (const uint32 nodeID) const
 379     {
 380         int maxLatency = 0;
 381
 382         for (int i = graph.getNumConnections(); --i >= 0;)
 383         {
 384             const AudioProcessorGraph::Connection* const c = graph.getConnection (i);
 385
 386             if (c->destNodeId == nodeID)
 387                 maxLatency = jmax (maxLatency, getNodeDelay (c->sourceNodeId));
 388         }
 389
 390         return maxLatency;
 391     }
 392
 393     //==============================================================================
 394     void createRenderingOpsForNode (AudioProcessorGraph::Node& node,
 395                                     Array<void*>& renderingOps,
 396                                     const int ourRenderingIndex)
 397     {
 398         AudioProcessor& processor = *node.getProcessor();
 399         const uint numAudioIns = processor.getTotalNumInputChannels(AudioProcessor::ChannelTypeAudio);
 400         const uint numAudioOuts = processor.getTotalNumOutputChannels(AudioProcessor::ChannelTypeAudio);
 401         const uint numCVIns = processor.getTotalNumInputChannels(AudioProcessor::ChannelTypeCV);
 402         const uint numCVOuts = processor.getTotalNumOutputChannels(AudioProcessor::ChannelTypeCV);
 403         const uint totalAudioChans = jmax (numAudioIns, numAudioOuts);
 404
 405         Array<uint> audioChannelsToUse, cvInChannelsToUse, cvOutChannelsToUse;
 406         int midiBufferToUse = -1;
 407
 408         int maxLatency = getInputLatencyForNode (node.nodeId);
 409
 410         for (uint inputChan = 0; inputChan < numAudioIns; ++inputChan)
 411         {
 412             // get a list of all the inputs to this node
 413             Array<uint32> sourceNodes;
 414             Array<uint> sourceOutputChans;
 415
 416             for (int i = graph.getNumConnections(); --i >= 0;)
 417             {
 418                 const AudioProcessorGraph::Connection* const c = graph.getConnection (i);
 419
 420                 if (c->destNodeId == node.nodeId
 421                     && c->destChannelIndex == inputChan
 422                     && c->channelType == AudioProcessor::ChannelTypeAudio)
 423                 {
 424                     sourceNodes.add (c->sourceNodeId);
 425                     sourceOutputChans.add (c->sourceChannelIndex);
 426                 }
 427             }
 428
 429             int bufIndex = -1;
 430
 431             if (sourceNodes.size() == 0)
 432             {
 433                 // unconnected input channel
 434                 bufIndex = getFreeBuffer (AudioProcessor::ChannelTypeAudio);
 435                 renderingOps.add (new ClearChannelOp (bufIndex, false));
 436             }
 437             else if (sourceNodes.size() == 1)
 438             {
 439                 // channel with a straightforward single input..
 440                 const uint32 srcNode = sourceNodes.getUnchecked(0);
 441                 const uint srcChan = sourceOutputChans.getUnchecked(0);
 442
 443                 bufIndex = getBufferContaining (AudioProcessor::ChannelTypeAudio, srcNode, srcChan);
 444
 445                 if (bufIndex < 0)
 446                 {
 447                     // if not found, this is probably a feedback loop
 448                     bufIndex = getReadOnlyEmptyBuffer();
 449                     wassert (bufIndex >= 0);
 450                 }
 451
 452                 if (inputChan < numAudioOuts
 453                      && isBufferNeededLater (AudioProcessor::ChannelTypeAudio,
 454                                              ourRenderingIndex,
 455                                              inputChan,
 456                                              srcNode, srcChan))
 457                 {
 458                     // can't mess up this channel because it's needed later by another node, so we
 459                     // need to use a copy of it..
 460                     const int newFreeBuffer = getFreeBuffer (AudioProcessor::ChannelTypeAudio);
 461
 462                     renderingOps.add (new CopyChannelOp (bufIndex, newFreeBuffer, false));
 463
 464                     bufIndex = newFreeBuffer;
 465                 }
 466
 467                 const int nodeDelay = getNodeDelay (srcNode);
 468
 469                 if (nodeDelay < maxLatency)
 470                     renderingOps.add (new DelayChannelOp (bufIndex, maxLatency - nodeDelay, false));
 471             }
 472             else
 473             {
 474                 // channel with a mix of several inputs..
 475
 476                 // try to find a re-usable channel from our inputs..
 477                 int reusableInputIndex = -1;
 478
 479                 for (int i = 0; i < sourceNodes.size(); ++i)
 480                 {
 481                     const int sourceBufIndex = getBufferContaining (AudioProcessor::ChannelTypeAudio,
 482                                                                     sourceNodes.getUnchecked(i),
 483                                                                     sourceOutputChans.getUnchecked(i));
 484
 485                     if (sourceBufIndex >= 0
 486                         && ! isBufferNeededLater (AudioProcessor::ChannelTypeAudio,
 487                                                   ourRenderingIndex,
 488                                                   inputChan,
 489                                                   sourceNodes.getUnchecked(i),
 490                                                   sourceOutputChans.getUnchecked(i)))
 491                     {
 492                         // we've found one of our input chans that can be re-used..
 493                         reusableInputIndex = i;
 494                         bufIndex = sourceBufIndex;
 495
 496                         const int nodeDelay = getNodeDelay (sourceNodes.getUnchecked (i));
 497                         if (nodeDelay < maxLatency)
 498                             renderingOps.add (new DelayChannelOp (sourceBufIndex, maxLatency - nodeDelay, false));
 499
 500                         break;
 501                     }
 502                 }
 503
 504                 if (reusableInputIndex < 0)
 505                 {
 506                     // can't re-use any of our input chans, so get a new one and copy everything into it..
 507                     bufIndex = getFreeBuffer (AudioProcessor::ChannelTypeAudio);
 508                     wassert (bufIndex != 0);
 509
 510                     markBufferAsContaining (AudioProcessor::ChannelTypeAudio,
 511                                             bufIndex, static_cast<uint32> (anonymousNodeID), 0);
 512
 513                     const int srcIndex = getBufferContaining (AudioProcessor::ChannelTypeAudio,
 514                                                               sourceNodes.getUnchecked (0),
 515                                                               sourceOutputChans.getUnchecked (0));
 516                     if (srcIndex < 0)
 517                     {
 518                         // if not found, this is probably a feedback loop
 519                         renderingOps.add (new ClearChannelOp (bufIndex, false));
 520                     }
 521                     else
 522                     {
 523                         renderingOps.add (new CopyChannelOp (srcIndex, bufIndex, false));
 524                     }
 525
 526                     reusableInputIndex = 0;
 527                     const int nodeDelay = getNodeDelay (sourceNodes.getFirst());
 528
 529                     if (nodeDelay < maxLatency)
 530                         renderingOps.add (new DelayChannelOp (bufIndex, maxLatency - nodeDelay, false));
 531                 }
 532
 533                 for (int j = 0; j < sourceNodes.size(); ++j)
 534                 {
 535                     if (j != reusableInputIndex)
 536                     {
 537                         int srcIndex = getBufferContaining (AudioProcessor::ChannelTypeAudio,
 538                                                             sourceNodes.getUnchecked(j),
 539                                                             sourceOutputChans.getUnchecked(j));
 540                         if (srcIndex >= 0)
 541                         {
 542                             const int nodeDelay = getNodeDelay (sourceNodes.getUnchecked (j));
 543
 544                             if (nodeDelay < maxLatency)
 545                             {
 546                                 if (! isBufferNeededLater (AudioProcessor::ChannelTypeAudio,
 547                                                            ourRenderingIndex, inputChan,
 548                                                            sourceNodes.getUnchecked(j),
 549                                                            sourceOutputChans.getUnchecked(j)))
 550                                 {
 551                                     renderingOps.add (new DelayChannelOp (srcIndex, maxLatency - nodeDelay, false));
 552                                 }
 553                                 else // buffer is reused elsewhere, can't be delayed
 554                                 {
 555                                     const int bufferToDelay = getFreeBuffer (AudioProcessor::ChannelTypeAudio);
 556                                     renderingOps.add (new CopyChannelOp (srcIndex, bufferToDelay, false));
 557                                     renderingOps.add (new DelayChannelOp (bufferToDelay, maxLatency - nodeDelay, false));
 558                                     srcIndex = bufferToDelay;
 559                                 }
 560                             }
 561
 562                             renderingOps.add (new AddChannelOp (srcIndex, bufIndex, false));
 563                         }
 564                     }
 565                 }
 566             }
 567
 568             CARLA_SAFE_ASSERT_CONTINUE (bufIndex >= 0);
 569             audioChannelsToUse.add (bufIndex);
 570
 571             if (inputChan < numAudioOuts)
 572                 markBufferAsContaining (AudioProcessor::ChannelTypeAudio, bufIndex, node.nodeId, inputChan);
 573         }
 574
 575         for (uint outputChan = numAudioIns; outputChan < numAudioOuts; ++outputChan)
 576         {
 577             const int bufIndex = getFreeBuffer (AudioProcessor::ChannelTypeAudio);
 578             CARLA_SAFE_ASSERT_CONTINUE (bufIndex > 0);
 579             audioChannelsToUse.add (bufIndex);
 580             markBufferAsContaining (AudioProcessor::ChannelTypeAudio, bufIndex, node.nodeId, outputChan);
 581         }
 582
 583         for (uint inputChan = 0; inputChan < numCVIns; ++inputChan)
 584         {
 585             // get a list of all the inputs to this node
 586             Array<uint32> sourceNodes;
 587             Array<uint> sourceOutputChans;
 588
 589             for (int i = graph.getNumConnections(); --i >= 0;)
 590             {
 591                 const AudioProcessorGraph::Connection* const c = graph.getConnection (i);
 592
 593                 if (c->destNodeId == node.nodeId
 594                     && c->destChannelIndex == inputChan
 595                     && c->channelType == AudioProcessor::ChannelTypeCV)
 596                 {
 597                     sourceNodes.add (c->sourceNodeId);
 598                     sourceOutputChans.add (c->sourceChannelIndex);
 599                 }
 600             }
 601
 602             int bufIndex = -1;
 603
 604             if (sourceNodes.size() == 0)
 605             {
 606                 // unconnected input channel
 607                 bufIndex = getFreeBuffer (AudioProcessor::ChannelTypeCV);
 608                 renderingOps.add (new ClearChannelOp (bufIndex, true));
 609             }
 610             else if (sourceNodes.size() == 1)
 611             {
 612                 // channel with a straightforward single input..
 613                 const uint32 srcNode = sourceNodes.getUnchecked(0);
 614                 const uint srcChan = sourceOutputChans.getUnchecked(0);
 615
 616                 bufIndex = getBufferContaining (AudioProcessor::ChannelTypeCV, srcNode, srcChan);
 617
 618                 if (bufIndex < 0)
 619                 {
 620                     // if not found, this is probably a feedback loop
 621                     bufIndex = getReadOnlyEmptyBuffer();
 622                     wassert (bufIndex >= 0);
 623                 }
 624
 625                 const int newFreeBuffer = getFreeBuffer (AudioProcessor::ChannelTypeCV);
 626
 627                 renderingOps.add (new CopyChannelOp (bufIndex, newFreeBuffer, true));
 628
 629                 bufIndex = newFreeBuffer;
 630
 631                 const int nodeDelay = getNodeDelay (srcNode);
 632
 633                 if (nodeDelay < maxLatency)
 634                     renderingOps.add (new DelayChannelOp (bufIndex, maxLatency - nodeDelay, true));
 635             }
 636             else
 637             {
 638                 // channel with a mix of several inputs..
 639
 640                 {
 641                     bufIndex = getFreeBuffer (AudioProcessor::ChannelTypeCV);
 642                     wassert (bufIndex != 0);
 643
 644                     const int srcIndex = getBufferContaining (AudioProcessor::ChannelTypeCV,
 645                                                               sourceNodes.getUnchecked (0),
 646                                                               sourceOutputChans.getUnchecked (0));
 647                     if (srcIndex < 0)
 648                     {
 649                         // if not found, this is probably a feedback loop
 650                         renderingOps.add (new ClearChannelOp (bufIndex, true));
 651                     }
 652                     else
 653                     {
 654                         renderingOps.add (new CopyChannelOp (srcIndex, bufIndex, true));
 655                     }
 656
 657                     const int nodeDelay = getNodeDelay (sourceNodes.getFirst());
 658
 659                     if (nodeDelay < maxLatency)
 660                         renderingOps.add (new DelayChannelOp (bufIndex, maxLatency - nodeDelay, true));
 661                 }
 662
 663                 for (int j = 1; j < sourceNodes.size(); ++j)
 664                 {
 665                     int srcIndex = getBufferContaining (AudioProcessor::ChannelTypeCV,
 666                                                         sourceNodes.getUnchecked(j),
 667                                                         sourceOutputChans.getUnchecked(j));
 668                     if (srcIndex >= 0)
 669                     {
 670                         const int nodeDelay = getNodeDelay (sourceNodes.getUnchecked (j));
 671
 672                         if (nodeDelay < maxLatency)
 673                         {
 674                             const int bufferToDelay = getFreeBuffer (AudioProcessor::ChannelTypeCV);
 675                             renderingOps.add (new CopyChannelOp (srcIndex, bufferToDelay, true));
 676                             renderingOps.add (new DelayChannelOp (bufferToDelay, maxLatency - nodeDelay, true));
 677                             srcIndex = bufferToDelay;
 678                         }
 679
 680                         renderingOps.add (new AddChannelOp (srcIndex, bufIndex, true));
 681                     }
 682                 }
 683             }
 684
 685             CARLA_SAFE_ASSERT_CONTINUE (bufIndex >= 0);
 686             cvInChannelsToUse.add (bufIndex);
 687             markBufferAsContaining (AudioProcessor::ChannelTypeCV, bufIndex, node.nodeId, inputChan);
 688         }
 689
 690         for (uint outputChan = 0; outputChan < numCVOuts; ++outputChan)
 691         {
 692             const int bufIndex = getFreeBuffer (AudioProcessor::ChannelTypeCV);
 693             CARLA_SAFE_ASSERT_CONTINUE (bufIndex > 0);
 694             cvOutChannelsToUse.add (bufIndex);
 695             markBufferAsContaining (AudioProcessor::ChannelTypeCV, bufIndex, node.nodeId, outputChan);
 696         }
 697
 698         // Now the same thing for midi..
 699         Array<uint32> midiSourceNodes;
 700
 701         for (int i = graph.getNumConnections(); --i >= 0;)
 702         {
 703             const AudioProcessorGraph::Connection* const c = graph.getConnection (i);
 704
 705             if (c->destNodeId == node.nodeId && c->channelType == AudioProcessor::ChannelTypeMIDI)
 706                 midiSourceNodes.add (c->sourceNodeId);
 707         }
 708
 709         if (midiSourceNodes.size() == 0)
 710         {
 711             // No midi inputs..
 712             midiBufferToUse = getFreeBuffer (AudioProcessor::ChannelTypeMIDI); // need to pick a buffer even if the processor doesn't use midi
 713
 714             if (processor.acceptsMidi() || processor.producesMidi())
 715                 renderingOps.add (new ClearMidiBufferOp (midiBufferToUse));
 716         }
 717         else if (midiSourceNodes.size() == 1)
 718         {
 719             // One midi input..
 720             midiBufferToUse = getBufferContaining (AudioProcessor::ChannelTypeMIDI,
 721                                                    midiSourceNodes.getUnchecked(0),
 722                                                    0);
 723             if (midiBufferToUse >= 0)
 724             {
 725                 if (isBufferNeededLater (AudioProcessor::ChannelTypeMIDI,
 726                                          ourRenderingIndex, 0,
 727                                          midiSourceNodes.getUnchecked(0), 0))
 728                 {
 729                     // can't mess up this channel because it's needed later by another node, so we
 730                     // need to use a copy of it..
 731                     const int newFreeBuffer = getFreeBuffer (AudioProcessor::ChannelTypeMIDI);
 732                     renderingOps.add (new CopyMidiBufferOp (midiBufferToUse, newFreeBuffer));
 733                     midiBufferToUse = newFreeBuffer;
 734                 }
 735             }
 736             else
 737             {
 738                 // probably a feedback loop, so just use an empty one..
 739                 midiBufferToUse = getFreeBuffer (AudioProcessor::ChannelTypeMIDI); // need to pick a buffer even if the processor doesn't use midi
 740             }
 741         }
 742         else
 743         {
 744             // More than one midi input being mixed..
 745             int reusableInputIndex = -1;
 746
 747             for (int i = 0; i < midiSourceNodes.size(); ++i)
 748             {
 749                 const int sourceBufIndex = getBufferContaining (AudioProcessor::ChannelTypeMIDI,
 750                                                                 midiSourceNodes.getUnchecked(i),
 751                                                                 0);
 752
 753                 if (sourceBufIndex >= 0
 754                      && ! isBufferNeededLater (AudioProcessor::ChannelTypeMIDI,
 755                                                ourRenderingIndex, 0,
 756                                                midiSourceNodes.getUnchecked(i), 0))
 757                 {
 758                     // we've found one of our input buffers that can be re-used..
 759                     reusableInputIndex = i;
 760                     midiBufferToUse = sourceBufIndex;
 761                     break;
 762                 }
 763             }
 764
 765             if (reusableInputIndex < 0)
 766             {
 767                 // can't re-use any of our input buffers, so get a new one and copy everything into it..
 768                 midiBufferToUse = getFreeBuffer (AudioProcessor::ChannelTypeMIDI);
 769                 wassert (midiBufferToUse >= 0);
 770
 771                 const int srcIndex = getBufferContaining (AudioProcessor::ChannelTypeMIDI,
 772                                                           midiSourceNodes.getUnchecked(0),
 773                                                           0);
 774                 if (srcIndex >= 0)
 775                     renderingOps.add (new CopyMidiBufferOp (srcIndex, midiBufferToUse));
 776                 else
 777                     renderingOps.add (new ClearMidiBufferOp (midiBufferToUse));
 778
 779                 reusableInputIndex = 0;
 780             }
 781
 782             for (int j = 0; j < midiSourceNodes.size(); ++j)
 783             {
 784                 if (j != reusableInputIndex)
 785                 {
 786                     const int srcIndex = getBufferContaining (AudioProcessor::ChannelTypeMIDI,
 787                                                               midiSourceNodes.getUnchecked(j),
 788                                                               0);
 789                     if (srcIndex >= 0)
 790                         renderingOps.add (new AddMidiBufferOp (srcIndex, midiBufferToUse));
 791                 }
 792             }
 793         }
 794
 795         if (processor.producesMidi())
 796             markBufferAsContaining (AudioProcessor::ChannelTypeMIDI,
 797                                     midiBufferToUse, node.nodeId,
 798                                     0);
 799
 800         setNodeDelay (node.nodeId, maxLatency + processor.getLatencySamples());
 801
 802         if (numAudioOuts == 0)
 803             totalLatency = maxLatency;
 804
 805         renderingOps.add (new ProcessBufferOp (&node,
 806                                                audioChannelsToUse,
 807                                                totalAudioChans,
 808                                                cvInChannelsToUse,
 809                                                cvOutChannelsToUse,
 810                                                midiBufferToUse));
 811     }
 812
 813     //==============================================================================
 814     int getFreeBuffer (const AudioProcessor::ChannelType channelType)
 815     {
 816         switch (channelType)
 817         {
 818         case AudioProcessor::ChannelTypeAudio:
 819             for (int i = 1; i < audioNodeIds.size(); ++i)
 820                 if (audioNodeIds.getUnchecked(i) == freeNodeID)
 821                     return i;
 822
 823             audioNodeIds.add ((uint32) freeNodeID);
 824             audioChannels.add (0);
 825             return audioNodeIds.size() - 1;
 826
 827         case AudioProcessor::ChannelTypeCV:
 828             for (int i = 1; i < cvNodeIds.size(); ++i)
 829                 if (cvNodeIds.getUnchecked(i) == freeNodeID)
 830                     return i;
 831
 832             cvNodeIds.add ((uint32) freeNodeID);
 833             cvChannels.add (0);
 834             return cvNodeIds.size() - 1;
 835
 836         case AudioProcessor::ChannelTypeMIDI:
 837             for (int i = 1; i < midiNodeIds.size(); ++i)
 838                 if (midiNodeIds.getUnchecked(i) == freeNodeID)
 839                     return i;
 840
 841             midiNodeIds.add ((uint32) freeNodeID);
 842             return midiNodeIds.size() - 1;
 843         }
 844
 845         return -1;
 846     }
 847
 848     int getReadOnlyEmptyBuffer() const noexcept
 849     {
 850         return 0;
 851     }
 852
 853     int getBufferContaining (const AudioProcessor::ChannelType channelType,
 854                              const uint32 nodeId,
 855                              const uint outputChannel) const noexcept
 856     {
 857         switch (channelType)
 858         {
 859         case AudioProcessor::ChannelTypeAudio:
 860             for (int i = audioNodeIds.size(); --i >= 0;)
 861                 if (audioNodeIds.getUnchecked(i) == nodeId && audioChannels.getUnchecked(i) == outputChannel)
 862                     return i;
 863             break;
 864
 865         case AudioProcessor::ChannelTypeCV:
 866             for (int i = cvNodeIds.size(); --i >= 0;)
 867                 if (cvNodeIds.getUnchecked(i) == nodeId && cvChannels.getUnchecked(i) == outputChannel)
 868                     return i;
 869             break;
 870
 871         case AudioProcessor::ChannelTypeMIDI:
 872             for (int i = midiNodeIds.size(); --i >= 0;)
 873             {
 874                 if (midiNodeIds.getUnchecked(i) == nodeId)
 875                     return i;
 876             }
 877             break;
 878         }
 879
 880         return -1;
 881     }
 882
 883     void markAnyUnusedBuffersAsFree (const int stepIndex)
 884     {
 885         for (int i = 0; i < audioNodeIds.size(); ++i)
 886         {
 887             if (isNodeBusy (audioNodeIds.getUnchecked(i))
 888                  && ! isBufferNeededLater (AudioProcessor::ChannelTypeAudio,
 889                                            stepIndex, -1,
 890                                            audioNodeIds.getUnchecked(i),
 891                                            audioChannels.getUnchecked(i)))
 892             {
 893                 audioNodeIds.set (i, (uint32) freeNodeID);
 894             }
 895         }
 896
 897         // NOTE: CV skipped on purpose
 898
 899         for (int i = 0; i < midiNodeIds.size(); ++i)
 900         {
 901             if (isNodeBusy (midiNodeIds.getUnchecked(i))
 902                  && ! isBufferNeededLater (AudioProcessor::ChannelTypeMIDI,
 903                                            stepIndex, -1,
 904                                            midiNodeIds.getUnchecked(i), 0))
 905             {
 906                 midiNodeIds.set (i, (uint32) freeNodeID);
 907             }
 908         }
 909     }
 910
 911     bool isBufferNeededLater (const AudioProcessor::ChannelType channelType,
 912                               int stepIndexToSearchFrom,
 913                               uint inputChannelOfIndexToIgnore,
 914                               const uint32 nodeId,
 915                               const uint outputChanIndex) const
 916     {
 917         while (stepIndexToSearchFrom < orderedNodes.size())
 918         {
 919             const AudioProcessorGraph::Node* const node = (const AudioProcessorGraph::Node*) orderedNodes.getUnchecked (stepIndexToSearchFrom);
 920
 921             for (uint i = 0; i < node->getProcessor()->getTotalNumInputChannels(channelType); ++i)
 922                 if (i != inputChannelOfIndexToIgnore
 923                         && graph.getConnectionBetween (channelType,
 924                                                        nodeId, outputChanIndex,
 925                                                        node->nodeId, i) != nullptr)
 926                     return true;
 927
 928             inputChannelOfIndexToIgnore = (uint)-1;
 929             ++stepIndexToSearchFrom;
 930         }
 931
 932         return false;
 933     }
 934
 935     void markBufferAsContaining (const AudioProcessor::ChannelType channelType,
 936                                  int bufferNum, uint32 nodeId, int outputIndex)
 937     {
 938         switch (channelType)
 939         {
 940         case AudioProcessor::ChannelTypeAudio:
 941             CARLA_SAFE_ASSERT_BREAK (bufferNum >= 0 && bufferNum < audioNodeIds.size());
 942             audioNodeIds.set (bufferNum, nodeId);
 943             audioChannels.set (bufferNum, outputIndex);
 944             break;
 945
 946         case AudioProcessor::ChannelTypeCV:
 947             CARLA_SAFE_ASSERT_BREAK (bufferNum >= 0 && bufferNum < cvNodeIds.size());
 948             cvNodeIds.set (bufferNum, nodeId);
 949             cvChannels.set (bufferNum, outputIndex);
 950             break;
 951
 952         case AudioProcessor::ChannelTypeMIDI:
 953             CARLA_SAFE_ASSERT_BREAK (bufferNum > 0 && bufferNum < midiNodeIds.size());
 954             midiNodeIds.set (bufferNum, nodeId);
 955             break;
 956         }
 957     }
 958
 959     CARLA_DECLARE_NON_COPYABLE (RenderingOpSequenceCalculator)
 960 };
 961
 962 //==============================================================================
 963 // Holds a fast lookup table for checking which nodes are inputs to others.
 964 class ConnectionLookupTable
 965 {
 966 public:
 967     explicit ConnectionLookupTable (const OwnedArray<AudioProcessorGraph::Connection>& connections)
 968     {
 969         for (int i = 0; i < static_cast<int>(connections.size()); ++i)
 970         {
 971             const AudioProcessorGraph::Connection* const c = connections.getUnchecked(i);
 972
 973             int index;
 974             Entry* entry = findEntry (c->destNodeId, index);
 975
 976             if (entry == nullptr)
 977             {
 978                 entry = new Entry (c->destNodeId);
 979                 entries.insert (index, entry);
 980             }
 981
 982             entry->srcNodes.add (c->sourceNodeId);
 983         }
 984     }
 985
 986     bool isAnInputTo (const uint32 possibleInputId,
 987                       const uint32 possibleDestinationId) const noexcept
 988     {
 989         return isAnInputToRecursive (possibleInputId, possibleDestinationId, entries.size());
 990     }
 991
 992 private:
 993     //==============================================================================
 994     struct Entry
 995     {
 996         explicit Entry (const uint32 destNodeId_) noexcept : destNodeId (destNodeId_) {}
 997
 998         const uint32 destNodeId;
 999         SortedSet<uint32> srcNodes;
1000
1001         CARLA_DECLARE_NON_COPYABLE (Entry)
1002     };
1003
1004     OwnedArray<Entry> entries;
1005
1006     bool isAnInputToRecursive (const uint32 possibleInputId,
1007                                const uint32 possibleDestinationId,
1008                                int recursionCheck) const noexcept
1009     {
1010         int index;
1011
1012         if (const Entry* const entry = findEntry (possibleDestinationId, index))
1013         {
1014             const SortedSet<uint32>& srcNodes = entry->srcNodes;
1015
1016             if (srcNodes.contains (possibleInputId))
1017                 return true;
1018
1019             if (--recursionCheck >= 0)
1020             {
1021                 for (int i = 0; i < srcNodes.size(); ++i)
1022                     if (isAnInputToRecursive (possibleInputId, srcNodes.getUnchecked(i), recursionCheck))
1023                         return true;
1024             }
1025         }
1026
1027         return false;
1028     }
1029
1030     Entry* findEntry (const uint32 destNodeId, int& insertIndex) const noexcept
1031     {
1032         Entry* result = nullptr;
1033
1034         int start = 0;
1035         int end = entries.size();
1036
1037         for (;;)
1038         {
1039             if (start >= end)
1040             {
1041                 break;
1042             }
1043             else if (destNodeId == entries.getUnchecked (start)->destNodeId)
1044             {
1045                 result = entries.getUnchecked (start);
1046                 break;
1047             }
1048             else
1049             {
1050                 const int halfway = (start + end) / 2;
1051
1052                 if (halfway == start)
1053                 {
1054                     if (destNodeId >= entries.getUnchecked (halfway)->destNodeId)
1055                         ++start;
1056
1057                     break;
1058                 }
1059                 else if (destNodeId >= entries.getUnchecked (halfway)->destNodeId)
1060                     start = halfway;
1061                 else
1062                     end = halfway;
1063             }
1064         }
1065
1066         insertIndex = start;
1067         return result;
1068     }
1069
1070     CARLA_DECLARE_NON_COPYABLE (ConnectionLookupTable)
1071 };
1072
1073 //==============================================================================
1074 struct ConnectionSorter
1075 {
1076     static int compareElements (const AudioProcessorGraph::Connection* const first,
1077                                 const AudioProcessorGraph::Connection* const second) noexcept
1078     {
1079         if (first->sourceNodeId < second->sourceNodeId)                return -1;
1080         if (first->sourceNodeId > second->sourceNodeId)                return 1;
1081         if (first->destNodeId < second->destNodeId)                    return -1;
1082         if (first->destNodeId > second->destNodeId)                    return 1;
1083         if (first->sourceChannelIndex < second->sourceChannelIndex)    return -1;
1084         if (first->sourceChannelIndex > second->sourceChannelIndex)    return 1;
1085         if (first->destChannelIndex < second->destChannelIndex)        return -1;
1086         if (first->destChannelIndex > second->destChannelIndex)        return 1;
1087
1088         return 0;
1089     }
1090 };
1091
1092 }
1093
1094 //==============================================================================
1095 AudioProcessorGraph::Connection::Connection (ChannelType ct,
1096                                              const uint32 sourceID, const uint sourceChannel,
1097                                              const uint32 destID, const uint destChannel) noexcept
1098     : channelType (ct),
1099       sourceNodeId (sourceID), sourceChannelIndex (sourceChannel),
1100       destNodeId (destID), destChannelIndex (destChannel)
1101 {
1102 }
1103
1104 //==============================================================================
1105 AudioProcessorGraph::Node::Node (const uint32 nodeID, AudioProcessor* const p) noexcept
1106     : nodeId (nodeID), processor (p), isPrepared (false)
1107 {
1108     wassert (processor != nullptr);
1109 }
1110
1111 void AudioProcessorGraph::Node::prepare (const double newSampleRate, const int newBlockSize,
1112                                          AudioProcessorGraph* const graph)
1113 {
1114     if (! isPrepared)
1115     {
1116         setParentGraph (graph);
1117
1118         processor->setRateAndBufferSizeDetails (newSampleRate, newBlockSize);
1119         processor->prepareToPlay (newSampleRate, newBlockSize);
1120         isPrepared = true;
1121     }
1122 }
1123
1124 void AudioProcessorGraph::Node::unprepare()
1125 {
1126     if (isPrepared)
1127     {
1128         isPrepared = false;
1129         processor->releaseResources();
1130     }
1131 }
1132
1133 void AudioProcessorGraph::Node::setParentGraph (AudioProcessorGraph* const graph) const
1134 {
1135     if (AudioProcessorGraph::AudioGraphIOProcessor* const ioProc
1136             = dynamic_cast<AudioProcessorGraph::AudioGraphIOProcessor*> (processor.get()))
1137         ioProc->setParentGraph (graph);
1138 }
1139
1140 //==============================================================================
1141 struct AudioProcessorGraph::AudioProcessorGraphBufferHelpers
1142 {
1143     AudioProcessorGraphBufferHelpers() noexcept
1144         : currentAudioInputBuffer (nullptr),
1145           currentCVInputBuffer (nullptr) {}
1146
1147     void setRenderingBufferSize (int newNumAudioChannels, int newNumCVChannels, int newNumSamples) noexcept
1148     {
1149         renderingAudioBuffers.setSize (newNumAudioChannels, newNumSamples);
1150         renderingAudioBuffers.clear();
1151
1152         renderingCVBuffers.setSize (newNumCVChannels, newNumSamples);
1153         renderingCVBuffers.clear();
1154     }
1155
1156     void release() noexcept
1157     {
1158         renderingAudioBuffers.setSize (1, 1);
1159         currentAudioInputBuffer = nullptr;
1160         currentCVInputBuffer = nullptr;
1161         currentAudioOutputBuffer.setSize (1, 1);
1162         currentCVOutputBuffer.setSize (1, 1);
1163
1164         renderingCVBuffers.setSize (1, 1);
1165     }
1166
1167     void prepareInOutBuffers (int newNumAudioChannels, int newNumCVChannels, int newNumSamples) noexcept
1168     {
1169         currentAudioInputBuffer = nullptr;
1170         currentCVInputBuffer = nullptr;
1171         currentAudioOutputBuffer.setSize (newNumAudioChannels, newNumSamples);
1172         currentCVOutputBuffer.setSize (newNumCVChannels, newNumSamples);
1173     }
1174
1175     AudioSampleBuffer        renderingAudioBuffers;
1176     AudioSampleBuffer        renderingCVBuffers;
1177     AudioSampleBuffer*       currentAudioInputBuffer;
1178     const AudioSampleBuffer* currentCVInputBuffer;
1179     AudioSampleBuffer        currentAudioOutputBuffer;
1180     AudioSampleBuffer        currentCVOutputBuffer;
1181 };
1182
1183 //==============================================================================
1184 AudioProcessorGraph::AudioProcessorGraph()
1185     : lastNodeId (0), audioAndCVBuffers (new AudioProcessorGraphBufferHelpers),
1186       currentMidiInputBuffer (nullptr), isPrepared (false), needsReorder (false)
1187 {
1188 }
1189
1190 AudioProcessorGraph::~AudioProcessorGraph()
1191 {
1192     clearRenderingSequence();
1193     clear();
1194 }
1195
1196 const String AudioProcessorGraph::getName() const
1197 {
1198     return "Audio Graph";
1199 }
1200
1201 //==============================================================================
1202 void AudioProcessorGraph::clear()
1203 {
1204     nodes.clear();
1205     connections.clear();
1206     needsReorder = true;
1207 }
1208
1209 AudioProcessorGraph::Node* AudioProcessorGraph::getNodeForId (const uint32 nodeId) const
1210 {
1211     for (int i = nodes.size(); --i >= 0;)
1212         if (nodes.getUnchecked(i)->nodeId == nodeId)
1213             return nodes.getUnchecked(i);
1214
1215     return nullptr;
1216 }
1217
1218 AudioProcessorGraph::Node* AudioProcessorGraph::addNode (AudioProcessor* const newProcessor, uint32 nodeId)
1219 {
1220     CARLA_SAFE_ASSERT_RETURN (newProcessor != nullptr && newProcessor != this, nullptr);
1221
1222     for (int i = nodes.size(); --i >= 0;)
1223     {
1224         CARLA_SAFE_ASSERT_RETURN (nodes.getUnchecked(i)->getProcessor() != newProcessor, nullptr);
1225     }
1226
1227     if (nodeId == 0)
1228     {
1229         nodeId = ++lastNodeId;
1230     }
1231     else
1232     {
1233         // you can't add a node with an id that already exists in the graph..
1234         CARLA_SAFE_ASSERT_RETURN (getNodeForId (nodeId) == nullptr, nullptr);
1235         removeNode (nodeId);
1236
1237         if (nodeId > lastNodeId)
1238             lastNodeId = nodeId;
1239     }
1240
1241     Node* const n = new Node (nodeId, newProcessor);
1242     nodes.add (n);
1243
1244     if (isPrepared)
1245         needsReorder = true;
1246
1247     n->setParentGraph (this);
1248     return n;
1249 }
1250
1251 bool AudioProcessorGraph::removeNode (const uint32 nodeId)
1252 {
1253     disconnectNode (nodeId);
1254
1255     for (int i = nodes.size(); --i >= 0;)
1256     {
1257         if (nodes.getUnchecked(i)->nodeId == nodeId)
1258         {
1259             nodes.remove (i);
1260
1261             if (isPrepared)
1262                 needsReorder = true;
1263
1264             return true;
1265         }
1266     }
1267
1268     return false;
1269 }
1270
1271 bool AudioProcessorGraph::removeNode (Node* node)
1272 {
1273     CARLA_SAFE_ASSERT_RETURN(node != nullptr, false);
1274
1275     return removeNode (node->nodeId);
1276 }
1277
1278 //==============================================================================
1279 const AudioProcessorGraph::Connection* AudioProcessorGraph::getConnectionBetween (const ChannelType ct,
1280                                                                                   const uint32 sourceNodeId,
1281                                                                                   const uint sourceChannelIndex,
1282                                                                                   const uint32 destNodeId,
1283                                                                                   const uint destChannelIndex) const
1284 {
1285     const Connection c (ct, sourceNodeId, sourceChannelIndex, destNodeId, destChannelIndex);
1286     GraphRenderingOps::ConnectionSorter sorter;
1287     return connections [connections.indexOfSorted (sorter, &c)];
1288 }
1289
1290 bool AudioProcessorGraph::isConnected (const uint32 possibleSourceNodeId,
1291                                        const uint32 possibleDestNodeId) const
1292 {
1293     for (int i = connections.size(); --i >= 0;)
1294     {
1295         const Connection* const c = connections.getUnchecked(i);
1296
1297         if (c->sourceNodeId == possibleSourceNodeId
1298              && c->destNodeId == possibleDestNodeId)
1299         {
1300             return true;
1301         }
1302     }
1303
1304     return false;
1305 }
1306
1307 bool AudioProcessorGraph::canConnect (ChannelType ct,
1308                                       const uint32 sourceNodeId,
1309                                       const uint sourceChannelIndex,
1310                                       const uint32 destNodeId,
1311                                       const uint destChannelIndex) const
1312 {
1313     if (sourceNodeId == destNodeId)
1314         return false;
1315
1316     const Node* const source = getNodeForId (sourceNodeId);
1317
1318     if (source == nullptr
1319          || (ct != ChannelTypeMIDI && sourceChannelIndex >= source->processor->getTotalNumOutputChannels(ct))
1320          || (ct == ChannelTypeMIDI && ! source->processor->producesMidi()))
1321         return false;
1322
1323     const Node* const dest = getNodeForId (destNodeId);
1324
1325     if (dest == nullptr
1326          || (ct != ChannelTypeMIDI && destChannelIndex >= dest->processor->getTotalNumInputChannels(ct))
1327          || (ct == ChannelTypeMIDI && ! dest->processor->acceptsMidi()))
1328         return false;
1329
1330     return getConnectionBetween (ct,
1331                                  sourceNodeId, sourceChannelIndex,
1332                                  destNodeId, destChannelIndex) == nullptr;
1333 }
1334
1335 bool AudioProcessorGraph::addConnection (const ChannelType ct,
1336                                          const uint32 sourceNodeId,
1337                                          const uint sourceChannelIndex,
1338                                          const uint32 destNodeId,
1339                                          const uint destChannelIndex)
1340 {
1341     if (! canConnect (ct, sourceNodeId, sourceChannelIndex, destNodeId, destChannelIndex))
1342         return false;
1343
1344     GraphRenderingOps::ConnectionSorter sorter;
1345     connections.addSorted (sorter, new Connection (ct,
1346                                                    sourceNodeId, sourceChannelIndex,
1347                                                    destNodeId, destChannelIndex));
1348
1349     if (isPrepared)
1350         needsReorder = true;
1351
1352     return true;
1353 }
1354
1355 void AudioProcessorGraph::removeConnection (const int index)
1356 {
1357     connections.remove (index);
1358
1359     if (isPrepared)
1360         needsReorder = true;
1361 }
1362
1363 bool AudioProcessorGraph::removeConnection (const ChannelType ct,
1364                                             const uint32 sourceNodeId, const uint sourceChannelIndex,
1365                                             const uint32 destNodeId, const uint destChannelIndex)
1366 {
1367     bool doneAnything = false;
1368
1369     for (int i = connections.size(); --i >= 0;)
1370     {
1371         const Connection* const c = connections.getUnchecked(i);
1372
1373         if (c->channelType == ct
1374              && c->sourceNodeId == sourceNodeId
1375              && c->destNodeId == destNodeId
1376              && c->sourceChannelIndex == sourceChannelIndex
1377              && c->destChannelIndex == destChannelIndex)
1378         {
1379             removeConnection (i);
1380             doneAnything = true;
1381         }
1382     }
1383
1384     return doneAnything;
1385 }
1386
1387 bool AudioProcessorGraph::disconnectNode (const uint32 nodeId)
1388 {
1389     bool doneAnything = false;
1390
1391     for (int i = connections.size(); --i >= 0;)
1392     {
1393         const Connection* const c = connections.getUnchecked(i);
1394
1395         if (c->sourceNodeId == nodeId || c->destNodeId == nodeId)
1396         {
1397             removeConnection (i);
1398             doneAnything = true;
1399         }
1400     }
1401
1402     return doneAnything;
1403 }
1404
1405 bool AudioProcessorGraph::isConnectionLegal (const Connection* const c) const
1406 {
1407     CARLA_SAFE_ASSERT_RETURN (c != nullptr, false);
1408
1409     const Node* const source = getNodeForId (c->sourceNodeId);
1410     const Node* const dest   = getNodeForId (c->destNodeId);
1411
1412     return source != nullptr
1413         && dest != nullptr
1414         && (c->channelType != ChannelTypeMIDI ? (c->sourceChannelIndex < source->processor->getTotalNumOutputChannels(c->channelType))
1415                                               : source->processor->producesMidi())
1416         && (c->channelType != ChannelTypeMIDI ? (c->destChannelIndex < dest->processor->getTotalNumInputChannels(c->channelType))
1417                                               : dest->processor->acceptsMidi());
1418 }
1419
1420 bool AudioProcessorGraph::removeIllegalConnections()
1421 {
1422     bool doneAnything = false;
1423
1424     for (int i = connections.size(); --i >= 0;)
1425     {
1426         if (! isConnectionLegal (connections.getUnchecked(i)))
1427         {
1428             removeConnection (i);
1429             doneAnything = true;
1430         }
1431     }
1432
1433     return doneAnything;
1434 }
1435
1436 //==============================================================================
1437 static void deleteRenderOpArray (Array<void*>& ops)
1438 {
1439     for (int i = ops.size(); --i >= 0;)
1440         delete static_cast<GraphRenderingOps::AudioGraphRenderingOpBase*> (ops.getUnchecked(i));
1441 }
1442
1443 void AudioProcessorGraph::clearRenderingSequence()
1444 {
1445     Array<void*> oldOps;
1446
1447     {
1448         const CarlaRecursiveMutexLocker cml (getCallbackLock());
1449         renderingOps.swapWith (oldOps);
1450     }
1451
1452     deleteRenderOpArray (oldOps);
1453 }
1454
1455 bool AudioProcessorGraph::isAnInputTo (const uint32 possibleInputId,
1456                                        const uint32 possibleDestinationId,
1457                                        const int recursionCheck) const
1458 {
1459     if (recursionCheck > 0)
1460     {
1461         for (int i = connections.size(); --i >= 0;)
1462         {
1463             const AudioProcessorGraph::Connection* const c = connections.getUnchecked (i);
1464
1465             if (c->destNodeId == possibleDestinationId
1466                  && (c->sourceNodeId == possibleInputId
1467                       || isAnInputTo (possibleInputId, c->sourceNodeId, recursionCheck - 1)))
1468                 return true;
1469         }
1470     }
1471
1472     return false;
1473 }
1474
1475 void AudioProcessorGraph::buildRenderingSequence()
1476 {
1477     Array<void*> newRenderingOps;
1478     int numAudioRenderingBuffersNeeded = 2;
1479     int numCVRenderingBuffersNeeded = 0;
1480     int numMidiBuffersNeeded = 1;
1481
1482     {
1483         const CarlaRecursiveMutexLocker cml (reorderMutex);
1484
1485         Array<Node*> orderedNodes;
1486
1487         {
1488             const GraphRenderingOps::ConnectionLookupTable table (connections);
1489
1490             for (int i = 0; i < nodes.size(); ++i)
1491             {
1492                 Node* const node = nodes.getUnchecked(i);
1493
1494                 node->prepare (getSampleRate(), getBlockSize(), this);
1495
1496                 int j = 0;
1497                 for (; j < orderedNodes.size(); ++j)
1498                     if (table.isAnInputTo (node->nodeId, ((Node*) orderedNodes.getUnchecked(j))->nodeId))
1499                       break;
1500
1501                 orderedNodes.insert (j, node);
1502             }
1503         }
1504
1505         GraphRenderingOps::RenderingOpSequenceCalculator calculator (*this, orderedNodes, newRenderingOps);
1506
1507         numAudioRenderingBuffersNeeded = calculator.getNumAudioBuffersNeeded();
1508         numCVRenderingBuffersNeeded = calculator.getNumCVBuffersNeeded();
1509         numMidiBuffersNeeded = calculator.getNumMidiBuffersNeeded();
1510     }
1511
1512     {
1513         // swap over to the new rendering sequence..
1514         const CarlaRecursiveMutexLocker cml (getCallbackLock());
1515
1516         audioAndCVBuffers->setRenderingBufferSize (numAudioRenderingBuffersNeeded,
1517                                                    numCVRenderingBuffersNeeded,
1518                                                    getBlockSize());
1519
1520         for (int i = static_cast<int>(midiBuffers.size()); --i >= 0;)
1521             midiBuffers.getUnchecked(i)->clear();
1522
1523         while (static_cast<int>(midiBuffers.size()) < numMidiBuffersNeeded)
1524             midiBuffers.add (new MidiBuffer());
1525
1526         renderingOps.swapWith (newRenderingOps);
1527     }
1528
1529     // delete the old ones..
1530     deleteRenderOpArray (newRenderingOps);
1531 }
1532
1533 //==============================================================================
1534 void AudioProcessorGraph::prepareToPlay (double sampleRate, int estimatedSamplesPerBlock)
1535 {
1536     setRateAndBufferSizeDetails(sampleRate, estimatedSamplesPerBlock);
1537
1538     audioAndCVBuffers->prepareInOutBuffers(jmax(1U, getTotalNumOutputChannels(AudioProcessor::ChannelTypeAudio)),
1539                                            jmax(1U, getTotalNumOutputChannels(AudioProcessor::ChannelTypeCV)),
1540                                            estimatedSamplesPerBlock);
1541
1542     currentMidiInputBuffer = nullptr;
1543     currentMidiOutputBuffer.clear();
1544
1545     clearRenderingSequence();
1546     buildRenderingSequence();
1547
1548     isPrepared = true;
1549 }
1550
1551 void AudioProcessorGraph::releaseResources()
1552 {
1553     isPrepared = false;
1554
1555     for (int i = 0; i < nodes.size(); ++i)
1556         nodes.getUnchecked(i)->unprepare();
1557
1558     audioAndCVBuffers->release();
1559     midiBuffers.clear();
1560
1561     currentMidiInputBuffer = nullptr;
1562     currentMidiOutputBuffer.clear();
1563 }
1564
1565 void AudioProcessorGraph::reset()
1566 {
1567     const CarlaRecursiveMutexLocker cml (getCallbackLock());
1568
1569     for (int i = 0; i < nodes.size(); ++i)
1570         nodes.getUnchecked(i)->getProcessor()->reset();
1571 }
1572
1573 void AudioProcessorGraph::setNonRealtime (bool isProcessingNonRealtime) noexcept
1574 {
1575     const CarlaRecursiveMutexLocker cml (getCallbackLock());
1576
1577     AudioProcessor::setNonRealtime (isProcessingNonRealtime);
1578
1579     for (int i = 0; i < nodes.size(); ++i)
1580         nodes.getUnchecked(i)->getProcessor()->setNonRealtime (isProcessingNonRealtime);
1581 }
1582
1583 /*
1584 void AudioProcessorGraph::processAudio (AudioSampleBuffer& audioBuffer, MidiBuffer& midiMessages)
1585 {
1586     AudioSampleBuffer*& currentAudioInputBuffer  = audioAndCVBuffers->currentAudioInputBuffer;
1587     AudioSampleBuffer&  currentAudioOutputBuffer = audioAndCVBuffers->currentAudioOutputBuffer;
1588     AudioSampleBuffer&  renderingAudioBuffers    = audioAndCVBuffers->renderingAudioBuffers;
1589     AudioSampleBuffer&  renderingCVBuffers       = audioAndCVBuffers->renderingCVBuffers;
1590
1591     const int numSamples = audioBuffer.getNumSamples();
1592
1593     if (! audioAndCVBuffers->currentAudioOutputBuffer.setSizeRT(numSamples))
1594         return;
1595     if (! audioAndCVBuffers->renderingAudioBuffers.setSizeRT(numSamples))
1596         return;
1597     if (! audioAndCVBuffers->renderingCVBuffers.setSizeRT(numSamples))
1598         return;
1599
1600     currentAudioInputBuffer = &audioBuffer;
1601     currentAudioOutputBuffer.clear();
1602     currentMidiInputBuffer = &midiMessages;
1603     currentMidiOutputBuffer.clear();
1604
1605     for (int i = 0; i < renderingOps.size(); ++i)
1606     {
1607         GraphRenderingOps::AudioGraphRenderingOpBase* const op
1608             = (GraphRenderingOps::AudioGraphRenderingOpBase*) renderingOps.getUnchecked(i);
1609
1610         op->perform (renderingAudioBuffers, renderingCVBuffers, midiBuffers, numSamples);
1611     }
1612
1613     for (uint32_t i = 0; i < audioBuffer.getNumChannels(); ++i)
1614         audioBuffer.copyFrom (i, 0, currentAudioOutputBuffer, i, 0, numSamples);
1615
1616     midiMessages.clear();
1617     midiMessages.addEvents (currentMidiOutputBuffer, 0, audioBuffer.getNumSamples(), 0);
1618 }
1619 */
1620
1621 void AudioProcessorGraph::processAudioAndCV (AudioSampleBuffer& audioBuffer,
1622                                              const AudioSampleBuffer& cvInBuffer,
1623                                              AudioSampleBuffer& cvOutBuffer,
1624                                              MidiBuffer& midiMessages)
1625 {
1626     AudioSampleBuffer*&       currentAudioInputBuffer  = audioAndCVBuffers->currentAudioInputBuffer;
1627     const AudioSampleBuffer*& currentCVInputBuffer     = audioAndCVBuffers->currentCVInputBuffer;
1628     AudioSampleBuffer&        currentAudioOutputBuffer = audioAndCVBuffers->currentAudioOutputBuffer;
1629     AudioSampleBuffer&        currentCVOutputBuffer    = audioAndCVBuffers->currentCVOutputBuffer;
1630     AudioSampleBuffer&        renderingAudioBuffers    = audioAndCVBuffers->renderingAudioBuffers;
1631     AudioSampleBuffer&        renderingCVBuffers       = audioAndCVBuffers->renderingCVBuffers;
1632
1633     const int numSamples = audioBuffer.getNumSamples();
1634
1635     if (! audioAndCVBuffers->currentAudioOutputBuffer.setSizeRT(numSamples))
1636         return;
1637     if (! audioAndCVBuffers->currentCVOutputBuffer.setSizeRT(numSamples))
1638         return;
1639     if (! audioAndCVBuffers->renderingAudioBuffers.setSizeRT(numSamples))
1640         return;
1641     if (! audioAndCVBuffers->renderingCVBuffers.setSizeRT(numSamples))
1642         return;
1643
1644     currentAudioInputBuffer = &audioBuffer;
1645     currentCVInputBuffer = &cvInBuffer;
1646     currentMidiInputBuffer = &midiMessages;
1647     currentAudioOutputBuffer.clear();
1648     currentCVOutputBuffer.clear();
1649     currentMidiOutputBuffer.clear();
1650
1651     for (int i = 0; i < renderingOps.size(); ++i)
1652     {
1653         GraphRenderingOps::AudioGraphRenderingOpBase* const op
1654             = (GraphRenderingOps::AudioGraphRenderingOpBase*) renderingOps.getUnchecked(i);
1655
1656         op->perform (renderingAudioBuffers, renderingCVBuffers, midiBuffers, numSamples);
1657     }
1658
1659     for (uint32_t i = 0; i < audioBuffer.getNumChannels(); ++i)
1660         audioBuffer.copyFrom (i, 0, currentAudioOutputBuffer, i, 0, numSamples);
1661
1662     for (uint32_t i = 0; i < cvOutBuffer.getNumChannels(); ++i)
1663         cvOutBuffer.copyFrom (i, 0, currentCVOutputBuffer, i, 0, numSamples);
1664
1665     midiMessages.clear();
1666     midiMessages.addEvents (currentMidiOutputBuffer, 0, audioBuffer.getNumSamples(), 0);
1667 }
1668
1669 bool AudioProcessorGraph::acceptsMidi() const                       { return true; }
1670 bool AudioProcessorGraph::producesMidi() const                      { return true; }
1671
1672 /*
1673 void AudioProcessorGraph::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
1674 {
1675     processAudio (buffer, midiMessages);
1676 }
1677 */
1678
1679 void AudioProcessorGraph::processBlockWithCV (AudioSampleBuffer& audioBuffer,
1680                                               const AudioSampleBuffer& cvInBuffer,
1681                                               AudioSampleBuffer& cvOutBuffer,
1682                                               MidiBuffer& midiMessages)
1683 {
1684     processAudioAndCV (audioBuffer, cvInBuffer, cvOutBuffer, midiMessages);
1685 }
1686
1687 void AudioProcessorGraph::reorderNowIfNeeded()
1688 {
1689     if (needsReorder)
1690     {
1691         needsReorder = false;
1692         buildRenderingSequence();
1693     }
1694 }
1695
1696 const CarlaRecursiveMutex& AudioProcessorGraph::getReorderMutex() const
1697 {
1698     return reorderMutex;
1699 }
1700
1701 //==============================================================================
1702 AudioProcessorGraph::AudioGraphIOProcessor::AudioGraphIOProcessor (const IODeviceType deviceType)
1703     : type (deviceType), graph (nullptr)
1704 {
1705 }
1706
1707 AudioProcessorGraph::AudioGraphIOProcessor::~AudioGraphIOProcessor()
1708 {
1709 }
1710
1711 const String AudioProcessorGraph::AudioGraphIOProcessor::getName() const
1712 {
1713     switch (type)
1714     {
1715         case audioOutputNode:   return "Audio Output";
1716         case audioInputNode:    return "Audio Input";
1717         case cvOutputNode:      return "CV Output";
1718         case cvInputNode:       return "CV Input";
1719         case midiOutputNode:    return "Midi Output";
1720         case midiInputNode:     return "Midi Input";
1721         default:                break;
1722     }
1723
1724     return String();
1725 }
1726
1727 void AudioProcessorGraph::AudioGraphIOProcessor::prepareToPlay (double, int)
1728 {
1729     CARLA_SAFE_ASSERT (graph != nullptr);
1730 }
1731
1732 void AudioProcessorGraph::AudioGraphIOProcessor::releaseResources()
1733 {
1734 }
1735
1736 void AudioProcessorGraph::AudioGraphIOProcessor::processAudioAndCV (AudioSampleBuffer& audioBuffer,
1737                                                                     const AudioSampleBuffer& cvInBuffer,
1738                                                                     AudioSampleBuffer& cvOutBuffer,
1739                                                                     MidiBuffer& midiMessages)
1740 {
1741     CARLA_SAFE_ASSERT_RETURN(graph != nullptr,);
1742
1743     switch (type)
1744     {
1745         case audioOutputNode:
1746         {
1747             AudioSampleBuffer&  currentAudioOutputBuffer =
1748                 graph->audioAndCVBuffers->currentAudioOutputBuffer;
1749
1750             for (int i = jmin (currentAudioOutputBuffer.getNumChannels(),
1751                                audioBuffer.getNumChannels()); --i >= 0;)
1752             {
1753                 currentAudioOutputBuffer.addFrom (i, 0, audioBuffer, i, 0, audioBuffer.getNumSamples());
1754             }
1755
1756             break;
1757         }
1758
1759         case audioInputNode:
1760         {
1761             AudioSampleBuffer*& currentAudioInputBuffer =
1762                 graph->audioAndCVBuffers->currentAudioInputBuffer;
1763
1764             for (int i = jmin (currentAudioInputBuffer->getNumChannels(),
1765                                audioBuffer.getNumChannels()); --i >= 0;)
1766             {
1767                 audioBuffer.copyFrom (i, 0, *currentAudioInputBuffer, i, 0, audioBuffer.getNumSamples());
1768             }
1769
1770             break;
1771         }
1772
1773         case cvOutputNode:
1774         {
1775             AudioSampleBuffer&  currentCVOutputBuffer =
1776                 graph->audioAndCVBuffers->currentCVOutputBuffer;
1777
1778             for (int i = jmin (currentCVOutputBuffer.getNumChannels(),
1779                                cvInBuffer.getNumChannels()); --i >= 0;)
1780             {
1781                 currentCVOutputBuffer.addFrom (i, 0, cvInBuffer, i, 0, cvInBuffer.getNumSamples());
1782             }
1783
1784             break;
1785         }
1786
1787         case cvInputNode:
1788         {
1789             const AudioSampleBuffer*& currentCVInputBuffer =
1790                 graph->audioAndCVBuffers->currentCVInputBuffer;
1791
1792             for (int i = jmin (currentCVInputBuffer->getNumChannels(),
1793                                cvOutBuffer.getNumChannels()); --i >= 0;)
1794             {
1795                 cvOutBuffer.copyFrom (i, 0, *currentCVInputBuffer, i, 0, cvOutBuffer.getNumSamples());
1796             }
1797
1798             break;
1799         }
1800
1801         case midiOutputNode:
1802             graph->currentMidiOutputBuffer.addEvents (midiMessages, 0, audioBuffer.getNumSamples(), 0);
1803             break;
1804
1805         case midiInputNode:
1806             midiMessages.addEvents (*graph->currentMidiInputBuffer, 0, audioBuffer.getNumSamples(), 0);
1807             break;
1808
1809         default:
1810             break;
1811     }
1812 }
1813
1814 void AudioProcessorGraph::AudioGraphIOProcessor::processBlockWithCV (AudioSampleBuffer& audioBuffer,
1815                                                                      const AudioSampleBuffer& cvInBuffer,
1816                                                                      AudioSampleBuffer& cvOutBuffer,
1817                                                                      MidiBuffer& midiMessages)
1818 {
1819     processAudioAndCV (audioBuffer, cvInBuffer, cvOutBuffer, midiMessages);
1820 }
1821
1822 bool AudioProcessorGraph::AudioGraphIOProcessor::acceptsMidi() const
1823 {
1824     return type == midiOutputNode;
1825 }
1826
1827 bool AudioProcessorGraph::AudioGraphIOProcessor::producesMidi() const
1828 {
1829     return type == midiInputNode;
1830 }
1831
1832 bool AudioProcessorGraph::AudioGraphIOProcessor::isInput() const noexcept
1833 {
1834     return type == audioInputNode || type == cvInputNode || type == midiInputNode;
1835 }
1836
1837 bool AudioProcessorGraph::AudioGraphIOProcessor::isOutput() const noexcept
1838 {
1839     return type == audioOutputNode || type == cvOutputNode || type == midiOutputNode;
1840 }
1841
1842 void AudioProcessorGraph::AudioGraphIOProcessor::setParentGraph (AudioProcessorGraph* const newGraph)
1843 {
1844     graph = newGraph;
1845
1846     if (graph != nullptr)
1847     {
1848         setPlayConfigDetails (type == audioOutputNode
1849                                    ? graph->getTotalNumOutputChannels(AudioProcessor::ChannelTypeAudio)
1850                                    : 0,
1851                               type == audioInputNode
1852                                    ? graph->getTotalNumInputChannels(AudioProcessor::ChannelTypeAudio)
1853                                    : 0,
1854                               type == cvOutputNode
1855                                    ? graph->getTotalNumOutputChannels(AudioProcessor::ChannelTypeCV)
1856                                    : 0,
1857                               type == cvInputNode
1858                                    ? graph->getTotalNumInputChannels(AudioProcessor::ChannelTypeCV)
1859                                    : 0,
1860                               type == midiOutputNode
1861                                    ? graph->getTotalNumOutputChannels(AudioProcessor::ChannelTypeMIDI)
1862                                    : 0,
1863                               type == midiInputNode
1864                                    ? graph->getTotalNumInputChannels(AudioProcessor::ChannelTypeMIDI)
1865                                    : 0,
1866                               getSampleRate(),
1867                               getBlockSize());
1868     }
1869 }
1870
1871 }