CircularSampleBuffer.h

Go to the documentation of this file.

#pragma once
 
#include <cassert>
 
#include "VectorOps.h"
 
/*
 * Utility buffer class for delay-based effects
 * Allocates a 2^n size buffer for branchless write and read using a bitmask
 * It can read and write to past and future samples, but does not check for overlaps
 */
 
namespace staffpad::audio {
 
template <typename SampleT>
class CircularSampleBuffer
{
public:
  CircularSampleBuffer()
  {
  }
 
  ~CircularSampleBuffer()
  {
    if (_buffer)
      free(_buffer);
  }
 
  void setSize(int n)
  {
    if (n > _allocatedSize)
    {
      auto oldSize = _allocatedSize;
 
      auto findLargerPowerOfTwo = [](int32_t number) {
        int32_t powerOf2 = 1;
        while (powerOf2 < number)
          powerOf2 *= 2;
        return powerOf2;
      };
 
      _allocatedSize = findLargerPowerOfTwo(n);
      _bufferSizeMask = _allocatedSize - 1;
      _buffer = (SampleT*)std::realloc(_buffer, _allocatedSize * sizeof(SampleT));
 
      // Reset the new memory region
      assert(_buffer);
      std::fill(_buffer + oldSize, _buffer + _allocatedSize, 0.f);
    }
  }
 
  int getAllocatedSize() const
  {
    return _allocatedSize;
  }
 
  void reset()
  {
    if (_buffer && _allocatedSize > 0)
      memset(_buffer, 0, sizeof(SampleT) * _allocatedSize);
    _position0 = 0;
  }
 
  void write(int offset, const SampleT& sample)
  {
    _buffer[(_position0 + offset) & _bufferSizeMask] = sample;
  }
 
  void writeOffset0(const SampleT& sample)
  {
    _buffer[_position0] = sample;
  }
 
  const SampleT& read(int offset) const
  {
    return _buffer[(_position0 + offset) & _bufferSizeMask];
  }
 
  void advance(int n)
  {
    _position0 += n;
    _position0 &= _bufferSizeMask;
  }
 
private:
  template <typename fnc>
  void _splitBlockOffsetFunction(int startOffset, int n, fnc f) const
  {
    assert(n <= _allocatedSize);
    int firstIndex = (_position0 + startOffset) & _bufferSizeMask;
    int n_to_end = _allocatedSize - firstIndex;
    if (n_to_end > n)
    {
      f(firstIndex, 0, n);
    }
    else
    {
      f(firstIndex, 0, n_to_end);
      f(0, n_to_end, n - n_to_end);
    }
  }
 
public:
  void writeBlock(int startOffset, int n, const SampleT* sourceBlock)
  {
    _splitBlockOffsetFunction(startOffset, n, [=](int bufferOff, int sampleOff, int n) {
      vo::copy(&sourceBlock[sampleOff], &_buffer[bufferOff], n);
    });
  }
 
  void readBlockWithGain(int startOffset, int n, SampleT* targetBlock, float gainFactor) const
  {
    _splitBlockOffsetFunction(startOffset, n, [=](int bufferOff, int sampleOff, int n) {
      vo::constantMultiply(&_buffer[bufferOff], gainFactor, &targetBlock[sampleOff], n);
    });
  }
 
  void readAddBlockWithGain(int startOffset, int n, SampleT* targetBlock, float gainFactor) const
  {
    _splitBlockOffsetFunction(startOffset, n, [=](int bufferOff, int sampleOff, int n) {
      vo::constantMultiplyAndAdd(&_buffer[bufferOff], gainFactor, &targetBlock[sampleOff], n);
    });
  }
 
  void writeAddBlockWithGain(int startOffset, int n, const SampleT* sourceBlock, float gainFactor)
  {
    _splitBlockOffsetFunction(startOffset, n, [=](int bufferOff, int sampleOff, int n) {
      vo::constantMultiplyAndAdd(&sourceBlock[sampleOff], gainFactor, &_buffer[bufferOff], n);
    });
  }
 
  void readBlock(int startOffset, int n, SampleT* targetBlock) const
  {
    _splitBlockOffsetFunction(startOffset, n, [=](int bufferOff, int sampleOff, int n) {
      vo::copy(&_buffer[bufferOff], &targetBlock[sampleOff], n);
    });
  }
 
  void readAndClearBlock(int startOffset, int n, SampleT* targetBlock)
  {
    _splitBlockOffsetFunction(startOffset, n, [=](int bufferOff, int sampleOff, int n) {
      vo::copy(&_buffer[bufferOff], &targetBlock[sampleOff], n);
      vo::setToZero(&_buffer[bufferOff], n);
    });
  }
 
  void clearBlock(int startOffset, int n)
  {
    _splitBlockOffsetFunction(startOffset, n,
                              [=](int bufferOff, int sampleOff, int n) { vo::setToZero(&_buffer[bufferOff], n); });
  }
 
private:
  SampleT* _buffer = nullptr;
 
  int _position0 = 0;     // position of sample index 0 inside _buffer. This is where the next sample will be written to
  int _allocatedSize = 0; // 2^n buffer size
  int _bufferSizeMask = 0; // 2^n-1 buffer mask
};
 
} // namespace staffpad::audio