PhaseVocoder.h

Go to the documentation of this file.

namespace krotos
{
    //==============================================================================
    class PhaseVocoder
    {
      public:
        enum PhaseVocoderMode
        {
            Robotizer = 0,
            // TODO: implement more !!!
            PitchShifter,
            TimeStrecher,
            NUM_VOCMODES
        };
 
        PhaseVocoder(int fftSize, int hopSize, int inputBufferSize, WindowType windowFunction);
 
        ~PhaseVocoder() = default;
 
        float process(float inputSample, int channelToUse);
 
        void setWindowFunction(WindowType windowType);
 
        void setGeneralParam(float paramVaue);
 
        void setMode(PhaseVocoderMode newMode) { m_mode = newMode; };
 
        void setSampleRate(float sampleRate) { m_sampleRate = sampleRate; };
 
      private:
        void processFrame(std::vector<float>& inBuffer, int inPointer, std::vector<float>& outBuffer, int outPointer);
 
        void robotize(std::vector<float>& fftData);
 
        void pitchShift(std::vector<float>& fftData);
 
        void timeStrech(std::vector<float>& fftData);
 
        void detectFrequency(std::vector<float>& fftData);
 
        void setNumChannels(int newValue);
 
        float wrapToPi(float phaseIn);
 
        float caclulateFrameRMS(std::vector<float> inputFrame);
 
        PhaseVocoderMode m_mode;
        // fft window size in samples
        int m_fftSize;
        // hopSize in samples i.e. how often we caclulate the fft
        int m_hopSizeAnalysis;
        int m_hopSizeSynthesis; // for time streching
 
        float m_sampleRate{0.0f};
 
        // fft processing object
        dsp::FFT m_fft;
        // window function
        std::vector<float> m_analysisWindow;
        std::vector<float> m_synthesisWindow;
        WindowType m_windowType;
        float m_windowGainCorrection;
 
        // circular input buffer, assembles a window of samples
        int m_inputBufferSize;
        std::vector<std::vector<float>> m_inputBuffer;
        // one write pointer per channel
        std::vector<int> m_inputWritePointer{0, 0};
        // one read pointer per channel
        std::vector<int> m_hopCounter{0, 0};
 
        // circular output buffer, collects the output for overlap-add
        int m_outputBufferSize;
        std::vector<std::vector<float>> m_outputBuffer;
        // one write pointer per channel
        std::vector<int> m_outputWritePointer;
        // one read pointer per channel
        std::vector<int> m_outputReadPointer{0, 0};
 
        // Used for Time Streching and Pitch calculation
        std::vector<std::vector<float>> m_previousPhasesInput;
        std::vector<std::vector<float>> m_previousPhasesOutput;
        std::vector<std::vector<float>> m_magnitudesSynthesis;
        std::vector<std::vector<float>> m_magnitudesAnalysis;
        std::vector<std::vector<float>> m_binFrequenciesAnalysis;
        std::vector<std::vector<float>> m_binFrequenciesSynthesis;
        int m_maxBinIndex{0};
        float m_maxBinValue{0.0f};
        float m_frequencyDetected{0.0f};
        float m_pitchShiftRatio{1.0f};  // for pitch shift
        float m_timeStretchRatio{1.0f}; // for time streching (>1 = expansion, <1 = compression)
 
        const int NUM_CHANNELS_MAX{2};
        // used in Robotizer window size recalculation - maintain COLA
        const int m_overlapFactor = 4;
        int m_numChannel;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PhaseVocoder)
    };
} // namespace krotos