staffpad::TimeAndPitch Class Reference

#include <TimeAndPitch.h>

Collaboration diagram for staffpad::TimeAndPitch:

Classes
struct	impl

Public Types
using	ShiftTimbreCb = std::function< void(double factor, std::complex< float > *spectrum, const float *magnitude)>

Public Member Functions
	TimeAndPitch (int fftSize, bool reduceImaging=true, ShiftTimbreCb shiftTimbreCb={})
	~TimeAndPitch ()
void	setup (int numChannels, int maxBlockSize)
void	setTimeStretchAndPitchFactor (double timeStretch, double pitchFactor)
int	getSamplesToNextHop () const
int	getNumAvailableOutputSamples () const
void	feedAudio (const float *const *in_smp, int numSamples)
void	retrieveAudio (float *const *out_smp, int numSamples)
void	processPitchShift (float *const *smp, int numSamples, double pitchFactor)
int	getLatencySamples () const
int	getLatencySamplesForStretchRatio (float timeStretch) const
void	reset ()

Private Member Functions
void	_process_hop (int hop_a, int hop_s)
	process one hop/chunk in _fft_timeSeries and add the result to output circular buffer More...
template<int num_channels>
void	_time_stretch (float hop_a, float hop_s)
void	_applyImagingReduction ()

Private Attributes
const int	fftSize
std::shared_ptr< impl >	d
const bool	_reduceImaging
const ShiftTimbreCb	_shiftTimbreCb
int	_numChannels = 1
int	_maxBlockSize = 1024
double	_resampleReadPos = 0.0
int	_availableOutputSamples = 0
int	_numBins = fftSize / 2 + 1
double	_overlap_a = overlap
int	_analysis_hop_counter = 0
double	_expectedPhaseChangePerBinPerSample = 0.01
double	_timeStretch = 1.0
double	_pitchFactor = 1.0
int	_outBufferWriteOffset = 0

Static Private Attributes
static constexpr int	overlap = 4
static constexpr bool	normalize_window = true
static constexpr bool	modulate_synthesis_hop = true

Detailed Description

Definition at line 13 of file TimeAndPitch.h.

Member Typedef Documentation

ShiftTimbreCb

using staffpad::TimeAndPitch::ShiftTimbreCb = std::function<void( double factor, std::complex<float>* spectrum, const float* magnitude)>

magnitude may be null, in which case the callback should re-compute it.

Definition at line 19 of file TimeAndPitch.h.

Constructor & Destructor Documentation

TimeAndPitch()

staffpad::TimeAndPitch::TimeAndPitch	(	int	fftSize,
		bool	reduceImaging = true,
		ShiftTimbreCb	shiftTimbreCb = {}
	)

Definition at line 90 of file TimeAndPitch.cpp.

    : fftSize(fftSize)
    , _reduceImaging(reduceImaging)
    , _shiftTimbreCb(std::move(shiftTimbreCb))
{
}

~TimeAndPitch()

staffpad::TimeAndPitch::~TimeAndPitch

(

)

Definition at line 98 of file TimeAndPitch.cpp.

{
  // Here for ~std::shared_ptr<impl>() to know ~impl()
}

Member Function Documentation

_applyImagingReduction()

void staffpad::TimeAndPitch::_applyImagingReduction ( )

private

Definition at line 342 of file TimeAndPitch.cpp.

{
   // Upsampling brings spectral components down, including those that were
   // beyond the Nyquist. From `imagingBeginBin`, we have a mirroring of the
   // spectrum, which, if not lowpass-filtered by the resampler, may yield
   // an aliasing-like quality if what is mirrored is a harmonic series. A
   // simple thing to do against that is to scramble the phase values there.
   // This way we preserve natural energy fluctuations, but the artifact
   // isn't noticeable as much anymore, because much more noise-like, which
   // is what one typically gets at those frequencies.
   constexpr auto alignment = 64 / sizeof(float);
   const int imagingBeginBin =
      std::ceil((fftSize / 2 * _pitchFactor + 1) / alignment) * alignment;
 
   if (imagingBeginBin >= _numBins)
      return;
 
   const auto n = _numBins - imagingBeginBin;
   auto pSpec = d->spectrum.getPtr(0);
   auto pRand = d->random_phases.getPtr(0);
   vo::rotate(nullptr, pRand, pSpec + imagingBeginBin, n);
   // Just rotating the random phase vector to produce pseudo-random
   // sequences of phases.
   std::uniform_int_distribution<size_t> dis(0, n - 1);
   const auto middle = dis(d->randomGenerator);
   std::rotate(pRand, pRand + middle, pRand + n);
}

