AudioEffects.h

Go to the documentation of this file.

#pragma once
#include "AudioToolsConfig.h"
#include "AudioTools/CoreAudio/AudioBasic/Collections.h"
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "SoundGenerator.h"
#include "AudioEffect.h"
// USE_VARIANTS defaults to on whenever the compiler is capable of it (needed
// for AudioEffectStream's runtime bits_per_sample switching); define
// `#define USE_VARIANTS 0` before including AudioTools.h to force the plain
// AudioEffectStreamT<effect_t> typedef instead, e.g. on a size-constrained target.
#ifndef USE_VARIANTS
#  define USE_VARIANTS (__cplusplus >= 201703L)
#endif
#if USE_VARIANTS
#  include <variant>
#endif
 
namespace audio_tools {
 
class AudioEffectCommon {
    public:
        void addEffect(AudioEffect &effect){
            TRACED();
            effects.push_back(&effect);
        }
 
        void addEffect(AudioEffect *effect){
            TRACED();
            effects.push_back(effect);
            LOGI("addEffect -> Number of effects: %d", (int)size());
        }
        void clear() {
            TRACED();
            effects.clear();
        }
 
        size_t size() {
            return effects.size();
        }
 
        AudioEffect* findEffect(int id){
            // find AudioEffect
            AudioEffect* result = nullptr;
            for (int j=0;j<size();j++){
                // we assume that ADSRGain is the first effect!
                if (effects[j]->id()==id){
                    result = effects[j];
                }
                LOGI("--> findEffect -> %d", effects[j]->id());
            }
            return result;
        }
        AudioEffect* operator [](int idx){
            return effects[idx];
        }
 
    protected:
        Vector<AudioEffect*> effects;
 
};
 
template <class GeneratorT>
class AudioEffects : public SoundGenerator<effect_t> {
    public:
        AudioEffects() = default;
 
        AudioEffects(AudioEffects &copy) {
            TRACEI();
            // create a copy of the source and all effects
            p_generator = copy.p_generator;
            for (int j=0;j<copy.size();j++){
                effects.addEffect(copy[j]->clone());
            }
            LOGI("Number of effects %d -> %d", copy.size(), this->size());
        }
 
        AudioEffects(GeneratorT &generator) {
            setInput(generator);
        }
 
        AudioEffects(Stream &input, int channels=2, float volume=1.0) {
            setInput(* (new GeneratorT(input, channels, volume)));
            owns_generator = true;
        }
 
        virtual ~AudioEffects(){
            TRACED();
            if (owns_generator && p_generator!=nullptr){
                delete p_generator;
            }
            for (int j=0;j<effects.size();j++){
                delete effects[j];
            }
        }
        
        void setInput(GeneratorT &in){
            TRACED();
            p_generator = &in;
            // automatically activate this object
            AudioInfo info;
            info.channels = 1;
            info.bits_per_sample = sizeof(effect_t)*8;
            begin(info);
        }
 
        void addEffect(AudioEffect &effect){
            TRACED();
            effects.addEffect(&effect);
        }
 
        void addEffect(AudioEffect *effect){
            TRACED();
            effects.addEffect(effect);
            LOGI("addEffect -> Number of effects: %d", size());
        }
 
        effect_t readSample() override {
            effect_t sample;
            if (p_generator!=nullptr){
                sample  = p_generator->readSample();
                int size = effects.size();
                for (int j=0; j<size; j++){
                    sample = effects[j]->process(sample);
                }
            }
            return sample;
        }
 
        void clear() {
            TRACED();
            effects.clear();
        }
 
        size_t size() {
            return effects.size();
        }
 
        GeneratorT &generator(){
            return *p_generator;
        }
 
        AudioEffect* operator [](int idx){
            return effects[idx];
        }
 
        AudioEffect* findEffect(int id){
            return effects.findEffect(id);
        }
 
    protected:
        AudioEffectCommon effects;
        GeneratorT *p_generator=nullptr;
        bool owns_generator = false;
};
 
 
template <class T>
class AudioEffectStreamT : public ModifyingStream {
  public:
    AudioEffectStreamT() = default;
 
    AudioEffectStreamT(Stream &io){
        setStream(io);
    }
 
    AudioEffectStreamT(Print &out){
        setOutput(out);
    }
 
    // copying would shallow-copy channel_effects/owned_clones and double-free on destruction
    AudioEffectStreamT(const AudioEffectStreamT&) = delete;
    AudioEffectStreamT& operator=(const AudioEffectStreamT&) = delete;
 
    ~AudioEffectStreamT() {
        clear();
    }
 
    AudioInfo defaultConfig() {
        AudioInfo cfg;
        cfg.sample_rate = 44100;
        cfg.bits_per_sample = 16;
        cfg.channels = 2;
        return cfg;
    }
 
    bool begin(AudioInfo cfg){
        info = cfg;
        return begin();
    }
 
