falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Browse Source

The minified juce graph class is done

tags/1.9.8
falkTX 7 years ago
parent
898121c8e4
commit
aab8d414ca
4 changed files with 30 additions and 110 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -1
      source/modules/juce_audio_graph/juce_audio_graph.cpp
  2. +4
    -1
      source/modules/juce_audio_graph/juce_audio_graph.h
  3. +19
    -101
      source/modules/juce_audio_graph/processors/juce_AudioProcessorGraph.cpp
  4. +6
    -7
      source/modules/juce_audio_graph/processors/juce_AudioProcessorGraph.h

+ 1
- 1
source/modules/juce_audio_graph/juce_audio_graph.cpp View File

@@ -33,7 +33,7 @@
// #include <wctype.h>
//==============================================================================
namespace juce
namespace juce2
{
#include "memory/juce_MemoryBlock.cpp"


+ 4
- 1
source/modules/juce_audio_graph/juce_audio_graph.h View File

@@ -106,7 +106,7 @@
#define NEEDS_TRANS(x) (x)
//==============================================================================
namespace juce
namespace juce2
{
class File;
@@ -127,12 +127,15 @@ class StringRef;
#include "memory/juce_HeapBlock.h"
#include "memory/juce_MemoryBlock.h"
#include "memory/juce_ReferenceCountedObject.h"
#include "text/juce_NewLine.h"
#include "containers/juce_ElementComparator.h"
#include "containers/juce_ArrayAllocationBase.h"
#include "containers/juce_Array.h"
#include "containers/juce_OwnedArray.h"
#include "containers/juce_ReferenceCountedArray.h"
#include "containers/juce_SortedSet.h"
// #include "containers/juce_Variant.h"
// #include "containers/juce_NamedValueSet.h"


+ 19
- 101
source/modules/juce_audio_graph/processors/juce_AudioProcessorGraph.cpp View File

@@ -26,38 +26,6 @@
const int AudioProcessorGraph::midiChannelIndex = 0x1000;
#if 0
//==============================================================================
template <typename FloatType, typename Impl> struct FloatDoubleUtil {};
template <typename Tag, typename Type> struct FloatDoubleType {};
template <typename Tag>
struct FloatAndDoubleComposition
{
typedef typename FloatDoubleType<Tag, float>::Type FloatType;
typedef typename FloatDoubleType<Tag, double>::Type DoubleType;
template <typename FloatingType>
inline typename FloatDoubleType<Tag, FloatingType>::Type& get() noexcept
{
return FloatDoubleUtil<FloatingType, FloatAndDoubleComposition<Tag> >::get (*this);
}
FloatType floatVersion;
DoubleType doubleVersion;
};
template <typename Impl> struct FloatDoubleUtil<float, Impl> { static inline typename Impl::FloatType& get (Impl& i) noexcept { return i.floatVersion; } };
template <typename Impl> struct FloatDoubleUtil<double, Impl> { static inline typename Impl::DoubleType& get (Impl& i) noexcept { return i.doubleVersion; } };
struct FloatPlaceholder;
template <typename FloatingType> struct FloatDoubleType<HeapBlock<FloatPlaceholder>, FloatingType> { typedef HeapBlock<FloatingType> Type; };
template <typename FloatingType> struct FloatDoubleType<HeapBlock<FloatPlaceholder*>, FloatingType> { typedef HeapBlock<FloatingType*> Type; };
template <typename FloatingType> struct FloatDoubleType<AudioBuffer<FloatPlaceholder>, FloatingType> { typedef AudioBuffer<FloatingType> Type; };
template <typename FloatingType> struct FloatDoubleType<AudioBuffer<FloatPlaceholder>*, FloatingType> { typedef AudioBuffer<FloatingType>* Type; };
#endif
//==============================================================================
namespace GraphRenderingOps
{
@@ -219,7 +187,6 @@ private:
JUCE_DECLARE_NON_COPYABLE (DelayChannelOp)
};
#if 0
//==============================================================================
struct ProcessBufferOp : public AudioGraphRenderingOp<ProcessBufferOp>
{
@@ -241,7 +208,7 @@ struct ProcessBufferOp : public AudioGraphRenderingOp<ProcessBufferOp>
void perform (AudioSampleBuffer& sharedBufferChans, const OwnedArray<MidiBuffer>& sharedMidiBuffers, const int numSamples)
{
HeapBlock<float*>& channels = audioChannels();
HeapBlock<float*>& channels = audioChannels;
for (int i = totalChans; --i >= 0;)
channels[i] = sharedBufferChans.getWritePointer (audioChannelsToUse.getUnchecked (i), 0);
@@ -270,14 +237,13 @@ struct ProcessBufferOp : public AudioGraphRenderingOp<ProcessBufferOp>
private:
Array<int> audioChannelsToUse;
FloatAndDoubleComposition<HeapBlock<FloatPlaceholder*> > audioChannels;
HeapBlock<float*> audioChannels;
AudioSampleBuffer tempBuffer;
const int totalChans;
const int midiBufferToUse;
JUCE_DECLARE_NON_COPYABLE (ProcessBufferOp)
};
#endif
//==============================================================================
/** Used to calculate the correct sequence of rendering ops needed, based on
@@ -303,9 +269,7 @@ struct RenderingOpSequenceCalculator
markAnyUnusedBuffersAsFree (i);
}
#if 0
graph.setLatencySamples (totalLatency);
#endif
}
int getNumBuffersNeeded() const noexcept { return nodeIds.size(); }
@@ -363,15 +327,10 @@ private:
Array<void*>& renderingOps,
const int ourRenderingIndex)
{
#if 0
AudioProcessor& processor = *node.getProcessor();
const int numIns = processor.getTotalNumInputChannels();
const int numOuts = processor.getTotalNumOutputChannels();
const int totalChans = jmax (numIns, numOuts);
#else
const int numIns = 0;
const int numOuts = 0;
#endif
Array<int> audioChannelsToUse;
int midiBufferToUse = -1;
@@ -566,10 +525,8 @@ private:
// No midi inputs..
midiBufferToUse = getFreeBuffer (true); // need to pick a buffer even if the processor doesn't use midi
#if 0
if (processor.acceptsMidi() || processor.producesMidi())
renderingOps.add (new ClearMidiBufferOp (midiBufferToUse));
#endif
}
else if (midiSourceNodes.size() == 1)
{
@@ -648,7 +605,6 @@ private:
}
}
#if 0
if (processor.producesMidi())
markBufferAsContaining (midiBufferToUse, node.nodeId,
AudioProcessorGraph::midiChannelIndex);
@@ -660,7 +616,6 @@ private:
renderingOps.add (new ProcessBufferOp (&node, audioChannelsToUse,
totalChans, midiBufferToUse));
#endif
}
//==============================================================================
@@ -754,13 +709,11 @@ private:
}
else
{
#if 0
for (int i = 0; i < node->getProcessor()->getTotalNumInputChannels(); ++i)
if (i != inputChannelOfIndexToIgnore
&& graph.getConnectionBetween (nodeId, outputChanIndex,
node->nodeId, i) != nullptr)
return true;
#endif
}
inputChannelOfIndexToIgnore = -1;
@@ -810,9 +763,7 @@ public:
entries.insert (index, entry);
}
#if 0
entry->srcNodes.add (c->sourceNodeId);
#endif
}
}
@@ -829,9 +780,7 @@ private:
explicit Entry (const uint32 destNodeId_) noexcept : destNodeId (destNodeId_) {}
const uint32 destNodeId;
#if 0
SortedSet<uint32> srcNodes;
#endif
JUCE_DECLARE_NON_COPYABLE (Entry)
};
@@ -846,7 +795,6 @@ private:
if (const Entry* const entry = findEntry (possibleDestinationId, index))
{
#if 0
const SortedSet<uint32>& srcNodes = entry->srcNodes;
if (srcNodes.contains (possibleInputId))
@@ -858,10 +806,6 @@ private:
if (isAnInputToRecursive (possibleInputId, srcNodes.getUnchecked(i), recursionCheck))
return true;
}
#else
(void)possibleInputId;
(void)recursionCheck;
#endif
}
return false;
@@ -1010,7 +954,7 @@ struct AudioProcessorGraph::AudioProcessorGraphBufferHelpers
//==============================================================================
AudioProcessorGraph::AudioProcessorGraph()
: lastNodeId (0), audioBuffers (new AudioProcessorGraphBufferHelpers),
currentMidiInputBuffer (nullptr), isPrepared (false)
currentMidiInputBuffer (nullptr), isPrepared (false), needsReorder (false)
{
}
@@ -1028,16 +972,11 @@ const String AudioProcessorGraph::getName() const
//==============================================================================
void AudioProcessorGraph::clear()
{
#if 0
nodes.clear();
#endif
connections.clear();
#if 0
triggerAsyncUpdate();
#endif
needsReorder = true;
}
#if 0
AudioProcessorGraph::Node* AudioProcessorGraph::getNodeForId (const uint32 nodeId) const
{
for (int i = nodes.size(); --i >= 0;)
@@ -1084,7 +1023,7 @@ AudioProcessorGraph::Node* AudioProcessorGraph::addNode (AudioProcessor* const n
nodes.add (n);
if (isPrepared)
triggerAsyncUpdate();
needsReorder = true;
n->setParentGraph (this);
return n;
@@ -1101,7 +1040,7 @@ bool AudioProcessorGraph::removeNode (const uint32 nodeId)
nodes.remove (i);
if (isPrepared)
triggerAsyncUpdate();
needsReorder = true;
return true;
}
@@ -1118,7 +1057,6 @@ bool AudioProcessorGraph::removeNode (Node* node)
jassertfalse;
return false;
}
#endif
//==============================================================================
const AudioProcessorGraph::Connection* AudioProcessorGraph::getConnectionBetween (const uint32 sourceNodeId,
@@ -1148,7 +1086,6 @@ bool AudioProcessorGraph::isConnected (const uint32 possibleSourceNodeId,
return false;
}
#if 0
bool AudioProcessorGraph::canConnect (const uint32 sourceNodeId,
const int sourceChannelIndex,
const uint32 destNodeId,
@@ -1177,7 +1114,6 @@ bool AudioProcessorGraph::canConnect (const uint32 sourceNodeId,
return getConnectionBetween (sourceNodeId, sourceChannelIndex,
destNodeId, destChannelIndex) == nullptr;
}
#endif
bool AudioProcessorGraph::addConnection (const uint32 sourceNodeId,
const int sourceChannelIndex,
@@ -1191,10 +1127,8 @@ bool AudioProcessorGraph::addConnection (const uint32 sourceNodeId,
connections.addSorted (sorter, new Connection (sourceNodeId, sourceChannelIndex,
destNodeId, destChannelIndex));
#if 0
if (isPrepared)
triggerAsyncUpdate();
#endif
needsReorder = true;
return true;
}
@@ -1203,10 +1137,8 @@ void AudioProcessorGraph::removeConnection (const int index)
{
connections.remove (index);
#if 0
if (isPrepared)
triggerAsyncUpdate();
#endif
needsReorder = true;
}
bool AudioProcessorGraph::removeConnection (const uint32 sourceNodeId, const int sourceChannelIndex,
@@ -1249,7 +1181,6 @@ bool AudioProcessorGraph::disconnectNode (const uint32 nodeId)
return doneAnything;
}
#if 0
bool AudioProcessorGraph::isConnectionLegal (const Connection* const c) const
{
jassert (c != nullptr);
@@ -1264,7 +1195,6 @@ bool AudioProcessorGraph::isConnectionLegal (const Connection* const c) const
&& (c->destChannelIndex != midiChannelIndex ? isPositiveAndBelow (c->destChannelIndex, dest->processor->getTotalNumInputChannels())
: dest->processor->acceptsMidi());
}
#endif
bool AudioProcessorGraph::removeIllegalConnections()
{
@@ -1301,7 +1231,6 @@ void AudioProcessorGraph::clearRenderingSequence()
deleteRenderOpArray (oldOps);
}
#if 0
bool AudioProcessorGraph::isAnInputTo (const uint32 possibleInputId,
const uint32 possibleDestinationId,
const int recursionCheck) const
@@ -1321,7 +1250,6 @@ bool AudioProcessorGraph::isAnInputTo (const uint32 possibleInputId,
return false;
}
#endif
void AudioProcessorGraph::buildRenderingSequence()
{
@@ -1330,21 +1258,18 @@ void AudioProcessorGraph::buildRenderingSequence()
int numMidiBuffersNeeded = 1;
{
#if 0
MessageManagerLock mml;
#endif
const CarlaRecursiveMutexLocker cml (reorderMutex);
Array<Node*> orderedNodes;
{
const GraphRenderingOps::ConnectionLookupTable table (connections);
#if 0
for (int i = 0; i < nodes.size(); ++i)
{
Node* const node = nodes.getUnchecked(i);
node->prepare (getSampleRate(), getBlockSize(), this, getProcessingPrecision());
node->prepare (getSampleRate(), getBlockSize(), this);
int j = 0;
for (; j < orderedNodes.size(); ++j)
@@ -1353,7 +1278,6 @@ void AudioProcessorGraph::buildRenderingSequence()
orderedNodes.insert (j, node);
}
#endif
}
GraphRenderingOps::RenderingOpSequenceCalculator calculator (*this, orderedNodes, newRenderingOps);
@@ -1381,13 +1305,6 @@ void AudioProcessorGraph::buildRenderingSequence()
deleteRenderOpArray (newRenderingOps);
}
#if 0
void AudioProcessorGraph::handleAsyncUpdate()
{
buildRenderingSequence();
}
#endif
//==============================================================================
void AudioProcessorGraph::prepareToPlay (double /*sampleRate*/, int estimatedSamplesPerBlock)
{
@@ -1406,10 +1323,8 @@ void AudioProcessorGraph::releaseResources()
{
isPrepared = false;
#if 0
for (int i = 0; i < nodes.size(); ++i)
nodes.getUnchecked(i)->unprepare();
#endif
audioBuffers->release();
midiBuffers.clear();
@@ -1422,10 +1337,8 @@ void AudioProcessorGraph::reset()
{
const CarlaRecursiveMutexLocker cml (getCallbackLock());
#if 0
for (int i = 0; i < nodes.size(); ++i)
nodes.getUnchecked(i)->getProcessor()->reset();
#endif
}
void AudioProcessorGraph::setNonRealtime (bool isProcessingNonRealtime) noexcept
@@ -1434,10 +1347,8 @@ void AudioProcessorGraph::setNonRealtime (bool isProcessingNonRealtime) noexcept
AudioProcessor::setNonRealtime (isProcessingNonRealtime);
#if 0
for (int i = 0; i < nodes.size(); ++i)
nodes.getUnchecked(i)->getProcessor()->setNonRealtime (isProcessingNonRealtime);
#endif
}
void AudioProcessorGraph::setPlayHead (AudioPlayHead* audioPlayHead)
@@ -1446,10 +1357,8 @@ void AudioProcessorGraph::setPlayHead (AudioPlayHead* audioPlayHead)
AudioProcessor::setPlayHead (audioPlayHead);
#if 0
for (int i = 0; i < nodes.size(); ++i)
nodes.getUnchecked(i)->getProcessor()->setPlayHead (audioPlayHead);
#endif
}
void AudioProcessorGraph::processAudio (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
@@ -1490,6 +1399,15 @@ void AudioProcessorGraph::processBlock (AudioSampleBuffer& buffer, MidiBuffer& m
processAudio (buffer, midiMessages);
}
void AudioProcessorGraph::reorderNowIfNeeded()
{
if (needsReorder)
{
needsReorder = false;
buildRenderingSequence();
}
}
//==============================================================================
AudioProcessorGraph::AudioGraphIOProcessor::AudioGraphIOProcessor (const IODeviceType deviceType)
: type (deviceType), graph (nullptr)


+ 6
- 7
source/modules/juce_audio_graph/processors/juce_AudioProcessorGraph.h View File

@@ -59,7 +59,7 @@ public:
To create a node, call AudioProcessorGraph::addNode().
*/
class JUCE_API Node /*: public ReferenceCountedObject*/
class JUCE_API Node : public ReferenceCountedObject
{
public:
//==============================================================================
@@ -79,11 +79,11 @@ public:
is displaying the nodes on-screen.
*/
NamedValueSet properties;
#endif
//==============================================================================
/** A convenient typedef for referring to a pointer to a node object. */
typedef ReferenceCountedObjectPtr<Node> Ptr;
#endif
private:
//==============================================================================
@@ -153,7 +153,6 @@ public:
*/
void clear();
#if 0
/** Returns the number of nodes in the graph. */
int getNumNodes() const noexcept { return nodes.size(); }
@@ -193,7 +192,6 @@ public:
This will also delete any connections that are attached to this node.
*/
bool removeNode (Node* node);
#endif
//==============================================================================
/** Returns the number of connections in the graph. */
@@ -354,14 +352,14 @@ public:
bool acceptsMidi() const override;
bool producesMidi() const override;
void reorderNowIfNeeded();
private:
//==============================================================================
void processAudio (AudioSampleBuffer& buffer, MidiBuffer& midiMessages);
//==============================================================================
#if 0
ReferenceCountedArray<Node> nodes;
#endif
OwnedArray<Connection> connections;
uint32 lastNodeId;
OwnedArray<MidiBuffer> midiBuffers;
@@ -374,7 +372,8 @@ private:
MidiBuffer* currentMidiInputBuffer;
MidiBuffer currentMidiOutputBuffer;
bool isPrepared;
bool isPrepared, needsReorder;
CarlaRecursiveMutex reorderMutex;
void clearRenderingSequence();
void buildRenderingSequence();


Write Preview
Loading…
Cancel
Save