References _numBins, _pitchFactor, d, fftSize, and staffpad::vo::rotate().

Referenced by _process_hop().

Here is the call graph for this function:

Here is the caller graph for this function:

_process_hop()

void staffpad::TimeAndPitch::_process_hop ( int  hop_a, int  hop_s  )

private

process one hop/chunk in _fft_timeSeries and add the result to output circular buffer

Definition at line 371 of file TimeAndPitch.cpp.

{
  if (d->exact_hop_a != d->exact_hop_s)
  {
    if (_numChannels == 2)
      _lr_to_ms(d->fft_timeseries.getPtr(0), d->fft_timeseries.getPtr(1), fftSize);
 
    for (int ch = 0; ch < _numChannels; ++ch)
    {
      vo::multiply(d->fft_timeseries.getPtr(ch), d->cosWindow.getPtr(0), d->fft_timeseries.getPtr(ch), fftSize);
      _fft_shift(d->fft_timeseries.getPtr(ch), fftSize);
    }
 
    // determine norm/phase
    d->fft.forwardReal(d->fft_timeseries, d->spectrum);
    // norms of the mid channel only (or sole channel) are needed in
    // _time_stretch
    vo::calcNorms(d->spectrum.getPtr(0), d->norm.getPtr(0), d->spectrum.getNumSamples());
    for (int ch = 0; ch < _numChannels; ++ch)
      vo::calcPhases(d->spectrum.getPtr(ch), d->phase.getPtr(ch), d->spectrum.getNumSamples());
 
    if (_shiftTimbreCb)
       _shiftTimbreCb(
          1 / _pitchFactor, d->spectrum.getPtr(0), d->norm.getPtr(0));
 
    if (_reduceImaging && _pitchFactor < 1.)
       _applyImagingReduction();
 
    if (_numChannels == 1)
      _time_stretch<1>((float)hop_a, (float)hop_s);
    else if (_numChannels == 2)
      _time_stretch<2>((float)hop_a, (float)hop_s);
 
    for (int ch = 0; ch < _numChannels; ++ch)
      _unwrapPhaseVec(d->phase_accum.getPtr(ch), _numBins);
 
    for (int ch = 0; ch < _numChannels; ++ch)
      vo::rotate(d->phase.getPtr(ch), d->phase_accum.getPtr(ch), d->spectrum.getPtr(ch),
                                  d->spectrum.getNumSamples());
    d->fft.inverseReal(d->spectrum, d->fft_timeseries);
 
    for (int ch = 0; ch < _numChannels; ++ch)
      vo::constantMultiply(d->fft_timeseries.getPtr(ch), 1.f / fftSize, d->fft_timeseries.getPtr(ch),
                           d->fft_timeseries.getNumSamples());
 
    if (_numChannels == 2)
      _ms_to_lr(d->fft_timeseries.getPtr(0), d->fft_timeseries.getPtr(1), fftSize);
 
    for (int ch = 0; ch < _numChannels; ++ch)
    {
      _fft_shift(d->fft_timeseries.getPtr(ch), fftSize);
      vo::multiply(d->fft_timeseries.getPtr(ch), d->cosWindow.getPtr(0), d->fft_timeseries.getPtr(ch), fftSize);
    }
  }
  else
  { // stretch factor == 1.0 => just apply window
    for (int ch = 0; ch < _numChannels; ++ch)
      vo::multiply(d->fft_timeseries.getPtr(ch), d->sqWindow.getPtr(0), d->fft_timeseries.getPtr(ch), fftSize);
  }
 
  {
    float gainFact = float(_timeStretch * ((8.f / 3.f) / _overlap_a)); // overlap add normalization factor
    for (int ch = 0; ch < _numChannels; ++ch)
      d->outCircularBuffer[ch].writeAddBlockWithGain(_outBufferWriteOffset, fftSize, d->fft_timeseries.getPtr(ch),
                                                     gainFact);
 
    if (normalize_window)
      d->normalizationBuffer.writeAddBlockWithGain(_outBufferWriteOffset, fftSize, d->sqWindow.getPtr(0), gainFact);
  }
  _outBufferWriteOffset += hop_s;
  _availableOutputSamples += hop_s;
}

