sampleDelay.cpp

// Copyright (c) 2012-2017 VideoStitch SAS
// Copyright (c) 2018 stitchEm

#include "sampleDelay.hpp"

#include <cmath>
#include <cassert>

namespace VideoStitch {
namespace Audio {

// --- Constructor ------------------------------

SampleDelay::SampleDelay() : AudioObject("delay", AudioFunction::PROCESSOR), curDelayTime_(0) {}

// --- Helpers ----------------------------------

namespace {
inline size_t convertSecondsToSamples(double seconds) {
  return static_cast<size_t>(seconds * getDefaultSamplingRate());
}
inline double convertSamplesToSeconds(size_t samples) {
  return static_cast<double>(samples) / getDefaultSamplingRate();
}
}  // namespace

// --- Set / get --------------------------------

Status SampleDelay::setDelaySeconds(double delayInSeconds) {
  std::lock_guard<std::mutex> lock(delayMutex_);
  curDelayTime_ = convertSecondsToSamples(delayInSeconds);
  return Status::OK();
}

double SampleDelay::getDelaySeconds() {
  std::lock_guard<std::mutex> lock(delayMutex_);
  return convertSamplesToSeconds(curDelayTime_);
}

void SampleDelay::setDelaySamples(size_t delayInSamples) {
  std::lock_guard<std::mutex> lock(delayMutex_);
  curDelayTime_ = delayInSamples;
}

size_t SampleDelay::getDelaySamples() {
  std::lock_guard<std::mutex> lock(delayMutex_);
  return curDelayTime_;
}

// --- Processing -------------------------------

namespace {
void applyWindow(const std::vector<audioSample_t>& inFadeOut, const std::vector<audioSample_t>& inFadeIn,
                 std::vector<audioSample_t>* winOut) {
  size_t numPoints = inFadeOut.size() * 2;
  std::vector<audioSample_t> win;
  for (size_t i = 0; i < numPoints; i++) {
    // Generate Hann window (https://www.youtube.com/watch?v=oHg5SJYRHA0)
    audioSample_t point = 0.5 - (0.5 * cos((2.0 * M_PI * (double)i) / ((double)numPoints - 1)));
    win.push_back(point);
  }
  size_t offset = (numPoints / 2) - 1;
  for (size_t i = 0; i < inFadeIn.size(); i++) {
    audioSample_t sample = (inFadeIn.data()[i] * win.data()[i]) + (inFadeOut.data()[i] * win.data()[i + offset]);
    winOut->push_back(sample);
  }
}

size_t getDiff(size_t delayTime, size_t oldDelayTime, size_t inputSize) {
  size_t diff = std::abs((int)delayTime - (int)oldDelayTime);

  // Below we do  xxEnd = CURRENT_DELAY_BUFFER.end() - inputSize - oldDelayTime + diff;
  // and          xxEnd = CURRENT_DELAY_BUFFER.end() - inputSize - delayTime + diff;
  // so the following checks are necessary to not go beyond the end of CURRENT_DELAY_BUFFER.
  // Also, the window can't be bigger that the block size.

  if (diff > (int)inputSize - oldDelayTime) {
    diff = inputSize - oldDelayTime;
  }
  if (diff > (int)inputSize - delayTime) {
    diff = inputSize - delayTime;
  }
  if (diff > inputSize) {
    diff = inputSize;
  }

  return diff;
}
}  // namespace

/// \fn void SampleDelay::step(AudioBlock& in, AudioBlock& out)
/// \brief A sample delay audio processing block
/// \param in The audio input
/// \param out Delayed output
///
/// If the delay value changes, we apply Hann windowing to avoid clicks
///
///   input        :                 +=======+
///   delay buffer : +-- // ---------+=======+
///   old delay    :                   *******     oldDelayTime
///   old output   :          +=======+
///   old window   :          |--|                 inFadeOut
///   new delay    :                      ****     delayTime
///   new output   :             +=======+
///   new window   :             |--|              inFadeIn
///   output       :             +<>+====+         winOut + samples from delay buffer
///   difference   :       -->|  |<--              abs(delayTime - oldDelayTime)
///
///
/// If the delay doesn't change, we simply copy
///
///   input        :              +=======+
///   delay buffer : +-- // ------+=======+
///   output       :         +=======+
///   delay time   :                  *****

#define CURRENT_DELAY_BUFFER delayBuffers_[track.channel()]

void SampleDelay::step(AudioBlock& out, const AudioBlock& in) {
  for (auto& track : in) {
    const size_t inputSize = track.size();

    // Insert new samples into delay buffer
    for (auto& s : track) {
      CURRENT_DELAY_BUFFER.push_back(s);
    }
    // TODO DEBUG this with lucas
    //    CURRENT_DELAY_BUFFER.insert(CURRENT_DELAY_BUFFER.begin(), track.begin(), track.end());

    size_t delayTime;
    //    size_t oldDelayTime;
    {
      std::lock_guard<std::mutex> lock(delayMutex_);
      delayTime = curDelayTime_;
    }
    // TO DEBUG WITH LUCAS
    //    {
    //      std::lock_guard<std::mutex> lock(delayMutex_);
    //      // The maximum delay we can apply right now
    //      size_t possibleDelay = CURRENT_DELAY_BUFFER.size() - inputSize;
    //      // The delay we will apply : the minimum of requested and possible
    //      delayTime = (possibleDelay < curDelayTime_) ? possibleDelay : curDelayTime_;
    //      // This loop we'll check the previous delay time against the current
    //      // delay time to see if we need windowing. We'll save the delay time
    //      // we're using this loop to check the next time around.
    //      oldDelayTime = oldDelayTime_;
    //      oldDelayTime_ = delayTime;
    //    }

    // If the delay has changed, apply windowing
    //    if (delayTime != oldDelayTime) {
    //      std::cout << "windowing when lucas will come back" << std::endl;

    //      size_t diff = getDiff(delayTime, oldDelayTime, inputSize);

    //      // inFadeOut = from : delayBuf.end() - in.size() - oldDelay
    //      //             to   : delayBuf.end() - in.size() - oldDelay + delayDiff
    //      std::vector<audioSample_t> inFadeOut;
    //      auto fadeOutStart = CURRENT_DELAY_BUFFER.end() - inputSize - oldDelayTime;
    //      auto fadeOutEnd   = CURRENT_DELAY_BUFFER.end() - inputSize - oldDelayTime + diff;
    //      inFadeOut.insert(inFadeOut.begin(), fadeOutStart, fadeOutEnd);

    //      // inFadeIn = from : delayBuf.end() - in.size() - delay
    //      //            to   : delayBuf.end() - in.size() - delay + delayDiff
    //      std::vector<audioSample_t> inFadeIn;
    //      auto fadeInStart = CURRENT_DELAY_BUFFER.end() - inputSize - delayTime;
    //      auto fadeInEnd   = CURRENT_DELAY_BUFFER.end() - inputSize - delayTime + diff;
    //      inFadeIn.insert(inFadeIn.begin(), fadeInStart, fadeInEnd);

    //      std::vector<audioSample_t> winOut;
    //      applyWindow(inFadeOut, inFadeIn, &winOut);

    //      out[track.channel()].assign(winOut.begin(), winOut.end());

    //      // fill = from : delayBuf.end() - in.size() - delay + delayDiff
    //      //        to   : delayBuf.end() - delay
    //      if (winOut.size() < inputSize) {
    //        auto fillStart = CURRENT_DELAY_BUFFER.end() - inputSize - delayTime + diff;
    //        auto fillEnd   = CURRENT_DELAY_BUFFER.end() - delayTime;
    //        copy(fillStart, fillEnd, back_inserter(out[track.channel()]));
    //      }
    //    } else {
    //      auto copyStart = CURRENT_DELAY_BUFFER.end() - delayTime - inputSize;
    //      auto copyEnd   = CURRENT_DELAY_BUFFER.end() - delayTime;
    //      out[track.channel()].assign(copyStart, copyEnd);
    //    }

    if ((inputSize + delayTime) > CURRENT_DELAY_BUFFER.size()) {
      // Not enough samples to fill a buffer : zero padding
      out[track.channel()].assign(inputSize, 0);
    } else {
      auto copyStart = CURRENT_DELAY_BUFFER.end() - delayTime - inputSize;
      auto copyEnd = CURRENT_DELAY_BUFFER.end() - delayTime;
      out[track.channel()].assign(copyStart, copyEnd);
    }

    // Remove oldest samples if we're up to kMaxTime
    size_t maxSamples = static_cast<size_t>(getDefaultSamplingRate() * kMaxDelayTime);
    if (CURRENT_DELAY_BUFFER.size() > maxSamples) {
      size_t numSamplesToErase = CURRENT_DELAY_BUFFER.size() - maxSamples;
      CURRENT_DELAY_BUFFER.erase(CURRENT_DELAY_BUFFER.begin(), CURRENT_DELAY_BUFFER.begin() + numSamplesToErase);
    }
  }
}

#undef CURRENT_DELAY_BUFFER

void SampleDelay::step(AudioBlock& buf) { step(buf, buf); }

}  // namespace Audio
}  // namespace VideoStitch