RADDsp.h

Go to the documentation of this file.

#ifndef RADDSP_H
#define RADDSP_H
 
#pragma once
 
#include <RADCore/RADLicenseGate.h>
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <vector>
 
namespace RADDsp {
 
    struct ComplexSample {
        float i = 0.0f;
        float q = 0.0f;
    };
 
    class FftPlan {
    public:
        FftPlan() = default;
        explicit FftPlan(size_t size);
 
        bool reset(size_t size);
        size_t size() const;
        bool valid() const;
 
        bool transformInPlace(std::vector<ComplexSample>& samples, bool inverse = false) const;
        bool transform(const std::vector<ComplexSample>& input, std::vector<ComplexSample>& output,
            bool inverse = false) const;
        std::vector<ComplexSample> transform(const std::vector<ComplexSample>& input,
            bool inverse = false) const;
        bool transformManyInPlace(std::vector<std::vector<ComplexSample>>& frames,
            bool inverse = false) const;
        bool transformMany(const std::vector<std::vector<ComplexSample>>& inputs,
            std::vector<std::vector<ComplexSample>>& outputs, bool inverse = false) const;
        std::vector<std::vector<ComplexSample>> transformMany(
            const std::vector<std::vector<ComplexSample>>& inputs, bool inverse = false) const;
        bool transformFramesInPlace(std::vector<ComplexSample>& frames, size_t frameCount,
            bool inverse = false) const;
        bool transformFrames(const std::vector<ComplexSample>& input, size_t frameCount,
            std::vector<ComplexSample>& output, bool inverse = false) const;
        std::vector<ComplexSample> transformFrames(const std::vector<ComplexSample>& input,
            size_t frameCount, bool inverse = false) const;
 
    private:
        size_t size_ = 0;
        std::vector<size_t> bitReverse_;
        std::vector<ComplexSample> twiddlesForward_;
        std::vector<ComplexSample> twiddlesInverse_;
    };
 
    class MatrixF {
    public:
        MatrixF() = default;
        MatrixF(size_t rows, size_t columns, float value = 0.0f);
        MatrixF(size_t rows, size_t columns, const std::vector<float>& rowMajor);
 
        size_t rows() const;
        size_t columns() const;
        bool empty() const;
        const std::vector<float>& data() const;
        std::vector<float>& data();
        void resize(size_t rows, size_t columns, float value = 0.0f);
        float& operator()(size_t row, size_t column);
        float operator()(size_t row, size_t column) const;
        float get(size_t row, size_t column) const;
        bool set(size_t row, size_t column, float value);
 
    private:
        size_t rows_ = 0;
        size_t columns_ = 0;
        std::vector<float> data_;
    };
 
    struct BiquadCoefficients {
        float b0 = 1.0f;
        float b1 = 0.0f;
        float b2 = 0.0f;
        float a1 = 0.0f;
        float a2 = 0.0f;
    };
 
    struct BiquadState {
        float x1 = 0.0f;
        float x2 = 0.0f;
        float y1 = 0.0f;
        float y2 = 0.0f;
 
        void reset();
        float process(float input, const BiquadCoefficients& coeffs);
    };
 
    struct EqualizerBand {
        float frequencyHz = 1000.0f;
        float gainDb = 0.0f;
        float q = 1.0f;
    };
 
    class BiquadCascade {
    public:
        void setSections(std::vector<BiquadCoefficients> sections);
        void addSection(BiquadCoefficients section);
        void clear();
        void reset();
        const std::vector<BiquadCoefficients>& sections() const;
        float processSample(float input);
        std::vector<float> process(const std::vector<float>& samples);
 
    private:
        std::vector<BiquadCoefficients> sections_;
        std::vector<BiquadState> states_;
    };
 