References _applyImagingReduction(), _availableOutputSamples, staffpad::anonymous_namespace{TimeAndPitch.cpp}::_fft_shift(), staffpad::anonymous_namespace{TimeAndPitch.cpp}::_lr_to_ms(), staffpad::anonymous_namespace{TimeAndPitch.cpp}::_ms_to_lr(), _numBins, _numChannels, _outBufferWriteOffset, _overlap_a, _pitchFactor, _reduceImaging, _shiftTimbreCb, _timeStretch, staffpad::anonymous_namespace{TimeAndPitch.cpp}::_unwrapPhaseVec(), staffpad::vo::calcNorms(), staffpad::vo::calcPhases(), staffpad::vo::constantMultiply(), d, fftSize, staffpad::vo::multiply(), normalize_window, and staffpad::vo::rotate().

Referenced by feedAudio().

Here is the call graph for this function:

Here is the caller graph for this function:

_time_stretch()

template<int num_channels>

void staffpad::TimeAndPitch::_time_stretch ( float  hop_a, float  hop_s  )

private

Definition at line 239 of file TimeAndPitch.cpp.

{
  auto alpha = a_s / a_a; // this is the real stretch factor based on integer hop sizes
 
  // Create a norm array
  const auto* norms = d->norm.getPtr(0); // for stereo, just use the mid-channel
  const auto* norms_last = d->last_norm.getPtr(0);
 
  d->peak_index.clear();
  d->trough_index.clear();
  float lowest = norms[0];
  int trough = 0;
  if (norms_last[0] >= norms[1])
  {
    d->peak_index.emplace_back(0);
    d->trough_index.emplace_back(0);
  }
  for (int i = 1; i < _numBins - 1; ++i)
  {
    if (norms_last[i] >= norms[i - 1] && norms_last[i] >= norms[i + 1])
    {
      d->peak_index.emplace_back(i);
      d->trough_index.emplace_back(trough);
      trough = i;
      lowest = norms[i];
    }
    else if (norms[i] < lowest)
    {
      lowest = norms[i];
      trough = i;
    }
  }
  if (norms_last[_numBins - 1] > norms[_numBins - 2])
  {
    d->peak_index.emplace_back(_numBins - 1);
    d->trough_index.emplace_back(trough);
  }
 
  if (d->peak_index.size() == 0)
  {
    // use max norm of last frame
    int max_idx = 0;
    float max_norm = 0.f;
    vo::findMaxElement(norms_last, _numBins, max_idx, max_norm);
    d->peak_index.emplace_back(max_idx);
  }
 
  const float** p = const_cast<const float**>(d->phase.getPtrs());
  const float** p_l = const_cast<const float**>(d->last_phase.getPtrs());
  float** acc = d->phase_accum.getPtrs();
 
  float expChange_a = a_a * float(_expectedPhaseChangePerBinPerSample);
  float expChange_s = a_s * float(_expectedPhaseChangePerBinPerSample);
 
  int num_peaks = (int)d->peak_index.size();
  // time integration for all peaks
  for (int i = 0; i < num_peaks; ++i)
  {
    const int n = d->peak_index[i];
    auto fn = float(n);
 
    // determine phase from last frame
    float fn_expChange_a = fn * expChange_a;
    float fn_expChange_s = fn * expChange_s;
 
    for (int ch = 0; ch < num_channels; ++ch)
      acc[ch][n] = acc[ch][n] + alpha * _unwrapPhase(p[ch][n] - p_l[ch][n] - fn_expChange_a) + fn_expChange_s;
  }
 
  // go from first peak to 0
  for (int n = d->peak_index[0]; n > 0; --n)
  {
    for (int ch = 0; ch < num_channels; ++ch)
      acc[ch][n - 1] = acc[ch][n] - alpha * _unwrapPhase(p[ch][n] - p[ch][n - 1]);
  }
 
  // 'grow' from pairs of peaks to the lowest norm in between
  for (int i = 0; i < num_peaks - 1; ++i)
  {
    const int mid = d->trough_index[i + 1];
    for (int n = d->peak_index[i]; n < mid; ++n)
    {
      for (int ch = 0; ch < num_channels; ++ch)
        acc[ch][n + 1] = acc[ch][n] + alpha * _unwrapPhase(p[ch][n + 1] - p[ch][n]);
    }
    for (int n = d->peak_index[i + 1]; n > mid + 1; --n)
    {
      for (int ch = 0; ch < num_channels; ++ch)
        acc[ch][n - 1] = acc[ch][n] - alpha * _unwrapPhase(p[ch][n] - p[ch][n - 1]);
    }
  }
 
  // last peak to the end
  for (int n = d->peak_index[num_peaks - 1]; n < _numBins - 1; ++n)
  {
    for (int ch = 0; ch < num_channels; ++ch)
      acc[ch][n + 1] = acc[ch][n] + alpha * _unwrapPhase(p[ch][n + 1] - p[ch][n]);
  }
 
  d->last_norm.assignSamples(d->norm);
  d->last_phase.assignSamples(d->phase);
}

