hart_audio_buffer_fill_with.hpp

Go to the documentation of this file.

#pragma once
 
#include "hart_exceptions.hpp"
 
namespace hart {
 
template <typename SampleType>
void AudioBuffer<SampleType>::_fillWith (SignalBase<SampleType>& signal, size_t requestedBlockSizeFrames, Preparation signalPreparation)
{
    if (getNumChannels() == 0)
        HART_THROW_OR_RETURN_VOID (hart::ChannelLayoutError, "Can't fill an AudioBuffer with Signal if the buffer is default-constructed or has no channels allocated");
 
    if (getNumFrames() == 0)
        HART_THROW_OR_RETURN_VOID (hart::SizeError, "Can't fill an AudioBuffer with Signal if the buffer is default-constructed or has no frames allocated");
 
    if (! hasSampleRate())
        HART_THROW_OR_RETURN_VOID (hart::SampleRateError, "Can't fill an AudioBuffer with Signal if the buffer's sample rate is undefined");
 
    if (! signal.supportsNumChannelsWithDSPChain (getNumChannels()))
        HART_THROW_OR_RETURN_VOID (hart::ChannelLayoutError, "Signal or an effect in its DSP chain doesn't support the number of channels that this buffer has");
 
    if (! signal.supportsSampleRateWithDSPChain (getSampleRateHz()))
        HART_THROW_OR_RETURN_VOID (hart::SampleRateError, "Signal or an effect in its DSP chain doesn't support the sample rate that this buffer has");
 
    const size_t blockSizeFrames = (requestedBlockSizeFrames == 0) ? getNumFrames() : requestedBlockSizeFrames;
 
    if (signalPreparation == Preparation::reset || signalPreparation == Preparation::resetAndPrepare)
        signal.resetWithDSPChain();
 
    if (signalPreparation == Preparation::prepare || signalPreparation == Preparation::resetAndPrepare)
        signal.prepareWithDSPChain (getSampleRateHz(), getNumChannels(), blockSizeFrames);
 
    if (blockSizeFrames >= getNumFrames())
    {
        // Render in one go
        signal.renderNextBlockWithDSPChain (*this);
        return;
    }
 
    size_t offsetFrames = 0;
    hart::AudioBuffer<SampleType> block (getNumChannels(), blockSizeFrames, getSampleRateHz());
 
    while (offsetFrames < getNumFrames())
    {
        const size_t currentBlockSizeFrames = std::min (blockSizeFrames, getNumFrames() - offsetFrames);
        hassert (currentBlockSizeFrames <= blockSizeFrames);
 
        if (currentBlockSizeFrames != block.getNumFrames())
        {
            // Expecting partial block at the end
            hassert (currentBlockSizeFrames < blockSizeFrames);
            hassert (block.getNumFrames() == blockSizeFrames);
 
            block.setNumFrames (currentBlockSizeFrames);
        }
 
        signal.renderNextBlockWithDSPChain (block);
 
        hassert (getNumFrames() > block.getNumFrames());
        hassert (getNumChannels() == block.getNumChannels());
 
        for (size_t channel = 0; channel < getNumChannels(); ++channel)
            copyFrom (channel, offsetFrames, block, channel, 0, currentBlockSizeFrames);
 
        offsetFrames += currentBlockSizeFrames;
    }
}
 
} // namespace hart