CodecMP3Helix.h

#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#ifndef HELIX_PRINT
#  define HELIX_PRINT
#endif
#include "MP3DecoderHelix.h"
 
namespace audio_tools {
 
class MP3DecoderHelix : public AudioDecoder  {
    public:
 
        MP3DecoderHelix() {
            TRACED();
            mp3 = new libhelix::MP3DecoderHelix();
            if (mp3!=nullptr){
                mp3->setReference(this);
            } else {
                LOGE("Not enough memory for libhelix");
            }
        }
        MP3DecoderHelix(Print &out_stream){
            TRACED();
            mp3 = new libhelix::MP3DecoderHelix();
            if (mp3!=nullptr){
                mp3->setReference(this);
            } else {
                LOGE("Not enough memory for libhelix");
            }
            setOutput(out_stream);
        }  
        MP3DecoderHelix(Print &out_stream) {…}
 
        MP3DecoderHelix(Print &out_stream, AudioInfoSupport &bi){
            TRACED();
            mp3 = new libhelix::MP3DecoderHelix();
            if (mp3!=nullptr){
                mp3->setReference(this);
            } else {
                LOGE("Not enough memory for libhelix");
            }
            setOutput(out_stream);
            addNotifyAudioChange(bi);
        }  
        MP3DecoderHelix(Print &out_stream, AudioInfoSupport &bi) {…}
 
        ~MP3DecoderHelix(){
            if (mp3!=nullptr) delete mp3;
        }
        ~MP3DecoderHelix() {…}
 
        void setOutput(Print &outStream) override {
            AudioDecoder::setOutput(outStream);
            if (mp3!=nullptr) mp3->setOutput(outStream);
        }
        void setOutput(Print &outStream) override  {…}
 
        bool begin() override {
            TRACED();
            if (mp3!=nullptr) {
                //mp3->setDelay(CODEC_DELAY_MS);   
                mp3->begin();
            } 
            return true;
        }
        bool begin() override  {…}
 
        void end() override {
            TRACED();
            if (mp3!=nullptr) mp3->end();
        }
        void end() override  {…}
 
        MP3FrameInfo audioInfoEx(){
            return mp3->audioInfo();
        }
 
        AudioInfo audioInfo() override {
            MP3FrameInfo i = audioInfoEx();
            AudioInfo baseInfo;
            baseInfo.channels = i.nChans;
            baseInfo.sample_rate = i.samprate;
            baseInfo.bits_per_sample = i.bitsPerSample;
            return baseInfo;
        }
        AudioInfo audioInfo() override  {…}
 
        size_t write(const uint8_t* data, size_t len) override {
            LOGD("%s: %zu", LOG_METHOD, len);
            if (mp3==nullptr) return 0;
            return mp3->write((uint8_t*)data, len);
        }
        size_t write(const uint8_t* data, size_t len) override  {…}
 
        operator bool() override {
            return mp3!=nullptr && (bool) *mp3;
        }
        operator bool() override  {…}
 
        libhelix::MP3DecoderHelix *driver() {
            return mp3;
        }
 
        void addNotifyAudioChange(AudioInfoSupport &bi) override {
            TRACED();
            AudioDecoder::addNotifyAudioChange(bi);
            if (mp3!=nullptr) mp3->setInfoCallback(infoCallback, this);
        }
        void addNotifyAudioChange(AudioInfoSupport &bi) override  {…}
 
        static void infoCallback(MP3FrameInfo &i, void * ref){
            MP3DecoderHelix* p_helix = (MP3DecoderHelix* )ref;
            if (p_helix!=nullptr){
                TRACED();
                AudioInfo baseInfo;
                baseInfo.channels = i.nChans;
                baseInfo.sample_rate = i.samprate;
                baseInfo.bits_per_sample = i.bitsPerSample;
                baseInfo.logInfo("MP3DecoderHelix");
                p_helix->notifyAudioChange(baseInfo);   
            } else {
                LOGE("Wrong Libhelix Version");
            }
        }
        static void infoCallback(MP3FrameInfo &i, void * ref) {…}
 
        size_t maxFrameSize() {
            return mp3->maxFrameSize();
        }
        size_t maxFrameSize() {…}
 
        void setMaxFrameSize(size_t len){
            mp3->setMaxFrameSize(len);
        }
        void setMaxFrameSize(size_t len) {…}
 
        size_t maxPCMSize() {
            return mp3->maxPCMSize();
        }
        size_t maxPCMSize() {…}
 
        void setMaxPCMSize(size_t len) {
            mp3->setMaxPCMSize(len);
        }
        void setMaxPCMSize(size_t len) {…}
    protected:
        libhelix::MP3DecoderHelix *mp3=nullptr;
 
};
class MP3DecoderHelix : public AudioDecoder {…};
 
 
} // namespace