more pitch shift groundwork

Author: Alloyed

kitdsp/CMakeLists.txt

@@ -13,8 +13,8 @@ add_library(KitDSP STATIC
     src/snesBitcrush.cpp
     src/dsfOscillator.cpp
     src/chorus.cpp
-    src/harmonizer.cpp
     src/frequencyShifter.cpp
+    src/pitch/h910PitchShifter.cpp
     src/pitch/zeroCrossingPitchDetector.cpp
 )
 

kitdsp/include/kitdsp/harmonizer.h kitdsp/include/kitdsp/apps/harmonizer.hkitdsp/include/kitdsp/harmonizer.h renamed to kitdsp/include/kitdsp/apps/harmonizer.h

@@ -7,9 +7,9 @@
 #include "kitdsp/math/vector.h"
 
 namespace kitdsp {
-class Harmonizer {
+class H910PitchShifter {
    public:
-    Harmonizer(etl::span<float> buffer, float sampleRate);
+    H910PitchShifter(etl::span<float> buffer, float sampleRate);
     void Reset();
 
     void SetParams(float pitchRatio, float grainSizeMs = 30.0f, float baseDelayMs = 0.0f, float feedback = 0.0f);

kitdsp/include/kitdsp/chunkifier.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <etl/span.h>
+#include <cassert>
+#include "kitdsp/delayLine.h"
+#include "kitdsp/macros.h"
+
+namespace kitdsp {
+/**
+ * Turns a continuous signal into equally sized chunks (for STFT or other chunk based algorithms).
+ */
+template <typename TSample>
+class Chunkifier {
+   public:
+    static constexpr size_t GetDesiredBufferSize(size_t chunkLength) { return chunkLength * 2; }
+    /**
+     * @param buffer should be sized to fit GetDesiredBufferSize()
+     * @param chunkLength should be the number of samples to include in a chunk
+     * @param overlapSamples should be the number of samples that should be included in the last chunk and the current
+     * chunk. 0 means no overlap.
+     */
+    Chunkifier(etl::span<TSample> buffer, size_t chunkLength, size_t overlapSamples)
+        : mBuf({buffer.data(), chunkLength}),
+          mChunk(buffer.data() + chunkLength, chunkLength),
+          mHopSize(chunkLength - overlapSamples) {
+        assert(buffer.size() == GetDesiredBufferSize(chunkLength));
+        assert(overlapSamples <= chunkLength);
+    }
+    void Reset() {
+        mBuf.Reset();
+        mHopIdx = 0;
+    }
+    template <typename TFn>
+    void Process(TSample input, TFn fn) {
+        mBuf.Write(input);
+        mHopIdx++;
+        if (mHopIdx > mHopSize) {
+            // mChunk is necessary here because the delay line might not be continuous
+            mBuf.ReadChunk(mChunk.size() - 1, mChunk);
+            fn(mChunk);
+            mHopIdx -= mHopSize;
+        }
+    }
+
+   private:
+    DelayLine<TSample> mBuf;
+    etl::span<TSample> mChunk;
+    size_t mHopIdx = 0;
+    size_t mHopSize;
+};
+}  // namespace kitdsp

kitdsp/include/kitdsp/control/adsr.h

@@ -37,7 +37,8 @@ class ApproachAdsr {
         // 0 -> 1
         mAttackH = Approach::CalculateHalfLifeFromSettleTime(attackMs, sampleRate, cSettlePrecision, 1.0f);
         // 1 -> sustain
-        mDecayH = Approach::CalculateHalfLifeFromSettleTime(decayMs, sampleRate, cSettlePrecision, 1.0f - sustainValue);
+        mDecayH = Approach::CalculateHalfLifeFromSettleTime(decayMs, sampleRate, cSettlePrecision,
+                                                            kitdsp::max(0.001f, 1.0f - sustainValue));
         mSustain = sustainValue;
         // sustain -> 0
         // sustain needs to at least be a little bit above 0 to avoid infinities

kitdsp/include/kitdsp/delayLine.h

@@ -3,6 +3,7 @@
 #include <etl/span.h>
 #include <cstdint>
 #include <cstring>
+#include "kitdsp/macros.h"
 #include "kitdsp/math/interpolate.h"
 
 namespace kitdsp {
@@ -28,6 +29,7 @@ class DelayLine {
     }
 
     inline const TSample Read(int32_t delayIndex) const {
+        assert(delayIndex < narrow_cast<int32_t>(Size()));
         // non-interpolating read
         size_t size = mBuffer.size();
         // TODO: if size is a power-of-two this could be a cheap & instead
@@ -46,20 +48,31 @@ class DelayLine {
         using namespace interpolate;
         switch (strategy) {
             case InterpolationStrategy::None: {
+                assert(idx >= 0 && idx < Size());
                 return Read(idx);
             };
             case InterpolationStrategy::Linear: {
+                assert(idx >= 0 && idx < narrow_cast<int32_t>(Size()) - 1);
                 return linear(Read(idx), Read(idx + 1), frac);
             };
             case InterpolationStrategy::Hermite: {
+                assert(idx >= 1 && idx < narrow_cast<int32_t>(Size()) - 2);
                 return hermite4pt3oX(Read(idx - 1), Read(idx), Read(idx + 1), Read(idx + 2), frac);
             };
             case InterpolationStrategy::Cubic: {
+                assert(idx >= 1 && idx < narrow_cast<int32_t>(Size()) - 2);
                 return cubic(Read(idx - 1), Read(idx), Read(idx + 1), Read(idx + 2), frac);
             };
         }
     }
 
+    void ReadChunk(size_t startSample, etl::span<TSample>& out) {
+        assert(startSample - static_cast<int32_t>(out.size()) + 1 >= 0);
+        for (size_t i = 0; i < out.size(); ++i) {
+            out[i] = Read(startSample - i);
+        }
+    }
+
     /**
      * This is a shorcut if you're planning to use your delay as part of an allpass filter.
      */

kitdsp/include/kitdsp/lookupTables/sineLut.h

@@ -10,6 +10,9 @@ namespace kitdsp {
 inline float sin2pif_lut(float x) {
     return lut[static_cast<int32_t>(x * 1024) % 1024];
 }
+inline float cos2pif_lut(float x) {
+    return sin2pif_lut(x + 0.25f);
+}
 }  // namespace kitdsp
 
 namespace {

kitdsp/include/kitdsp/math/shy_fft.h

@@ -26,6 +26,9 @@
 //
 
 // ported from stmlib: https://github.com/pichenettes/stmlib/blob/master/fft/shy_fft.h
+// plus some comments to document the input/output formats
+// extra notes here:
+// https://forum.electro-smith.com/t/my-battle-with-shy-fft-h-and-what-it-taught-me-shyfft-quick-guide/8455/5
 // @KitDSP
 // -----------------------------------------------------------------------------
 //
@@ -678,6 +681,12 @@ struct InverseTransform<T, 2, Phasor> {
     }
 };
 
+/**
+ * ShyFFT public class.
+ * @param T the sample format
+ * @param size the max number of samples in the input/output buffers
+ * @param Phasor pick between LutPhasor (more memory, faster) and RotationPhaser
+ */
 template <typename T = float, size_t size = 16, template <typename, size_t> class Phasor = LutPhasor>
 class ShyFFT {
    public:
@@ -708,21 +717,44 @@ class ShyFFT {
         phasor_.Init();
     }
 
+    /**
+     * perform direct FFT.
+     * @param input the input buffer. should be `size` samples long. this is used destructively.
+     * @param output the output buffer. should be `size` samples long, returns the real components (from [0, size*0.5),
+     * then the imaginary components (from [size*0.5, size), non-interleaved.
+     */
     void Direct(T* input, T* output) {
         DirectTransform<T, num_passes, Phasor<T, num_passes> > d;
         d(input, output, num_passes <= 8 ? &bit_rev_[0] : bit_rev_256_lut_, &phasor_);
     }
 
+    /**
+     * perform inverse FFT.
+     * @param input the input buffer. should be the real values, then the imaginary. this is used destructively.
+     * @param output the output buffer. should be `size` samples long, this is an audio signal.
+     */
     void Inverse(T* input, T* output) {
         InverseTransform<T, num_passes, Phasor<T, num_passes> > i;
         i(input, output, num_passes <= 8 ? &bit_rev_[0] : bit_rev_256_lut_, &phasor_);
     }
 
+    /**
+     * perform direct FFT.
+     * @param input the input buffer. should be `n` samples long. this is used destructively.
+     * @param output the output buffer. should be `n` samples long, non-interleaved.
+     * @param n the size of the buffer.
+     */
     void Direct(T* input, T* output, size_t n) {
         DirectTransform<T, num_passes, Phasor<T, num_passes> > d;
         d(input, output, bit_rev_256_lut_, &phasor_, n);
     }
 
+    /**
+     * perform inverse FFT.
+     * @param input the input buffer. should be `n` samples long, non-interleaved. this is used destructively.
+     * @param output the output buffer. should be `n` samples long.
+     * @param n the size of the buffer.
+     */
     void Inverse(T* input, T* output, size_t n) {
         InverseTransform<T, num_passes, Phasor<T, num_passes> > i;
         i(input, output, bit_rev_256_lut_, &phasor_, n);

kitdsp/include/kitdsp/math/stft.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "kitdsp/chunkifier.h"
+#include "kitdsp/lookupTables/sineLut.h"
+#include "kitdsp/math/shy_fft.h"
+
+namespace {
+float hammingWindow(float t) {
+    return 0.54f - (0.46f * kitdsp::cos2pif_lut(t));
+}
+
+float hannWindow(float t) {
+    return 0.5f * (1.0f - kitdsp::cos2pif_lut(t));
+}
+
+float rectangleWindow(float t) {
+    return 1;
+}
+}  // namespace
+
+namespace kitdsp {
+template <size_t CHUNK_SIZE>
+class STFT {
+   public:
+    static constexpr size_t GetDesiredBufferSize() { return CHUNK_SIZE * 3; }
+    static constexpr size_t GetDesiredOverlap() { return CHUNK_SIZE / 2; }
+
+    explicit STFT(etl::span<float> buffer)
+        : mChunkifier({buffer.data(), CHUNK_SIZE * 2}, CHUNK_SIZE, GetDesiredOverlap()),
+          mOut(buffer.data() + CHUNK_SIZE * 2, CHUNK_SIZE),
+          mFFT() {
+        mFFT.Init();
+    }
+
+    void Process(float in) {
+        mChunkifier.Process(in, [this](etl::span<float> chunk) {
+            for (size_t i = 0; i < chunk.size(); ++i) {
+                chunk[i] = chunk[i] * hammingWindow(static_cast<float>(i) / static_cast<float>(chunk.size()));
+            }
+            mFFT.Direct(chunk.data(), mOut.data());
+        });
+    }
+
+    etl::span<float> mOut;
+
+   private:
+    Chunkifier<float> mChunkifier;
+    ShyFFT<float, CHUNK_SIZE> mFFT;
+};
+}  // namespace kitdsp

kitdsp/include/kitdsp/pitch/h910PitchShifter.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "kitdsp/control/lfo.h"
+#include "kitdsp/delayLine.h"
+#include "kitdsp/filters/biquad.h"
+
+namespace kitdsp {
+class H910PitchShifter {
+   public:
+    H910PitchShifter(etl::span<float> buffer, float sampleRate);
+    void Reset();
+
+    void SetParams(float pitchRatio, float grainSizeMs = 30.0f, float baseDelayMs = 0.0f, float feedback = 0.0f);
+
+    float Process(float in);
+
+    size_t GetMaxGrainSize() const;
+
+    size_t GetEffectiveDelay() const;
+
+   private:
+    DelayLine<float> mDelayLine;
+    lfo::Phasor mGrainPhasor;
+    float mSampleRate;
+    float mGrainSizeSamples;
+    float mBaseDelaySamples;
+    bool mSlowing;
+    float mFeedback;
+    rbj::BiquadFilter<rbj::BiquadFilterMode::LowPass> mFilterOut;
+};
+}  // namespace kitdsp

kitdsp/include/kitdsp/pitch/psolaPitchShifter.h

@@ -34,9 +34,9 @@ namespace pitch {
  */
 class PsolaPitchShifter {
     struct Grain {
-        float sizeSamples;
-        float samplesPlayed;
-        float speed;
+        float sizeSamples = 0.0f;
+        float samplesPlayed = 0.0f;
+        float speed = 0.0f;
         explicit Grain(DelayLine<float>& buf) : mBuf(buf) {}
         void Set(float start, float size, float speed) {
             this->pos = start;
@@ -49,6 +49,9 @@ class PsolaPitchShifter {
             samplesPlayed += speed;
         }
         float Read() {
+            if (sizeSamples == 0.0f) {
+                return 0.0f;
+            }
             float progress = kitdsp::clamp(samplesPlayed / sizeSamples, 0.0f, 1.0f);
             using namespace kitdsp::interpolate;
             return mBuf.Read<InterpolationStrategy::Linear>(pos) * hanningWindow(progress);
@@ -66,6 +69,7 @@ class PsolaPitchShifter {
         mSpeed = pitchMultiplier;
         mPeriod = 0.05f * sampleRate;
         float overlapRatio = 1.0f - 0.2f;  // TODO not this
+        assert(pitchMultiplier != 0);
         mGrainPicker.SetPeriodSamples(overlapRatio * (mPeriod / pitchMultiplier));
     }
     float Process(float input) {