wavetable.h

Go to the documentation of this file.

#pragma once
 
#include "JuceHeader.h"
 
#include "common.h"
#include "futils.h"
#include "utils.h"
#include "wave_frame.h"
 
namespace vital {
 
    class Wavetable {
    public:
        static constexpr int kFrequencyBins = WaveFrame::kWaveformBits;
        static constexpr int kWaveformSize = WaveFrame::kWaveformSize;
        static constexpr int kExtraValues = 3;
        static constexpr int kNumHarmonics = kWaveformSize / 2 + 1;
        static constexpr int kPolyFrequencySize = 2 * kNumHarmonics / poly_float::kSize + 2;
 
        struct WavetableData {
            WavetableData(int frames, int table_version) :
                    num_frames(frames), frequency_ratio(1.0f), sample_rate(kDefaultSampleRate), version(table_version) { }
 
            int num_frames;  
            mono_float frequency_ratio;  
            mono_float sample_rate;      
            int version;                 
 
            std::unique_ptr<mono_float[][kWaveformSize]> wave_data;
            std::unique_ptr<poly_float[][kPolyFrequencySize]> frequency_amplitudes;
            std::unique_ptr<poly_float[][kPolyFrequencySize]> normalized_frequencies;
            std::unique_ptr<poly_float[][kPolyFrequencySize]> phases;
        };
 
        static constexpr const mono_float* null_waveform() { return kZeroWaveform; }
 
        Wavetable(int max_frames);
 
        void loadDefaultWavetable();
 
        void setNumFrames(int num_frames);
 
        void setFrequencyRatio(float frequency_ratio);
 
        void setSampleRate(float rate);
 
        std::string getName() { return name_; }
 
        std::string getAuthor() { return author_; }
 
        void setName(const std::string& name) { name_ = name; }
 
        void setAuthor(const std::string& author) { author_ = author; }
 
        static force_inline mono_float getFrequencyFloatBin(mono_float phase_increment) {
            return futils::log2(1.0f / phase_increment);
        }
 
        static force_inline int getFrequencyBin(mono_float phase_increment) {
            int num_waves = 1.0f / phase_increment;
            return utils::iclamp(utils::ilog2(num_waves), 0, kFrequencyBins - 1);
        }
 
        force_inline int clampFrame(int frame) {
            return std::min(frame, current_data_->num_frames - 1);
        }
 
        force_inline const WavetableData* getAllData() {
            return current_data_;
        }
 
        force_inline mono_float* getBuffer(int frame_index) {
            return current_data_->wave_data[clampFrame(frame_index)];
        }
 
        force_inline poly_float* getFrequencyAmplitudes(int frame_index) {
            return current_data_->frequency_amplitudes[clampFrame(frame_index)];
        }
 
        force_inline poly_float* getNormalizedFrequencies(int frame_index) {
            return current_data_->normalized_frequencies[clampFrame(frame_index)];
        }
 
        force_inline int getVersion() {
            return current_data_->version;
        }
 
        force_inline int clampActiveFrame(int frame) {
            return std::min(frame, active_audio_data_.load()->num_frames - 1);
        }
 
        force_inline float getActiveFrequencyRatio() const {
            return active_audio_data_.load()->frequency_ratio;
        };
 
        force_inline float getActiveSampleRate() const {
            return active_audio_data_.load()->sample_rate;
        };
 
        force_inline const WavetableData* getAllActiveData() {
            return active_audio_data_.load();
        }
 
        force_inline poly_float* getActiveFrequencyAmplitudes(int frame_index) {
            return active_audio_data_.load()->frequency_amplitudes[clampActiveFrame(frame_index)];
        }
 
        force_inline poly_float* getActiveNormalizedFrequencies(int frame_index) {
            return active_audio_data_.load()->normalized_frequencies[clampActiveFrame(frame_index)];
        }
 
        force_inline int getActiveVersion() {
            return active_audio_data_.load()->version;
        }
 
        void loadWaveFrame(const WaveFrame* wave_frame);
 
        void loadWaveFrame(const WaveFrame* wave_frame, int to_index);
 
        void postProcess(float max_span);
 
        force_inline int numFrames() const { return current_data_->num_frames; }
 
        force_inline int numActiveFrames() const { return active_audio_data_.load()->num_frames; }
 
        force_inline void markUsed() { active_audio_data_ = current_data_; }
 
        force_inline void markUnused() { active_audio_data_ = nullptr; }
 
        force_inline void setShepardTable(bool shepard) { shepard_table_ = shepard; }
 
        force_inline bool isShepardTable() { return shepard_table_; }
 
    protected:
        Wavetable() = default;
 
        void loadFrequencyAmplitudes(const std::complex<float>* frequencies, int to_index);
 
        void loadNormalizedFrequencies(const std::complex<float>* frequencies, int to_index);
 
        static const mono_float kZeroWaveform[kWaveformSize + kExtraValues];
 
        std::string name_;                 
        std::string author_;               
        int max_frames_;                   
        WavetableData* current_data_;      
        std::atomic<WavetableData*> active_audio_data_; 
        std::unique_ptr<WavetableData> data_; 
        bool shepard_table_;               
 
        mono_float fft_data_[2 * kWaveformSize]; 
 
        JUCE_LEAK_DETECTOR(Wavetable)
    };
} // namespace vital