References _expectedPhaseChangePerBinPerSample, _numBins, staffpad::anonymous_namespace{TimeAndPitch.cpp}::_unwrapPhase(), d, staffpad::vo::findMaxElement(), and fn.

Here is the call graph for this function:

feedAudio()

void staffpad::TimeAndPitch::feedAudio	(	const float *const *	in_smp,
		int	numSamples
	)

Feed more input samples.

See also

getSamplesToNextHop() to know how much to feed to produce more output samples.

Definition at line 472 of file TimeAndPitch.cpp.

{
  assert(numSamples <= _maxBlockSize);
  for (int ch = 0; ch < _numChannels; ++ch)
  {
    d->inResampleInputBuffer[ch].writeBlock(0, numSamples, input_smp[ch]);
    d->inResampleInputBuffer[ch].advance(numSamples);
  }
  _resampleReadPos -= numSamples;
 
  // determine integer hop size for the next hop.
  // The error accumulators will make the value fluctuate by one to reach arbitrary scale
  // ratios
  if (d->exact_hop_s == 0.0) // this happens if feedAudio is called without setting up stretch factors
    d->exact_hop_s = d->next_exact_hop_s;
 
  const int hop_s = int(d->exact_hop_s + d->hop_s_err);
  const int hop_a = int(d->exact_hop_a + d->hop_a_err);
 
  double step = 0.0;
  double read_pos = _resampleReadPos;
  while (read_pos < 0.0)
  {
    auto int_pos = int(std::floor(read_pos));
    float frac_pos = float(read_pos - int_pos);
    for (int ch = 0; ch < _numChannels; ++ch)
    {
      float smp[6];
      d->inResampleInputBuffer[ch].readBlock(int_pos - 6, 6, smp);
      float s = (frac_pos == 0) ? smp[2] : lagrange6(smp, frac_pos);
      d->inCircularBuffer[ch].writeOffset0(s);
      d->inCircularBuffer[ch].advance(1);
    }
    _analysis_hop_counter++;
    step++;
 
    if (_analysis_hop_counter >= hop_a)
    {
      _analysis_hop_counter -= hop_a;
      d->hop_s_err += d->exact_hop_s - hop_s;
      d->hop_a_err += d->exact_hop_a - hop_a;
      for (int ch = 0; ch < _numChannels; ++ch)
        d->inCircularBuffer[ch].readBlock(-fftSize, fftSize, d->fft_timeseries.getPtr(ch));
      _process_hop(hop_a, hop_s);
    }
    read_pos = _resampleReadPos + step * _pitchFactor;
  }
  _resampleReadPos = read_pos;
}

References _analysis_hop_counter, _maxBlockSize, _numChannels, _pitchFactor, _process_hop(), _resampleReadPos, d, fftSize, and staffpad::anonymous_namespace{TimeAndPitch.cpp}::lagrange6().

Referenced by processPitchShift().

Here is the call graph for this function:

Here is the caller graph for this function:

getLatencySamples()

int staffpad::TimeAndPitch::getLatencySamples

(

)

const

Latency in input samples

Definition at line 558 of file TimeAndPitch.cpp.

{
  return fftSize - fftSize / overlap + 3; // 3 for resampling
}

References fftSize, and overlap.

Referenced by getLatencySamplesForStretchRatio().

Here is the caller graph for this function:

getLatencySamplesForStretchRatio()

int staffpad::TimeAndPitch::getLatencySamplesForStretchRatio

(

float

timeStretch

)

const

Latency in output samples, calculated on the given timeStretch factor

Definition at line 564 of file TimeAndPitch.cpp.

{
  const float coeff = (timeStretch < 1.f) ? (1.f / 3.f) : (2.f / 3.f);
  return int(getLatencySamples() * (timeStretch * coeff + (1 - coeff)));
}

