CodecFloat.h

#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
 
 
namespace audio_tools {
 
class DecoderFloat : public AudioDecoder {
    public:
        DecoderFloat() = default;
        DecoderFloat(Print &out_stream, bool active=true){
            TRACED();
            p_print = &out_stream;
        }
        DecoderFloat(Print &out_stream, bool active=true) {…}
 
        DecoderFloat(Print &out_stream, AudioInfoSupport &bi){
            TRACED();
            p_print = &out_stream;
            addNotifyAudioChange(bi);
        }
        DecoderFloat(Print &out_stream, AudioInfoSupport &bi) {…}
 
        void setOutput(Print &out_stream) override {
            p_print = &out_stream;
        }
        void setOutput(Print &out_stream) override  {…}
 
        virtual size_t write(const uint8_t *data, size_t len) override {
            if (p_print==nullptr)  return 0;
            int samples = len/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)) * 2;
        }
        virtual size_t write(const uint8_t *data, size_t len) override  {…}
 
        virtual operator bool() override {
            return p_print!=nullptr;;
        }
 
    protected:
        Print *p_print=nullptr;
        Vector<int16_t> buffer;
 
};
class DecoderFloat : public AudioDecoder {…};
 
class EncoderFloat : public AudioEncoder {
    public: 
        EncoderFloat() = default;      
 
        EncoderFloat(Print &out){
            p_print = &out;
        }
        EncoderFloat(Print &out) {…}
 
        void setOutput(Print &out_stream) override {
            p_print = &out_stream;
        }
        void setOutput(Print &out_stream) override  {…}
 
        const char* mime() override{
            return mime_pcm;
        }
        const char* mime() override {…}
 
        virtual bool begin() override{
            is_open = true;
            return true;
        }
        virtual bool begin() override {…}
 
        bool begin(Print &out) {
            p_print = &out;
            return begin();
        }
        bool begin(Print &out) {…}
 
        void end() override {
            is_open = false;
        }
        void end() override  {…}
 
        virtual size_t write(const uint8_t *data, size_t len) override {
            if (p_print==nullptr)  return 0;
            int16_t *pt16 = (int16_t*)data;
            size_t samples = len / 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));
        }
        virtual size_t write(const uint8_t *data, size_t len) override  {…}
 
        operator bool() override {
            return is_open;
        }
 
        bool isOpen(){
            return is_open;
        }
 
    protected:
        Print* p_print=nullptr;;
        volatile bool is_open;
        Vector<float> buffer;
        
 
};
class EncoderFloat : public AudioEncoder {…};
 
}