    bool begin(){
        TRACEI();
        // 24-bit samples are commonly stored padded to 4 bytes (int24_4bytes_t,
        // the default int24_t) for alignment/performance, so sizeof(T) won't
        // equal bits_per_sample/8==3 in that case; accept sizeof(int24_t) too.
        bool bits_ok = sizeof(T)==info.bits_per_sample/8
                    || (info.bits_per_sample==24 && sizeof(T)==sizeof(int24_t));
        if (bits_ok){
            active = true;
            setupChannels();
        } else {
            LOGE("bits_per_sample not consistent: %d",info.bits_per_sample);
            active = false;
        }
        return active;
    }
 
    void end() override {
        active = false;
    }
 
    void setStream(Stream &io) override {
        p_io = &io;
        p_out = &io;
    }
 
 
    void setOutput(Print &print) override {
        p_out = &print;
    }
 
    size_t readBytes(uint8_t *data, size_t len) override {
        if (!active || p_io==nullptr)return 0;
 
        // read data from source
        size_t result = p_io->readBytes((uint8_t*)data, len);
        int frames = result / sizeof(T) / info.channels;
        T* samples = (T*) data;
 
        for (int f=0;f<frames;f++){
            for (int ch=0;ch<info.channels;ch++){
                T &sample = samples[f*info.channels+ch];
                AudioEffectCommon &chain = channel_effects[ch];
                for (int j=0; j<chain.size(); j++){
                    sample = chain[j]->process(sample);
                }
            }
        }
        return result;
    }
 
    size_t write(const uint8_t *data, size_t len) override {
        if (!active)return 0;
        // length must be multple of channels
        assert(len % (sizeof(T)*info.channels)==0);
        int frames = len / sizeof(T) / info.channels;
        int total_samples = frames * info.channels;
 
        buffer_out.resize(total_samples);
        T* out = buffer_out.data();
 
        // process all samples
        for (int f=0;f<frames;f++){
            const T* p_buffer = ((const T*)data) + (f*info.channels);
            T* p_frame_out = out + (f*info.channels);
            for (int ch=0;ch<info.channels;ch++){
                T sample = p_buffer[ch];
                AudioEffectCommon &chain = channel_effects[ch];
                for (int j=0; j<chain.size(); j++){
                    sample = chain[j]->process(sample);
                }
                p_frame_out[ch] = sample;
            }
        }
 
        size_t written_samples = 0;
        if (p_io!=nullptr){
            written_samples = writeDataT<T, Stream>(p_io, out, total_samples);
        } else if (p_out!=nullptr){
            written_samples = writeDataT<T, Print>(p_out, out, total_samples);
        }
        return written_samples * sizeof(T);
    }
 
    int available() override {
        if (p_io==nullptr) return 0;
        return p_io->available();
    }
 
    int availableForWrite() override {
        if (p_out!=nullptr) return p_out->availableForWrite();
        if (p_io!=nullptr) return p_io->availableForWrite();
        return 0;
    }
 
    void flush() override {
        if (p_out!=nullptr) p_out->flush();
        else if (p_io!=nullptr) p_io->flush();
    }
 
    void addEffect(AudioEffect &effect){
        addEffect(&effect);
    }
 
    void addEffect(AudioEffect *effect){
        TRACED();
        effects.addEffect(effect);
        LOGI("addEffect -> Number of effects: %d", (int) size());
        // if channels are already set up, extend them immediately instead of
        // waiting for the next begin()
        if (active){
            for (int ch=0; ch<channel_effects.size(); ch++){
                cloneInto(ch, effect);
            }
        }
    }
 
    void addEffect(int channel, AudioEffect &effect){
        addEffect(channel, &effect);
    }
 
    void addEffect(int channel, AudioEffect *effect){
        TRACED();
        if (!active || channel<0 || channel>=channel_effects.size()){
            LOGE("Invalid channel %d or begin() not yet called", channel);
            return;
        }
        channel_effects[channel].addEffect(effect);
    }
 
    void clear() {
        TRACED();
        for (int i=0; i<owned_clones.size(); i++){
            delete owned_clones[i];
        }
        owned_clones.clear();
        channel_effects.clear();
        effects.clear();
    }
 
    size_t size() {
        return effects.size();
    }
 
    AudioEffect* operator [](int idx){
        return effects[idx];
    }
 
    AudioEffect* findEffect(int id){
        return effects.findEffect(id);
    }
 
    AudioEffectCommon& channelEffects(int channel){
        return channel_effects[channel];
    }
 
    int channelCount(){
        return channel_effects.size();
    }
 
  protected:
    AudioEffectCommon effects;                  // template chain populated via addEffect()
    Vector<AudioEffectCommon> channel_effects;   // one independent chain per channel, cloned from `effects`
    Vector<AudioEffect*> owned_clones;           // clones created internally; ours to delete
    Vector<T> buffer_out;                        // reused scratch buffer for write(): avoids per-sample writes
    bool active = false;
    Stream *p_io=nullptr;
    Print *p_out=nullptr;
 