References getLatencySamples().

Here is the call graph for this function:

getNumAvailableOutputSamples()

int staffpad::TimeAndPitch::getNumAvailableOutputSamples

(

)

const

Tells the number of already processed output samples (after time-stretching) that are ready for consumption.

Definition at line 164 of file TimeAndPitch.cpp.

{
  return _availableOutputSamples;
}

References _availableOutputSamples.

getSamplesToNextHop()

int staffpad::TimeAndPitch::getSamplesToNextHop

(

)

const

Return the ~number of samples until the next hop gets analysed (might be 1 or 2 too high). For extremely small stretch ratios, several analyses might be needed to produce samples, so you may have to repeat the process. Eventually, more output samples are produced.

Definition at line 158 of file TimeAndPitch.cpp.

{
  return std::max(0, int(std::ceil(d->exact_hop_a)) - _analysis_hop_counter +
                         1); // 1 extra to counter pitch factor error accumulation
}

References _analysis_hop_counter, and d.

processPitchShift()

void staffpad::TimeAndPitch::processPitchShift	(	float *const *	smp,
		int	numSamples,
		double	pitchFactor
	)

Pitch-shift only in-place processing.

Definition at line 551 of file TimeAndPitch.cpp.

{
  setTimeStretchAndPitchFactor(1.0, pitchFactor);
  feedAudio(smp, numSamples);
  retrieveAudio(smp, numSamples);
}

References feedAudio(), retrieveAudio(), and setTimeStretchAndPitchFactor().

Here is the call graph for this function:

reset()

void staffpad::TimeAndPitch::reset

(

)

Resets the internal state, discards any buffered input

Definition at line 169 of file TimeAndPitch.cpp.

{
  _analysis_hop_counter = 0;
  _availableOutputSamples = 0;
  for (int ch = 0; ch < _numChannels; ++ch)
  {
    d->inResampleInputBuffer[ch].reset();
    d->inCircularBuffer[ch].reset();
    d->outCircularBuffer[ch].reset();
  }
  d->normalizationBuffer.reset();
  d->last_norm.zeroOut();
  d->last_phase.zeroOut();
  d->phase_accum.zeroOut();
  _outBufferWriteOffset = 0;
  d->hop_a_err = 0.0;
  d->hop_s_err = 0.0;
  d->exact_hop_s = 0.0;
  _resampleReadPos = 0.0;
}

References _analysis_hop_counter, _availableOutputSamples, _numChannels, _outBufferWriteOffset, _resampleReadPos, and d.

Referenced by setup().

Here is the caller graph for this function:

retrieveAudio()

void staffpad::TimeAndPitch::retrieveAudio	(	float *const *	out_smp,
		int	numSamples
	)

Retrieved shifted/stretched samples in output.

See also

getNumAvailableOutputSamples() to ask a valid amount of numSamples.

Definition at line 522 of file TimeAndPitch.cpp.

{
  assert(numSamples <= _maxBlockSize);
  for (int ch = 0; ch < _numChannels; ++ch)
  {
    d->outCircularBuffer[ch].readAndClearBlock(0, numSamples, out_smp[ch]);
    if (normalize_window)
    {
      constexpr float curve =
          4.f * 4.f; // the curve approximates 1/x over 1 but fades to 0 near 0 to avoid fade-in clicks
      for (int i = 0; i < numSamples; ++i)
      {
        float x = d->normalizationBuffer.read(i);
        out_smp[ch][i] *= x / (x * x + 1 / curve);
      }
    }
    d->outCircularBuffer[ch].advance(numSamples);
  }
 
  d->normalizationBuffer.clearBlock(0, numSamples);
  d->normalizationBuffer.advance(numSamples);
 
  _outBufferWriteOffset -= numSamples;
  _availableOutputSamples -= numSamples;
 
  if (modulate_synthesis_hop)
    d->exact_hop_s = d->next_exact_hop_s;
}

References _availableOutputSamples, _maxBlockSize, _numChannels, _outBufferWriteOffset, d, modulate_synthesis_hop, and normalize_window.

Referenced by processPitchShift().

Here is the caller graph for this function:

setTimeStretchAndPitchFactor()

void staffpad::TimeAndPitch::setTimeStretchAndPitchFactor	(	double	timeStretch,
		double	pitchFactor
	)

