Bufferize node in a graph

[Ayra]

Hi, I created My own class that inherit AudioProcessorGraph, my goal il to bufferize a node that is too hard to process with a longer blockSize, My thought is:

I have a queue done by 3 audioBuffer, when I ì’m in the processBlock I process once yes and once no the node with blockSize*2. Up to now I get only noise in output.

here the .h

class ProcessorWrapper
{
public:
    ProcessorWrapper(MyAudioProcessorGraph* owner,
                     juce::AudioProcessorGraph::Node::Ptr node);
    
    bool operator== (const ProcessorWrapper& other) const noexcept { return wrappedProcessor == other.wrappedProcessor; }
    bool operator!= (const ProcessorWrapper& other) const noexcept { return wrappedProcessor != other.wrappedProcessor; }

    //==============================================================================
    
    void setBufferiziation(bool enable);
    bool getBufferization() const { return bufferized; }

    //==============================================================================

    void processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages);
    void processBlock(juce::AudioBuffer<double>& buffer, juce::MidiBuffer& midiMessages);
    
    //==============================================================================
    
    juce::AudioProcessor* getWrappedProcessor() const { return wrappedProcessor; }
    
private:
    
    MyAudioProcessorGraph* graph;
    juce::AudioProcessor* wrappedProcessor;
    
    bool bufferized = false;
    
    //==============================================================================
    
    bool processed = false;
    bool prepared  = false;
    int numProcessBlock = 0;
    
    juce::Array<AudioBuffer<float>>  bufferizedBufferFloat  {};    
    //==============================================================================
    
    void prepareToPlay(double sampleRate, int samplesPerBlock);

};

and here the .cpp

ProcessorWrapper::ProcessorWrapper(MTAudioProcessorGraph* owner, juce::AudioProcessorGraph::Node::Ptr node) : graph(owner), wrappedProcessor(node->getProcessor())
    {
    }

    void ProcessorWrapper::setBufferiziation(bool enable)
    {
        if (!wrappedProcessor || !graph) { return; }
        
        if (bufferized == enable) { return; }

        bufferized = enable;
        
        prepared  = false;
        
        numProcessBlock = 0;
        
        prepareToPlay(graph->getSampleRate(), graph->getBlockSize());
    }
    
    void ProcessorWrapper::prepareToPlay(double sampleRate, int samplesPerBlock) 
    {
        if (!wrappedProcessor || !graph) { return; }
        
        numProcessBlock = 0;
        
        if (bufferized)
        {
            bufferizedBufferFloat.clear();
            bufferizedBufferDouble.clear();
            
            bufferizedBufferFloat.ensureStorageAllocated(3);           
            bufferizedBufferDouble.ensureStorageAllocated(3);
            
            for (int i = 0; i < 3; ++i)
            {
                bufferizedBufferFloat.add(juce::AudioBuffer<float>(wrappedProcessor->getTotalNumInputChannels(), samplesPerBlock));
                bufferizedBufferDouble.add(juce::AudioBuffer<double>(wrappedProcessor->getTotalNumInputChannels(), samplesPerBlock));
            }
            
            processed = false;
            
            wrappedProcessor->setRateAndBufferSizeDetails(sampleRate, samplesPerBlock*2);
            wrappedProcessor->prepareToPlay(sampleRate, samplesPerBlock*2);
            
        } else {
            wrappedProcessor->prepareToPlay(sampleRate, samplesPerBlock);
        }
        
        prepared = true;
    }

    void ProcessorWrapper::processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages)
    {
        if (!wrappedProcessor || !graph) { return; }
        
        if (bufferized && prepared)
        {
            const int numChannels = jmax(wrappedProcessor->getTotalNumInputChannels(), wrappedProcessor->getTotalNumOutputChannels());
            const int numSamples  = buffer.getNumSamples();
            
            jassert(bufferizedBufferFloat.size() == 3);

            bufferizedBufferFloat[0].makeCopyOf(buffer);
                                      
            if (numProcessBlock < 2)
            {
                processed = false;
                
                for (int ch = 0; ch < numChannels; ++ch)
                {
                    bufferizedBufferFloat[2].makeCopyOf(bufferizedBufferFloat[1]);
                    bufferizedBufferFloat[1].makeCopyOf(bufferizedBufferFloat[0]);
                }
                
                numProcessBlock++;
                
                return;
            }
            
            if (!processed)
            {
                juce::AudioBuffer<float> combinedBuffer(numChannels, numSamples * 2);
                
                for (int ch = 0; ch < numChannels; ++ch)
                {
                    combinedBuffer.copyFrom(ch, 0,          bufferizedBufferFloat[1].getReadPointer(ch), numSamples);
                    combinedBuffer.copyFrom(ch, numSamples, bufferizedBufferFloat[2].getReadPointer(ch), numSamples);
                }

                wrappedProcessor->processBlock(combinedBuffer, midiMessages);

                for (int ch = 0; ch < numChannels; ++ch)
                {
                    bufferizedBufferFloat[1].copyFrom(ch, 0, combinedBuffer, ch, 0,          numSamples);
                    bufferizedBufferFloat[2].copyFrom(ch, 0, combinedBuffer, ch, numSamples, numSamples);
                }
                
                buffer.makeCopyOf(bufferizedBufferFloat[1]);
                
                for (int ch = 0; ch < numChannels; ++ch)
                {
                    bufferizedBufferFloat[1].makeCopyOf(bufferizedBufferFloat[0]);
                }
            } else {

                buffer.makeCopyOf(bufferizedBufferFloat.getLast());
                
                for (int ch = 0; ch < numChannels; ++ch)
                {
                    bufferizedBufferFloat[2].makeCopyOf(bufferizedBufferFloat[1]);
                    bufferizedBufferFloat[1].makeCopyOf(bufferizedBufferFloat[0]);
                }
            }
            
            processed = !processed;

        } else {
            wrappedProcessor->processBlock(buffer, midiMessages);
        }
    }

(ps I know I need also a MidiBuffer otherwise once yes and once no the midi messages should be missed)

[Ayra]

I have to consider everything, in reality with this approach the process is done each two but with double weight because of the double of samples.

What should be the good practice to Bufferize a plugin?

I need to start another real-time thread with a callback each samples*2 and in this callback doing the processBlock of plugin (prepared with double BlockSize). But how to sync with the graph callback call?

Really thank you!