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, 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(){
            if (mp3!=nullptr) delete mp3;
        }
 
        void setOutput(Print &outStream) override {
            AudioDecoder::setOutput(outStream);
            if (mp3!=nullptr) mp3->setOutput(outStream);
        }
 
        bool begin() override {
            TRACEI();
            if (mp3 == nullptr) {
                LOGE("Not enough memory for libhelix");
                return false;
            }
            mp3->begin(); 
            return true;
        }
 
        void end() override {
            TRACED();
            if (mp3!=nullptr) mp3->end();
        }
 
        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;
        }
 
        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);
        }
 
        operator bool() override {
            return mp3!=nullptr && (bool) *mp3;
        }
 
        libhelix::MP3DecoderHelix *driver() {
            return mp3;
        }
 
        void addNotifyAudioChange(AudioInfoSupport &bi) override {
            TRACED();
            AudioDecoder::addNotifyAudioChange(bi);
            if (mp3!=nullptr) mp3->setInfoCallback(infoCallback, this);
        }
 
        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");
            }
        }
 
        size_t maxFrameSize() {
            return mp3->maxFrameSize();
        }
 
        void setMaxFrameSize(size_t len){
            mp3->setMaxFrameSize(len);
        }
 
        size_t maxPCMSize() {
            return mp3->maxPCMSize();
        }
 
        void setMaxPCMSize(size_t len) {
            mp3->setMaxPCMSize(len);
        }
    protected:
        libhelix::MP3DecoderHelix *mp3=nullptr;
 
};
 
 
} // namespace