AudioBuffer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 or the MIT license,
 * at your option. You may not use this file except in compliance with
 * one of these licenses. You may obtain copies of the licenses at:
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 * https://opensource.org/licenses/MIT
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 *
 * @author Yan Pujante
 */
#pragma once
 
#include <pluginterfaces/vst/ivstaudioprocessor.h>
#include <algorithm>
 
#include <pongasoft/Utils/Concepts.h>
#include "AudioUtils.h"
 
namespace pongasoft {
 
using namespace Utils;
 
namespace VST {
 
using namespace Steinberg;
using namespace Steinberg::Vst;
 
// defines the default setup channels (0 is left, 1 is right)
constexpr int32 DEFAULT_LEFT_CHANNEL = 0;
constexpr int32 DEFAULT_RIGHT_CHANNEL = 1;

template<std::floating_point SampleType>
class AudioBuffers
{
public:
  struct AbsoluteMaxOp
  {
    void operator()(SampleType iSample)
    {
      fAbsoluteMax = std::max(fAbsoluteMax, iSample < 0 ? -iSample : iSample);
    }
 
    SampleType fAbsoluteMax = 0;
  };

  class Channel
  {
  public:
    Channel(AudioBuffers &iBuffers, int32 iChannel) : fBuffers{iBuffers}, fChannel{iChannel}
    {
    }

    int32 getNumSamples() const
    {
      return fBuffers.getNumSamples();
    }

    SampleType *getBuffer()
    {
      return fChannel < fBuffers.getNumChannels() ? fBuffers.getBuffer()[fChannel] : nullptr;
    }

    SampleType const *getBuffer() const
    {
      return fChannel < fBuffers.getNumChannels() ? fBuffers.getBuffer()[fChannel] : nullptr;
    }

    bool isSilent() const { return fBuffers.isSilent(fChannel); }

    void setSilenceFlag(bool iSilent)
    {
      fBuffers.setSilenceFlag(fChannel, iSilent);
    }

    bool isActive() const
    {
      return fChannel < fBuffers.getNumChannels() && getBuffer() != nullptr;
    }

    tresult copyTo(Channel &toChannel) const { return toChannel.copyFrom(*this); }

    tresult copyFrom(Channel const &fromChannel)
    {
      int32 numSamples = std::min(getNumSamples(), fromChannel.getNumSamples());
 
      auto ptrFrom = fromChannel.getBuffer();
      auto ptrTo = getBuffer();
 
      // sanity check
      if(!ptrFrom || !ptrTo)
        return kResultFalse;
 
      std::copy(ptrFrom, ptrFrom + numSamples, ptrTo);
 
      return kResultOk;
    }

    SampleType absoluteMax() const
    {
      return forEachSample(AbsoluteMaxOp()).fAbsoluteMax;
    }

    void clear()
    {
      auto buffer = getBuffer();
 
      // sanity check
      if(!buffer)
        return;
 
      std::fill(buffer, buffer + getNumSamples(), 0);
 
      setSilenceFlag(true);
    }

    template<UnaryModifier<SampleType> F>
    F forEachSample(F f)
    {
      auto buffer = getBuffer();
 
      if(buffer)
      {
        return std::for_each(buffer, buffer + getNumSamples(), f);
      }
      else
        return f;
    }

    template<UnaryFunction<SampleType> F>
    F forEachSample(F f) const
    {
      auto buffer = getBuffer();
 
      if(buffer)
      {
        return std::for_each(buffer, buffer + getNumSamples(), f);
      }
      else
        return f;
    }

    template<UnaryTransformer<SampleType> F>
    F copyFrom(Channel const &iFromChannel, F f)
    {
      auto outputBuffer = getBuffer();
      auto inputBuffer = iFromChannel.getBuffer();
 
      if(outputBuffer && inputBuffer)
      {
        int32 const numSamples = std::min(getNumSamples(), iFromChannel.getNumSamples());
 
        // implementation note: adding 'F &' as the template type forces f to be passed
        // by reference otherwise it would be copied which would loose the state (ex: for functors).
        std::transform<decltype(inputBuffer), decltype(outputBuffer), F &>(inputBuffer, inputBuffer + numSamples, outputBuffer, f);
      }
 
      return f;
    }

    template<UnaryTransformer<SampleType> F>
    F copyTo(Channel &oToChannel, F f) const
    {
      return oToChannel.copyFrom(*this, f);
    }
 
  private:
    AudioBuffers &fBuffers;
    int32 fChannel;
  };
 
  typedef AudioBuffers class_type;
 
 
public:
  AudioBuffers(AudioBusBuffers &buffer, int32 numSamples) : fBuffer(buffer), fNumSamples(numSamples)
  {}
 
  // returns true if the buffer is silent (meaning all channels are silent => set to 1) (according to silenceFlags)
  bool isSilent() const
  {
    return fBuffer.numChannels == 0 || fBuffer.silenceFlags == (static_cast<uint64>(1) << fBuffer.numChannels) - 1;
  }

  bool adjustSilenceFlags()
  {
    uint64 silenceFlags = 0;
 
    auto buffer = getBuffer();
 
    for(int32 channel = 0; channel < getNumChannels(); channel++)
    {
      bool silent = true;
 
      auto ptr = buffer[channel];
 
      if(!ptr)
        continue;
 
      for(int j = 0; j < getNumSamples(); ++j, ptr++)
      {
        auto sample = *ptr;
 
        if(silent && !pongasoft::VST::isSilent(sample))
          silent = false;
      }
 
      if(silent)
        BIT_SET(silenceFlags, channel);
    }
 
    fBuffer.silenceFlags = silenceFlags;
 
    return isSilent();
  }
 
