AudioSTK.h

#pragma once
 
#include "AudioToolsConfig.h"
#include "AudioTools/CoreAudio/AudioEffects/AudioEffect.h"
#include "AudioTools/CoreAudio/AudioStreams.h"
 
#ifdef ESP32
#  include "freertos/FreeRTOS.h"
#endif
#include "StkAll.h"
 
namespace audio_tools {
 
template <class StkCls, class T>
class STKGenerator : public SoundGenerator<T> {
    public:
        STKGenerator() = default;
 
        // Creates an STKGenerator for an instrument
        STKGenerator(StkCls &instrument) : SoundGenerator<T>() {
            this->p_instrument = &instrument;
        }
 
        void setInput(StkCls &instrument){
            this->p_instrument = &instrument;
        }
 
        AudioInfo defaultConfig() {
            AudioInfo info;
            info.channels = 2;
            info.bits_per_sample = sizeof(T) * 8;
            info.sample_rate = stk::Stk::sampleRate();
            return info;
        }
        AudioInfo defaultConfig() {…}
 
        bool begin(AudioInfo cfg){
            TRACEI();
            cfg.logInfo();
            SoundGenerator<T>::begin(cfg);
            max_value = NumberConverter::maxValue(sizeof(T)*8);
            stk::Stk::setSampleRate(SoundGenerator<T>::info.sample_rate);
            return true;
        }
        bool begin(AudioInfo cfg) {…}
 
        T readSample() {
            T result = 0;
            if (p_instrument!=nullptr) {
                result = p_instrument->tick()*max_value;
            }
            return result;
        }
        T readSample() {…}
 
    protected:
        StkCls *p_instrument=nullptr;
        T max_value;
 
};
class STKGenerator : public SoundGenerator<T> {…};
 
template <class StkCls>
class STKStream : public GeneratedSoundStream<int16_t> {
    public:
        STKStream() {
            GeneratedSoundStream<int16_t>::setInput(generator);          
        };
 
        STKStream(StkCls &instrument){
            generator.setInput(instrument);
            GeneratedSoundStream<int16_t>::setInput(generator);
        }
        void setInput(StkCls &instrument){
            generator.setInput(instrument);
            GeneratedSoundStream<int16_t>::setInput(generator);
        }
        void setInput(StkCls *instrument){
            generator.setInput(*instrument);
            GeneratedSoundStream<int16_t>::setInput(generator);
        }
 
        AudioInfo defaultConfig() {
            AudioInfo info;
            info.channels = 1;
            info.bits_per_sample = 16;
            info.sample_rate = stk::Stk::sampleRate();
            return info;
        }
 
    protected:
        STKGenerator<StkCls,int16_t> generator;
 
};
class STKStream : public GeneratedSoundStream<int16_t> {…};
 
class STKEffect : public AudioEffect {
public:
  STKEffect(stk::Effect &stkEffect) { p_effect = &stkEffect; }
 
  virtual effect_t process(effect_t in) {
    // just convert between int16 and float
    float value = static_cast<float>(in) / 32767.0;
    return p_effect->tick(value) * 32767.0;
  }
  virtual effect_t process(effect_t in) {…}
 
protected:
  stk::Effect *p_effect = nullptr;
};
class STKEffect : public AudioEffect {…};
 
class STKChorus : public AudioEffect, public stk::Chorus {
public:
  STKChorus(float baseDelay = 6000) : stk::Chorus(baseDelay) {}
  STKChorus(const STKChorus& copy) = default;
 
  AudioEffect* clone() override{
    return new STKChorus(*this);
  }
 
  virtual effect_t process(effect_t in) {
    // just convert between int16 and float
    float value = static_cast<float>(in) / 32767.0;
    return stk::Chorus::tick(value) * 32767.0;
  }
  virtual effect_t process(effect_t in) {…}
};
class STKChorus : public AudioEffect, public stk::Chorus {…};
 
class STKEcho : public AudioEffect, public stk::Echo {
public:
  STKEcho(unsigned long maximumDelay = (unsigned long)Stk::sampleRate())
      : stk::Echo(maximumDelay) {}
  STKEcho(const STKEcho& copy) = default;
 