    class Equalizer16Band {
    public:
        explicit Equalizer16Band(uint32_t sampleRate = 48000);
        void setSampleRate(uint32_t sampleRate);
        uint32_t sampleRate() const;
        const std::array<EqualizerBand, 16>& bands() const;
        bool setBand(size_t index, float frequencyHz, float gainDb, float q = 1.0f);
        bool setBandGain(size_t index, float gainDb);
        float bandGain(size_t index) const;
        void reset();
        std::vector<float> process(const std::vector<float>& samples);
 
    private:
        void rebuild();
 
        uint32_t sampleRate_ = 48000;
        std::array<EqualizerBand, 16> bands_{};
        BiquadCascade cascade_;
    };
 
    struct StereoFrame {
        float left = 0.0f;
        float right = 0.0f;
    };
 
    struct DelaySettings {
        uint32_t sampleRate = 48000;
        float delayMs = 250.0f;
        float feedback = 0.25f;
        float wet = 0.35f;
        float dry = 1.0f;
        float crossFeedback = 0.0f;
        float maxDelayMs = 2000.0f;
    };
 
    class DigitalDelay {
    public:
        explicit DigitalDelay(uint32_t sampleRate = 48000, float maxDelayMs = 2000.0f);
        void configure(const DelaySettings& settings);
        const DelaySettings& settings() const;
        void setSampleRate(uint32_t sampleRate);
        void reset();
        StereoFrame processSample(StereoFrame input);
        std::vector<float> processInterleavedStereo(const std::vector<float>& interleaved);
 
    private:
        float readDelay(const std::vector<float>& buffer, float delaySamples) const;
        void resizeBuffer();
 
        DelaySettings settings_{};
        std::vector<float> bufferL_;
        std::vector<float> bufferR_;
        size_t writeIndex_ = 0;
    };
 
    struct AnalogDelaySettings : DelaySettings {
        float modulationRateHz = 0.35f;
        float modulationDepthMs = 3.0f;
        float tone = 0.35f;
        float drive = 0.15f;
        float stereoPhase = 0.25f;
    };
 
    class AnalogModDelay {
    public:
        explicit AnalogModDelay(uint32_t sampleRate = 48000, float maxDelayMs = 2000.0f);
        void configure(const AnalogDelaySettings& settings);
        const AnalogDelaySettings& settings() const;
        void setSampleRate(uint32_t sampleRate);
        void reset();
        StereoFrame processSample(StereoFrame input);
        std::vector<float> processInterleavedStereo(const std::vector<float>& interleaved);
 
    private:
        float readDelay(const std::vector<float>& buffer, float delaySamples) const;
        void resizeBuffer();
 
        AnalogDelaySettings settings_{};
        std::vector<float> bufferL_;
        std::vector<float> bufferR_;
        size_t writeIndex_ = 0;
        float toneStateL_ = 0.0f;
        float toneStateR_ = 0.0f;
        float lfoPhase_ = 0.0f;
    };
 
    void applyGain(std::vector<float>& samples, float gain);
    std::vector<float> mix(const std::vector<float>& a, const std::vector<float>& b);
    float peak(const std::vector<float>& samples);
    float rms(const std::vector<float>& samples);
    void normalizePeak(std::vector<float>& samples, float targetPeak = 1.0f);
 
    std::vector<float> sine(float frequencyHz, float seconds, uint32_t sampleRate, float amplitude = 1.0f);
    std::vector<float> whiteNoise(size_t count, float amplitude = 1.0f, uint32_t seed = 0x524144u);
 
    std::vector<float> linearResample(const std::vector<float>& interleaved, uint16_t channels,
        uint32_t sourceRate, uint32_t targetRate);
    std::vector<std::vector<float>> deinterleave(const std::vector<float>& interleaved, uint16_t channels);
    std::vector<float> interleave(const std::vector<std::vector<float>>& channels);
    std::vector<float> magnitude(const std::vector<ComplexSample>& samples);
    std::vector<float> phase(const std::vector<ComplexSample>& samples);
    void applyGain(std::vector<ComplexSample>& samples, float gain);
    std::vector<ComplexSample> frequencyShift(const std::vector<ComplexSample>& samples,
        float frequencyHz, uint32_t sampleRate);
 
