CodecFloat.h

#pragma once
 
#include "AudioCodecs/AudioEncoded.h"
 
 
namespace audio_tools {
 
class DecoderFloat : public AudioDecoder {
    public:
        DecoderFloat(Print &out_stream, bool active=true){
            TRACED();
            p_print = &out_stream;
        }
 
        DecoderFloat(Print &out_stream, AudioInfoSupport &bi){
            TRACED();
            p_print = &out_stream;
            addNotifyAudioChange(bi);
        }
 
        void setOutput(Print &out_stream) override {
            p_print = &out_stream;
        }
 
        virtual size_t write(const void *data, size_t in_size) override {
            if (p_print==nullptr)  return 0;
            int samples = in_size/sizeof(float);
            buffer.resize(samples);
            float* p_float = (float*) data;
            for (int j=0;j<samples;j++){
                buffer[j] = p_float[j]*32767;
            }
            return p_print->write((uint8_t*)buffer.data(), samples*sizeof(int16_t));
        }
 
        virtual operator bool() override {
            return p_print!=nullptr;;
        }
 
    protected:
        Print *p_print=nullptr;
        Vector<int16_t> buffer;
 
};
 
class EncoderFloat : public AudioEncoder {
    public: 
        // Empty Constructor - the output stream must be provided with begin()
        EncoderFloat(){
        }        
 
        // Constructor providing the output stream
        EncoderFloat(Print &out){
            p_print = &out;
        }
 
        void setOutput(Print &out_stream) override {
            p_print = &out_stream;
        }
 
        const char* mime() override{
            return mime_pcm;
        }
 
        virtual bool begin() override{
            is_open = true;
            return true;
        }
 
        bool begin(Print &out) {
            p_print = &out;
            return begin();
        }
 
        void end() override {
            is_open = false;
        }
 
        virtual size_t write(const void *in_ptr, size_t in_size) override {
            if (p_print==nullptr)  return 0;
            int16_t *pt16 = (int16_t*)in_ptr;
            size_t samples = in_size / sizeof(int16_t);
            buffer.resize(samples);
            for (size_t j=0;j<samples;j++){
                buffer[j] = static_cast<float>(pt16[j]) / 32768.0;
            }
            return p_print->write((uint8_t*)buffer.data(), samples*sizeof(float));
        }
 
        operator bool() override {
            return is_open;
        }
 
        bool isOpen(){
            return is_open;
        }
 
    protected:
        Print* p_print=nullptr;;
        volatile bool is_open;
        Vector<float> buffer;
        
 
};
 
}