Set independent time stretch and pitch factors (synchronously to processing thread). The factor change resolution follows the processing block size, with some approximation. As a general rule, smaller block sizes result in finer changes, although there's a lower bound due to internal windowed segmentation and OLA resynthesis.

Definition at line 444 of file TimeAndPitch.cpp.

{
  assert(timeScale > 0.0);
  assert(pitchFactor > 0.0);
  _pitchFactor = pitchFactor;
  _timeStretch = timeScale * pitchFactor;
 
  _overlap_a = overlap;
  double overlap_s = overlap;
  if (_timeStretch > 1.0 || !modulate_synthesis_hop)
    _overlap_a *= _timeStretch;
  else
    overlap_s /= _timeStretch;
 
  d->exact_hop_a = double(fftSize) / _overlap_a;
  if (!modulate_synthesis_hop)
  {
    d->exact_hop_s = double(fftSize) / overlap_s;
  }
  else
  {
    // switch after processing next block, unless it's the first one
    d->next_exact_hop_s = double(fftSize) / overlap_s;
    if (d->exact_hop_s == 0.0) // on first chunk set it immediately
      d->exact_hop_s = d->next_exact_hop_s;
  }
}

References _overlap_a, _pitchFactor, _timeStretch, d, fftSize, modulate_synthesis_hop, and overlap.

Referenced by processPitchShift().

Here is the caller graph for this function:

setup()

void staffpad::TimeAndPitch::setup	(	int	numChannels,
		int	maxBlockSize
	)

Setup at least once before processing.

Parameters

numChannels	Must be 1 or 2
maxBlockSize	The caller's maximum block size, e.g. 1024 samples

Definition at line 103 of file TimeAndPitch.cpp.

{
  assert(numChannels == 1 || numChannels == 2);
  _numChannels = numChannels;
 
  d = std::make_unique<impl>(fftSize);
  _maxBlockSize = maxBlockSize;
  _numBins = fftSize / 2 + 1;
 
  // audio sample buffers
  d->fft_timeseries.setSize(_numChannels, fftSize);
  int outBufferSize = fftSize + 2 * _maxBlockSize; // 1 block extra for safety
  for (int ch = 0; ch < _numChannels; ++ch)
  {
    d->inResampleInputBuffer[ch].setSize(_maxBlockSize +
                                         6); // needs additional history for resampling. more in the future
    d->inCircularBuffer[ch].setSize(fftSize);
    d->outCircularBuffer[ch].setSize(outBufferSize);
  }
  d->normalizationBuffer.setSize(outBufferSize);
 
  // fft coefficient buffers
  d->spectrum.setSize(_numChannels, _numBins);
  d->norm.setSize(1, _numBins);
  d->last_norm.setSize(1, _numBins);
  d->phase.setSize(_numChannels, _numBins);
  d->last_phase.setSize(_numChannels, _numBins);
  d->phase_accum.setSize(_numChannels, _numBins);
  d->random_phases.setSize(1, _numBins);
  generateRandomPhaseVector(
     d->random_phases.getPtr(0), _numBins, d->randomGenerator);
 
  _expectedPhaseChangePerBinPerSample = twoPi / double(fftSize);
 
  // Cos window
  // For perfect int-factor overlaps the first sample needs to be 0 and the last non-zero.
  d->cosWindow.setSize(1, fftSize);
  d->sqWindow.setSize(1, fftSize);
  auto* w = d->cosWindow.getPtr(0);
  auto* sqw = d->sqWindow.getPtr(0);
  for (int i = 0; i < fftSize; ++i)
  {
    w[i] = -0.5f * std::cos(float(twoPi * (float)i / (float)fftSize)) + 0.5f;
    sqw[i] = w[i] * w[i];
  }
 
  d->peak_index.reserve(_numBins);
  d->trough_index.reserve(_numBins);
 
  // force fft to allocate all buffers now. Currently there is no other way in the fft class
  d->fft.forwardReal(d->fft_timeseries, d->spectrum);
 
  reset();
}

References _expectedPhaseChangePerBinPerSample, _maxBlockSize, _numBins, _numChannels, d, fftSize, staffpad::anonymous_namespace{TimeAndPitch.cpp}::generateRandomPhaseVector(), anonymous_namespace{StaffPadTimeAndPitch.cpp}::maxBlockSize, reset(), and staffpad::anonymous_namespace{TimeAndPitch.cpp}::twoPi.

Here is the call graph for this function:

Member Data Documentation

_analysis_hop_counter

