LentPitShift.h

#ifndef STK_LENTPITSHIFT_H
#define STK_LENTPITSHIFT_H
 
#include "Effect.h"
#include "Delay.h"
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
class LentPitShift : public Effect
{
 public:
  LentPitShift( StkFloat periodRatio = 1.0, int tMax = RT_BUFFER_SIZE );
 
  ~LentPitShift( void ) {
    delete window;
    delete dt;
    delete dpt;
    delete cumDt;
  }
 
  void clear( void );
 
  void setShift( StkFloat shift );
 
  StkFloat tick( StkFloat input );
 
 
  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
 
 
  StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
 protected:
 
 
  void process( );
 
  // Frame storage vectors for process function
  StkFrames inputFrames;
  StkFrames outputFrames;
  int ptrFrames;          // writing pointer
 
  // Input delay line
  Delay inputLine_;
  int inputPtr;
 
  // Output delay line
  Delay outputLine_;
  double outputPtr;
 
  // Pitch tracker variables
  unsigned long tMax_;    // Maximal period measurable by the pitch tracker.
  // It is also the size of the window used by the pitch tracker and
  // the size of the frames that can be computed by the tick function
 
  StkFloat threshold_; // Threshold of detection for the pitch tracker
  unsigned long lastPeriod_;    // Result of the last pitch tracking loop
  StkFloat* dt;        // Array containing the euclidian distance coefficients
  StkFloat* cumDt;     // Array containing the cumulative sum of the coefficients in dt
  StkFloat* dpt;       // Array containing the pitch tracking function coefficients
 
  // Pitch shifter variables
  StkFloat env[2];     // Coefficients for the linear interpolation when modifying the output samples
  StkFloat* window;    // Hamming window used for the input portion extraction
  double periodRatio_; // Ratio of modification of the signal period
  StkFrames zeroFrame; // Frame of tMax_ zero samples
 
 
  // Coefficient delay line that could be used for a dynamic calculation of the pitch
  //Delay* coeffLine_;
 
};
 
inline void LentPitShift::process()
{
  StkFloat x_t;    // input coefficient
  StkFloat x_t_T;  // previous input coefficient at T samples
  StkFloat coeff;  // new coefficient for the difference function
 
  unsigned long alternativePitch = tMax_;  // Global minimum storage
  lastPeriod_ = tMax_+1;         // Storage of the lowest local minimum under the threshold
 
  // Loop variables
  unsigned long delay_;
  unsigned int n;
 
  // Initialization of the dt coefficients.  Since the
  // frames are of tMax_ length, there is no overlapping
  // between the successive windows where pitch tracking
  // is performed.
  for ( delay_=1; delay_<=tMax_; delay_++ )
    dt[delay_] = 0.;
 
  // Calculation of the dt coefficients and update of the input delay line.
  for ( n=0; n<inputFrames.size(); n++ ) {
    x_t = inputLine_.tick( inputFrames[ n ] );
    for ( delay_=1; delay_<= tMax_; delay_++ ) {
      x_t_T = inputLine_.tapOut( delay_ );
      coeff = x_t - x_t_T;
      dt[delay_] += coeff * coeff;
    }
  }
 
  // Calculation of the pitch tracking function and test for the minima.
  for ( delay_=1; delay_<=tMax_; delay_++ ) {
    cumDt[delay_] = dt[delay_] + cumDt[delay_-1];
    dpt[delay_] = dt[delay_] * delay_ / cumDt[delay_];
 
    // Look for a minimum
    if ( dpt[delay_-1]-dpt[delay_-2] < 0 && dpt[delay_]-dpt[delay_-1] > 0 ) {
      // Check if the minimum is under the threshold
      if ( dpt[delay_-1] < threshold_ ){
        lastPeriod_ = delay_-1;
        // If a minimum is found, we can stop the loop
        break;
      }
      else if ( dpt[alternativePitch] > dpt[delay_-1] )
        // Otherwise we store it if it is the current global minimum
        alternativePitch = delay_-1;
    }
  }
 
  // Test for the last period length.
  if ( dpt[delay_]-dpt[delay_-1] < 0 ) {
    if ( dpt[delay_] < threshold_ )
      lastPeriod_ = delay_;
    else if ( dpt[alternativePitch] > dpt[delay_] )
      alternativePitch = delay_;
  }
 
  if ( lastPeriod_ == tMax_+1 )
    // No period has been under the threshold so we used the global minimum
    lastPeriod_ = alternativePitch;
 
  // We put the new zero output coefficients in the output delay line and 
  // we get the previous calculated coefficients
  outputLine_.tick( zeroFrame, outputFrames );
 
  // Initialization of the Hamming window used in the algorithm
  for ( int n=-(int)lastPeriod_; n<(int)lastPeriod_; n++ )
    window[n+lastPeriod_] = (1 + cos(STK_PI*n/lastPeriod_)) / 2         ;
 
  long M;  // Index of reading in the input delay line
  long N;  // Index of writing in the output delay line
  double sample;  // Temporary storage for the new coefficient
 
  // We loop for all the frames of length lastPeriod_ presents between inputPtr and tMax_
  for ( ; inputPtr<(int)(tMax_-lastPeriod_); inputPtr+=lastPeriod_ ) {
    // Test for the decision of compression/expansion
    while ( outputPtr < inputPtr ) {
      // Coefficients for the linear interpolation
      env[1] = fmod( outputPtr + tMax_, 1.0 );
      env[0] = 1.0 - env[1];
      M = tMax_ - inputPtr + lastPeriod_ - 1; // New reading pointer
      N = 2*tMax_ - (unsigned long)floor(outputPtr + tMax_) + lastPeriod_ - 1; // New writing pointer
      for ( unsigned int j=0; j<2*lastPeriod_; j++,M--,N-- ) {
        sample = inputLine_.tapOut(M) * window[j] / 2.;
        // Linear interpolation
        outputLine_.addTo(env[0] * sample, N);
        outputLine_.addTo(env[1] * sample, N-1);
      }
      outputPtr = outputPtr + lastPeriod_ * periodRatio_; // new output pointer
    }
  }
  // Shifting of the pointers waiting for the new frame of length tMax_.
  outputPtr -= tMax_;
  inputPtr  -= tMax_;
}
 
 
inline StkFloat LentPitShift :: tick( StkFloat input )
{
  StkFloat sample;
 
  inputFrames[ptrFrames] = input;
 
  sample = outputFrames[ptrFrames++];
 
  // Check for end condition
  if ( ptrFrames == (int) inputFrames.size() ){
    ptrFrames = 0;
    process( );
  }
 
  return sample;
}
 
inline StkFrames& LentPitShift :: tick( StkFrames& frames, unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= frames.channels() ) {
    oStream_ << "LentPitShift::tick(): channel and StkFrames arguments are incompatible!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  StkFloat *samples = &frames[channel];
  unsigned int hop = frames.channels();
  for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
    *samples = tick( *samples );
  }
 
  return frames;
}
 
inline StkFrames& LentPitShift :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
{
#if defined(_STK_DEBUG_)
  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
    oStream_ << "LentPitShift::tick(): channel and StkFrames arguments are incompatible!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  StkFloat *iSamples = &iFrames[iChannel];
  StkFloat *oSamples = &oFrames[oChannel];
  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
    *oSamples = tick( *iSamples );
  }
 
  return iFrames;
}
 
} // stk namespace
 
#endif