SampleRateBasedClock.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/base/ftypes.h>
#include <pluginterfaces/vst/vsttypes.h>
#include <cmath>
#include <chrono>
 
namespace pongasoft {
namespace VST {
 
using namespace Steinberg;
using namespace Steinberg::Vst;

class SampleRateBasedClock
{
public:
  class RateLimiter
  {
  public:
    explicit RateLimiter(uint32 iRateLimitInSamples = 0) : fRateLimitInSamples{iRateLimitInSamples}, fSampleCount{0}
    {}

    bool shouldUpdate(uint32 numSamples)
    {
      fSampleCount += numSamples;
      if(fSampleCount >= fRateLimitInSamples)
      {
        fSampleCount -= fRateLimitInSamples;
        return true;
      }
      return false;
    }
 
  private:
    uint32 fRateLimitInSamples;
    uint32 fSampleCount;
  };
 
  // Constructor
  explicit SampleRateBasedClock(SampleRate iSampleRate) : fSampleRate{iSampleRate}
  {
 
  }
 
  // getSampleCountFor: how many samples for iMillis seconds
  uint32 getSampleCountFor(uint32 iMillis) const
  {
    return static_cast<uint32>(ceil(fSampleRate * iMillis / 1000.0));
  }
 
  // getSampleCountFor1Bar: how many samples for 1 bar (given the tempo and optional time signature)
  uint32 getSampleCountFor1Bar(double iTempo, int32 iTimeSigNumerator = 4, int32 iTimeSigDenominator = 4) const
  {
    auto oneBarInSeconds = 240.0 / iTempo;
    if(iTimeSigNumerator != iTimeSigDenominator && iTimeSigDenominator != 0)
    {
      oneBarInSeconds *= (static_cast<double>(iTimeSigNumerator) / static_cast<double>(iTimeSigDenominator));
    }
    return static_cast<uint32>(ceil(fSampleRate * oneBarInSeconds));
  }
 
  // getTimeForSampleCount: inverse of getSampleCountFor
  uint32 getTimeForSampleCount(uint32 iSampleCount) const
  {
    return static_cast<uint32>(ceil(iSampleCount * 1000.0 / fSampleRate));
  }

  TSamples getNextBarSampleCount(TSamples iCurrentSampleCount, double iTempo, int32 iTimeSigNumerator = 4, int32 iTimeSigDenominator = 4) const
  {
    auto sampleCountFor1Bar =
      static_cast<TSamples>(getSampleCountFor1Bar(iTempo, iTimeSigNumerator, iTimeSigDenominator));
    auto barMultiples = iCurrentSampleCount / sampleCountFor1Bar;
    auto barBoundary = barMultiples * sampleCountFor1Bar;
    if(barBoundary == iCurrentSampleCount)
      return iCurrentSampleCount;
    else
      return barBoundary + sampleCountFor1Bar;
  }
 
  // getSampleRate
  SampleRate getSampleRate() const
  {
    return fSampleRate;
  }
 
  // setSampleRate
  void setSampleRate(SampleRate iSampleRate)
  {
    fSampleRate = iSampleRate;
  }
 
  // getRateLimiter
  RateLimiter getRateLimiter(uint32 iMillis) const
  {
    return RateLimiter{getSampleCountFor(iMillis)};
  }
 
private:
  SampleRate fSampleRate;
};
 
}
}