int staffpad::TimeAndPitch::_analysis_hop_counter = 0

private

Definition at line 110 of file TimeAndPitch.h.

Referenced by feedAudio(), getSamplesToNextHop(), and reset().

_availableOutputSamples

int staffpad::TimeAndPitch::_availableOutputSamples = 0

private

Definition at line 106 of file TimeAndPitch.h.

Referenced by _process_hop(), getNumAvailableOutputSamples(), reset(), and retrieveAudio().

_expectedPhaseChangePerBinPerSample

double staffpad::TimeAndPitch::_expectedPhaseChangePerBinPerSample = 0.01

private

Definition at line 112 of file TimeAndPitch.h.

Referenced by _time_stretch(), and setup().

_maxBlockSize

int staffpad::TimeAndPitch::_maxBlockSize = 1024

private

Definition at line 104 of file TimeAndPitch.h.

Referenced by feedAudio(), retrieveAudio(), and setup().

_numBins

int staffpad::TimeAndPitch::_numBins = fftSize / 2 + 1

private

Definition at line 107 of file TimeAndPitch.h.

Referenced by _applyImagingReduction(), _process_hop(), _time_stretch(), and setup().

_numChannels

int staffpad::TimeAndPitch::_numChannels = 1

private

Definition at line 103 of file TimeAndPitch.h.

Referenced by _process_hop(), feedAudio(), reset(), retrieveAudio(), and setup().

_outBufferWriteOffset

int staffpad::TimeAndPitch::_outBufferWriteOffset = 0

private

Definition at line 116 of file TimeAndPitch.h.

Referenced by _process_hop(), reset(), and retrieveAudio().

_overlap_a

double staffpad::TimeAndPitch::_overlap_a = overlap

private

Definition at line 108 of file TimeAndPitch.h.

Referenced by _process_hop(), and setTimeStretchAndPitchFactor().

_pitchFactor

double staffpad::TimeAndPitch::_pitchFactor = 1.0

private

Definition at line 114 of file TimeAndPitch.h.

Referenced by _applyImagingReduction(), _process_hop(), feedAudio(), and setTimeStretchAndPitchFactor().

_reduceImaging

const bool staffpad::TimeAndPitch::_reduceImaging

private

Definition at line 100 of file TimeAndPitch.h.

Referenced by _process_hop().

_resampleReadPos

double staffpad::TimeAndPitch::_resampleReadPos = 0.0

private

Definition at line 105 of file TimeAndPitch.h.

Referenced by feedAudio(), and reset().

_shiftTimbreCb

const ShiftTimbreCb staffpad::TimeAndPitch::_shiftTimbreCb

private

Definition at line 101 of file TimeAndPitch.h.

Referenced by _process_hop().

_timeStretch

double staffpad::TimeAndPitch::_timeStretch = 1.0

private

Definition at line 113 of file TimeAndPitch.h.

Referenced by _process_hop(), and setTimeStretchAndPitchFactor().

d

std::shared_ptr<impl> staffpad::TimeAndPitch::d

private

Definition at line 98 of file TimeAndPitch.h.

Referenced by _applyImagingReduction(), _process_hop(), _time_stretch(), feedAudio(), getSamplesToNextHop(), reset(), retrieveAudio(), setTimeStretchAndPitchFactor(), and setup().

fftSize

const int staffpad::TimeAndPitch::fftSize

private

Definition at line 87 of file TimeAndPitch.h.

Referenced by _applyImagingReduction(), _process_hop(), feedAudio(), getLatencySamples(), setTimeStretchAndPitchFactor(), and setup().

modulate_synthesis_hop

constexpr bool staffpad::TimeAndPitch::modulate_synthesis_hop = true

staticconstexprprivate

Definition at line 90 of file TimeAndPitch.h.

Referenced by retrieveAudio(), and setTimeStretchAndPitchFactor().

normalize_window

constexpr bool staffpad::TimeAndPitch::normalize_window = true

staticconstexprprivate

Definition at line 89 of file TimeAndPitch.h.

Referenced by _process_hop(), and retrieveAudio().

overlap

constexpr int staffpad::TimeAndPitch::overlap = 4

staticconstexprprivate

Definition at line 88 of file TimeAndPitch.h.

Referenced by getLatencySamples(), and setTimeStretchAndPitchFactor().

---

The documentation for this class was generated from the following files:

• TimeAndPitch.h
• TimeAndPitch.cpp