AudioBuffer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 <pongasoft/logging/logging.h>
#include <algorithm>

#include "AudioUtils.h"

namespace pongasoft {
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<typename 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}
    {
    }

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

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

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

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

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

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

    inline 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;
    }

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

    inline void clear()
    {
      auto buffer = getBuffer();

      // sanity check
      if(!buffer)
        return;

      std::fill(buffer, buffer + getNumSamples(), 0);

      setSilenceFlag(true);
    }

    template<typename UnaryFunction>
    inline UnaryFunction forEachSample(UnaryFunction f)
    {
      auto buffer = getBuffer();

      if(buffer)
      {
        return std::for_each(buffer, buffer + getNumSamples(), f);
      }
      else
        return f;
    }

    template<typename UnaryFunction>
    inline UnaryFunction forEachSample(UnaryFunction f) const
    {
      auto buffer = getBuffer();

      if(buffer)
      {
        return std::for_each(buffer, buffer + getNumSamples(), f);
      }
      else
        return f;
    }

    template<typename UnaryOperation>
    inline UnaryOperation copyFrom(Channel const &iFromChannel, UnaryOperation f)
    {
      auto outputBuffer = getBuffer();
      auto inputBuffer = iFromChannel.getBuffer();

      if(outputBuffer && inputBuffer)
      {
        int32 const numSamples = std::min(getNumSamples(), iFromChannel.getNumSamples());

        // implementation note: adding 'UnaryOperation &' 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), UnaryOperation &>(inputBuffer, inputBuffer + numSamples, outputBuffer, f);
      }

      return f;
    }

    template<typename UnaryOperation>
    inline UnaryOperation copyTo(Channel &oToChannel, UnaryOperation f) const
    {
      return oToChannel.copyFrom(*this, f);
    }

  private:
    AudioBuffers &fBuffers;
    int32 fChannel;
  };

  typedef AudioBuffers<SampleType> 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)
  inline bool isSilent() const
  {
    return fBuffer.numChannels == 0 || fBuffer.silenceFlags == (static_cast<uint64>(1) << fBuffer.numChannels) - 1;
  }

  inline 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
  inline uint64 getSilenceFlags() const { return fBuffer.silenceFlags; }

  // setSilenceFlags
  inline void setSilenceFlags(uint64 iFlags) const { fBuffer.silenceFlags = iFlags; }

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

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

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

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

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

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

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

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

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

  inline SampleType **getBuffer();

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

  inline AudioBusBuffers &getAudioBusBuffers() { return fBuffer; }

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

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

  inline int32 getNumSamples() const { return fNumSamples; }

  template<typename UnaryFunction>
  inline UnaryFunction forEachSample(UnaryFunction f)
  {
    for(int32 channel = 0; channel < getNumChannels(); channel++)
    {
      f = getAudioChannel(channel).forEachSample(f);
    }

    return f;
  }

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

    return f;
  }

  inline 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<typename UnaryOperation>
  inline UnaryOperation copyFrom(class_type const &iFromBuffer, UnaryOperation 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<typename UnaryOperation>
  inline UnaryOperation copyTo(class_type &iToBuffer, UnaryOperation f) const { return iToBuffer.copyFrom(*this, f); };

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

  inline 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;

}
}