  // getSilenceFlags
  uint64 getSilenceFlags() const { return fBuffer.silenceFlags; }
 
  // setSilenceFlags
  void setSilenceFlags(uint64 iFlags) { fBuffer.silenceFlags = iFlags; }

  void setSilenceFlag(int32 iChannel, bool iSilent)
  {
    if(iChannel < getNumChannels())
    {
      if(iSilent)
        BIT_SET(fBuffer.silenceFlags, iChannel);
      else
        BIT_CLEAR(fBuffer.silenceFlags, iChannel);
    }
  }

  void clearSilentFlag()
  {
    fBuffer.silenceFlags = 0;
  }

  bool isSilent(int32 iChannel) const
  {
    if(iChannel < getNumChannels())
    {
      return BIT_TEST(fBuffer.silenceFlags, iChannel);
    }
    return true;
  }

  Channel getAudioChannel(int32 iChannel)
  {
    return Channel{*this, iChannel};
  }

  Channel getAudioChannel(int32 iChannel) const
  {
    // implementation note: removing const since Channel accepts only non const
    return Channel{*const_cast<class_type *>(this), iChannel};
  }

  Channel getLeftChannel() { return getAudioChannel(DEFAULT_LEFT_CHANNEL); }

  Channel getLeftChannel() const { return getAudioChannel(DEFAULT_LEFT_CHANNEL); }

  Channel getRightChannel() { return getAudioChannel(DEFAULT_RIGHT_CHANNEL); }

  Channel getRightChannel() const { return getAudioChannel(DEFAULT_RIGHT_CHANNEL); }

  SampleType **getBuffer();
 
  // returns the underlying (sample) buffer (const version)
  SampleType const * const *getBuffer() const;

  AudioBusBuffers &getAudioBusBuffers() { return fBuffer; }

  AudioBusBuffers const &getAudioBusBuffers() const { return fBuffer; }

  int32 getNumChannels() const { return fBuffer.numChannels; }

  int32 getNumSamples() const { return fNumSamples; }

  template<UnaryModifier<SampleType> F>
  F forEachSample(F f)
  {
    for(int32 channel = 0; channel < getNumChannels(); channel++)
    {
      f = getAudioChannel(channel).forEachSample(f);
    }
 
    return f;
  }

  template<UnaryFunction<SampleType> F>
  F forEachSample(F f) const
  {
    for(int32 channel = 0; channel < getNumChannels(); channel++)
    {
      f = getAudioChannel(channel).forEachSample(f);
    }
 
    return f;
  }

  tresult copyTo(class_type &toBuffer) const { return toBuffer.copyFrom(*this); };

  tresult copyFrom(class_type const &fromBuffer)
  {
    auto fromSamples = fromBuffer.getBuffer();
    auto toSamples = getBuffer();
 
    // there are cases when the 2 buffers could be identical.. no need to copy
    if(fromSamples == toSamples)
      return kResultOk;
 
    // sanity check
    if(!fromSamples || !toSamples)
      return kResultFalse;
 
    int32 numChannels = std::min(getNumChannels(), fromBuffer.getNumChannels());
    int32 numSamples = std::min(getNumSamples(), fromBuffer.getNumSamples());
 
    for(int32 channel = 0; channel < numChannels; channel++)
    {
      auto ptrFrom = fromSamples[channel];
      auto ptrTo = toSamples[channel];
 
      // sanity check
      if(!ptrFrom || !ptrTo)
        continue;
 
      std::copy(ptrFrom, ptrFrom + numSamples, ptrTo);
    }
 
    return kResultOk;
  }

  template<UnaryTransformer<SampleType> F>
  F copyFrom(class_type const &iFromBuffer, F f)
  {
    int32 numChannels = std::min(getNumChannels(), iFromBuffer.getNumChannels());
 
    for(int32 channel = 0; channel < numChannels; channel++)
    {
      f = getAudioChannel(channel).copyFrom(iFromBuffer.getAudioChannel(channel), f);
    }
 
    return f;
  }

  template<UnaryTransformer<SampleType> F>
  F copyTo(class_type &iToBuffer, F f) const { return iToBuffer.copyFrom(*this, f); }

  SampleType absoluteMax() const
  {
    return forEachSample(AbsoluteMaxOp()).fAbsoluteMax;
  }

  tresult clear()
  {
    for(int32 channel = 0; channel < getNumChannels(); channel++)
    {
      getAudioChannel(channel).clear();
    }
 
    return kResultOk;
  }
 
private:
  AudioBusBuffers &fBuffer;
  const int32 fNumSamples;
};
 
template<>
inline Sample32 const * const *AudioBuffers<Sample32>::getBuffer() const { return fBuffer.channelBuffers32; }
 
template<>
inline Sample64 const * const *AudioBuffers<Sample64>::getBuffer() const { return fBuffer.channelBuffers64; }
 
template<>
inline Sample32 **AudioBuffers<Sample32>::getBuffer() { return fBuffer.channelBuffers32; }
 
template<>
inline Sample64 **AudioBuffers<Sample64>::getBuffer() { return fBuffer.channelBuffers64; }
 
typedef AudioBuffers<Sample32> AudioBuffers32;
typedef AudioBuffers<Sample64> AudioBuffers64;
 
}
}