    std::vector<float> hannWindow(size_t count);
    std::vector<float> hammingWindow(size_t count);
    std::vector<float> blackmanWindow(size_t count);
    std::vector<float> rectangularWindow(size_t count);
    void applyWindow(std::vector<float>& samples, const std::vector<float>& window);
    std::vector<float> firFilter(const std::vector<float>& samples, const std::vector<float>& taps);
    std::vector<float> convolve(const std::vector<float>& a, const std::vector<float>& b);
    std::vector<float> crossCorrelate(const std::vector<float>& a, const std::vector<float>& b);
    std::vector<float> normalizedCrossCorrelate(const std::vector<float>& a, const std::vector<float>& b);
    std::vector<float> onePoleLowPass(const std::vector<float>& samples, float alpha);
    FftPlan createFftPlan(size_t size);
    std::vector<ComplexSample> fft(const std::vector<ComplexSample>& samples, bool inverse = false);
    std::vector<std::vector<ComplexSample>> fftMany(
        const std::vector<std::vector<ComplexSample>>& frames, bool inverse = false);
    std::vector<ComplexSample> fftFrames(const std::vector<ComplexSample>& frames,
        size_t frameSize, bool inverse = false);
    std::vector<float> magnitudeSpectrum(const std::vector<ComplexSample>& spectrum);
    std::vector<float> powerSpectrum(const std::vector<ComplexSample>& spectrum);
    std::vector<float> designLowPassFIR(size_t taps, float cutoffHz, uint32_t sampleRate);
    BiquadCoefficients designBiquadLowPass(float cutoffHz, uint32_t sampleRate, float q = 0.70710678f);
    BiquadCoefficients designBiquadHighPass(float cutoffHz, uint32_t sampleRate, float q = 0.70710678f);
    BiquadCoefficients designBiquadBandPass(float centerHz, uint32_t sampleRate, float q = 1.0f);
    BiquadCoefficients designBiquadNotch(float centerHz, uint32_t sampleRate, float q = 1.0f);
    BiquadCoefficients designBiquadPeakingEQ(float centerHz, uint32_t sampleRate, float gainDb, float q = 1.0f);
    std::vector<float> decimate(const std::vector<float>& samples, size_t factor);
    std::vector<float> interpolateZeros(const std::vector<float>& samples, size_t factor);
    std::vector<float> mixCosine(const std::vector<float>& samples, float frequencyHz, uint32_t sampleRate);
    void automaticGainControl(std::vector<float>& samples, float targetRms = 0.25f, float maxGain = 32.0f);
 
    MatrixF identityMatrix(size_t size);
    MatrixF diagonalMatrix(const std::vector<float>& diagonal);
    MatrixF transpose(const MatrixF& matrix);
    MatrixF add(const MatrixF& a, const MatrixF& b);
    MatrixF subtract(const MatrixF& a, const MatrixF& b);
    MatrixF scale(const MatrixF& matrix, float scalar);
    MatrixF hadamard(const MatrixF& a, const MatrixF& b);
    MatrixF multiply(const MatrixF& a, const MatrixF& b);
    std::vector<float> multiply(const MatrixF& matrix, const std::vector<float>& vector);
    std::vector<float> multiply(const MatrixF& matrix, std::initializer_list<float> vector);
    float dot(const std::vector<float>& a, const std::vector<float>& b);
    float l2Norm(const std::vector<float>& vector);
    std::vector<float> normalizeVector(const std::vector<float>& vector);
    MatrixF outerProduct(const std::vector<float>& a, const std::vector<float>& b);
    MatrixF covarianceMatrix(const MatrixF& observations);
    bool invert(const MatrixF& matrix, MatrixF& inverse, float epsilon = 1.0e-6f);
    bool solveLinearSystem(const MatrixF& matrix, const std::vector<float>& rhs,
        std::vector<float>& solution, float epsilon = 1.0e-6f);
 
} // namespace RADDsp
 
#endif