    void cloneInto(int ch, AudioEffect *effect){
        AudioEffect *clone = effect->clone();
        channel_effects[ch].addEffect(clone);
        owned_clones.push_back(clone);
    }
 
    void setupChannels() {
        for (int i=0; i<owned_clones.size(); i++){
            delete owned_clones[i];
        }
        owned_clones.clear();
        channel_effects.clear();
        channel_effects.resize(info.channels);
        for (int ch=0; ch<info.channels; ch++){
            for (int j=0; j<effects.size(); j++){
                cloneInto(ch, effects[j]);
            }
        }
    }
};
 
#if USE_VARIANTS || defined(DOXYGEN)
class AudioEffectStream : public ModifyingStream {
  public:
    AudioEffectStream() = default;
 
    AudioEffectStream(Stream &io){
        setOutput(io);
        setInput(io);
    }
 
    AudioEffectStream(Print &out){
        setOutput(out);
    }
 
    AudioInfo defaultConfig() {
        AudioInfo cfg;
        cfg.sample_rate = 44100;
        cfg.bits_per_sample = 16;
        cfg.channels = 2;
        return cfg;
    }
 
    bool begin(AudioInfo cfg){
        info = cfg;
        return begin();
    }
 
    bool begin(){
        TRACEI();
        switch(info.bits_per_sample){
            case 16: 
                variant.emplace<0>();
                break;
            case 24: 
                variant.emplace<1>();
                break;
            case 32: 
                variant.emplace<2>();
                break;
            default:
                LOGE("Unspported bits_per_sample: %d", info.bits_per_sample);
                return false;
        }
        if (p_out != nullptr) {
            std::visit( [this](auto&& e) {return e.setOutput(*p_out);}, variant );
        }
        if (p_io != nullptr) {
            std::visit( [this](auto&& e) {return e.setStream(*p_io);}, variant );
        }
        return std::visit( [this](auto&& e) {return e.begin(info);}, variant );
    }
 
    void end() override {
        std::visit( [](auto&& e) {e.end();}, variant );
    }
 
    void setInput(Stream &io){
        setStream(io);
    }
 
    void setStream(Stream &io){
        p_io = &io;
    }
 
    void setOutput(Stream &io){
        p_out = &io;
    }
 
    void setOutput(Print &print){
        p_out = &print;
    }
 
    size_t readBytes(uint8_t *data, size_t len) override {
        return std::visit( [data, len](auto&& e) {return e.readBytes(data, len);}, variant );
    }
 
    size_t write(const uint8_t *data, size_t len) override {
        return std::visit( [data, len](auto&& e) {return e.write(data, len);}, variant );
    }
 
    int available() override {
        return std::visit( [](auto&& e) {return e.available();}, variant );
    }
 
    int availableForWrite() override {
        return std::visit( [](auto&& e) {return e.availableForWrite();}, variant );
    }
 
    void flush() override {
        std::visit( [](auto&& e) {e.flush();}, variant );
    }
 
    void addEffect(AudioEffect &effect){
        addEffect(&effect);
    }
 
    void addEffect(AudioEffect *effect){
        std::visit( [effect](auto&& e) {e.addEffect(effect);}, variant );
    }
 
    void addEffect(int channel, AudioEffect &effect){
        addEffect(channel, &effect);
    }
 
    void addEffect(int channel, AudioEffect *effect){
        std::visit( [channel, effect](auto&& e) {e.addEffect(channel, effect);}, variant );
    }
 
    void clear() {
        std::visit( [](auto&& e) {e.clear();}, variant );
    }
 
    size_t size() {
        return std::visit( [](auto&& e) {return e.size();}, variant );
    }
 
    AudioEffect* operator [](int idx){
        return std::visit( [idx](auto&& e) {return e[idx];}, variant );
    }
 
    AudioEffect* findEffect(int id){
        return std::visit( [id](auto&& e) {return e.findEffect(id);}, variant );
    }
 
    AudioEffectCommon& channelEffects(int channel){
        return std::visit( [channel](auto&& e) -> AudioEffectCommon& {return e.channelEffects(channel);}, variant );
    }
 
    int channelCount(){
        return std::visit( [](auto&& e) {return e.channelCount();}, variant );
    }
 
  protected:
    std::variant<AudioEffectStreamT<int16_t>, AudioEffectStreamT<int24_t>,AudioEffectStreamT<int32_t>> variant;
    Stream *p_io=nullptr;
    Print *p_out=nullptr;
 
};
 
#else
// Use int16_t as only supported data type
using AudioEffectStream = AudioEffectStreamT<effect_t>;
#endif
 
} // namespace