  AudioEffect* clone() override{
    return new STKEcho(*this);
  }
 
  virtual effect_t process(effect_t in) {
    // just convert between int16 and float
    float value = static_cast<float>(in) / 32767.0;
    return stk::Echo::tick(value) * 32767.0;
  }
  virtual effect_t process(effect_t in) {…}
};
class STKEcho : public AudioEffect, public stk::Echo {…};
 
class STKFreeVerb : public AudioEffect, public stk::FreeVerb {
public:
  STKFreeVerb() = default;
  STKFreeVerb(const STKFreeVerb& copy) = default;
  AudioEffect* clone() override{
    return new STKFreeVerb(*this);
  }
  virtual effect_t process(effect_t in) {
    // just convert between int16 and float
    float value = static_cast<float>(in) / 32767.0;
    return stk::FreeVerb::tick(value) * 32767.0;
  }
  virtual effect_t process(effect_t in) {…}
};
class STKFreeVerb : public AudioEffect, public stk::FreeVerb {…};
 
class STKChowningReverb : public AudioEffect, public stk::JCRev {
public:
  STKChowningReverb() = default;
  STKChowningReverb(const STKChowningReverb& copy) = default;
  AudioEffect* clone() override{
    return new STKChowningReverb(*this);
  }
 
  virtual effect_t process(effect_t in) {
    // just convert between int16 and float
    float value = static_cast<float>(in) / 32767.0;
    return stk::JCRev::tick(value) * 32767.0;
  }
  virtual effect_t process(effect_t in) {…}
};
class STKChowningReverb : public AudioEffect, public stk::JCRev {…};
 
class STKNReverb : public AudioEffect, public stk::NRev {
public:
  STKNReverb(float t60 = 1.0) : NRev(t60) {}
  STKNReverb(const STKNReverb& copy) = default;
  AudioEffect* clone() override{
    return new STKNReverb(*this);
  }
  virtual effect_t process(effect_t in) {
    // just convert between int16 and float
    float value = static_cast<float>(in) / 32767.0;
    return stk::NRev::tick(value) * 32767.0;
  }
  virtual effect_t process(effect_t in) {…}
};
class STKNReverb : public AudioEffect, public stk::NRev {…};
 
class STKPerryReverb : public AudioEffect, public stk::PRCRev {
public:
  STKPerryReverb(float t60 = 1.0) : PRCRev(t60) {}
  STKPerryReverb(const STKPerryReverb& copy) = default;
  AudioEffect* clone() override{
    return new STKPerryReverb(*this);
  }
  virtual effect_t process(effect_t in) {
    // just convert between int16 and float
    float value = static_cast<float>(in) / 32767.0;
    return stk::PRCRev::tick(value) * 32767.0;
  }
  virtual effect_t process(effect_t in) {…}
};
class STKPerryReverb : public AudioEffect, public stk::PRCRev {…};
 
class STKLentPitShift : public AudioEffect, public stk::LentPitShift {
public:
  STKLentPitShift(float periodRatio = 1.0, int tMax = 512)
      : stk::LentPitShift(periodRatio, tMax) {}
  STKLentPitShift(const STKLentPitShift& copy) = default;
 
  AudioEffect* clone() override{
    return new STKLentPitShift(*this);
  }
  virtual effect_t process(effect_t in) {
    // just convert between int16 and float
    float value = static_cast<float>(in) / 32767.0;
    return stk::LentPitShift::tick(value) * 32767.0;
  }
  virtual effect_t process(effect_t in) {…}
};
class STKLentPitShift : public AudioEffect, public stk::LentPitShift {…};
 
class STKPitShift : public AudioEffect, public stk::PitShift {
public:
  STKPitShift() = default;
  STKPitShift(const STKPitShift& copy) = default;
 
  AudioEffect* clone() override{
    return new STKPitShift(*this);
  }
  virtual effect_t process(effect_t in) {
    // just convert between int16 and float
    float value = static_cast<float>(in) / 32767.0;
    return stk::PitShift::tick(value) * 32767.0;
  }
  virtual effect_t process(effect_t in) {…}
};
class STKPitShift : public AudioEffect, public stk::PitShift {…};
 
 
}