CodecAACHelix.h

#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#ifndef HELIX_PRINT
#  define HELIX_PRINT
#endif
#include "AACDecoderHelix.h"
 
namespace audio_tools {
 
class AACDecoderHelix : public AudioDecoder  {
    public:
 
        AACDecoderHelix() {
            TRACED();
            aac = new libhelix::AACDecoderHelix();
            if (aac!=nullptr){
                aac->setReference(this);
            } else {
                LOGE("Not enough memory for libhelix");
            }
        }
        AACDecoderHelix(Print &out_stream){
            TRACED();
            aac = new libhelix::AACDecoderHelix(out_stream);
            if (aac!=nullptr){
                aac->setReference(this);
            } else {
                LOGE("Not enough memory for libhelix");
            }
        }  
        AACDecoderHelix(Print &out_stream) {…}
 
        AACDecoderHelix(Print &out_stream, AudioInfoSupport &bi){
            TRACED();
            aac = new libhelix::AACDecoderHelix(out_stream);
            if (aac!=nullptr){
                aac->setReference(this);
            } else {
                LOGE("Not enough memory for libhelix");
            }
            addNotifyAudioChange(bi);
        }  
        AACDecoderHelix(Print &out_stream, AudioInfoSupport &bi) {…}
 
        ~AACDecoderHelix(){
             TRACED();
            if (aac!=nullptr) delete aac;
        }
        ~AACDecoderHelix() {…}
 
        // void setRaw(bool flag){
        //     if (aac!=nullptr) aac->setRaw(flag);
        // }
 
        virtual void setOutput(Print &out_stream) override {
            TRACED();
            AudioDecoder::setOutput(out_stream);
            if (aac!=nullptr) aac->setOutput(out_stream);
        }
        virtual void setOutput(Print &out_stream) override  {…}
 
        bool begin() override {
            TRACED();
            if (aac!=nullptr) {
                //aac->setDelay(CODEC_DELAY_MS);
                aac->setInfoCallback(infoCallback, this);
                aac->begin();
            }
            return true;
        }
        bool begin() override  {…}
 
        virtual void end() override {
            TRACED();
            if (aac!=nullptr) aac->end();
        }
        virtual void end() override  {…}
 
        virtual _AACFrameInfo audioInfoEx(){
            return aac->audioInfo();
        }
 
        AudioInfo audioInfo() override{
            AudioInfo result;
            auto i = audioInfoEx();
            result.channels = i.nChans;
            result.sample_rate = i.sampRateOut;
            result.bits_per_sample = i.bitsPerSample;
            return result;
        }
        AudioInfo audioInfo() override {…}
 
        void setAudioInfo(AudioInfo info) override {
            this->info = info;
            if(info_notifications_active){
                notifyAudioChange(info);   
            }
        }
        void setAudioInfo(AudioInfo info) override  {…}
 
        size_t write(const uint8_t* data, size_t len) override {
            LOGD("AACDecoderHelix::write: %d", (int)len);
            if (aac==nullptr) return 0;
            int open = len;
            int processed = 0;
            uint8_t *data8 = (uint8_t*)data;
            while(open>0){
                 int act_write = aac->write(data8+processed, min(open, DEFAULT_BUFFER_SIZE));
                 open -= act_write;
                 processed += act_write;
            }
            return processed;
        }
        size_t write(const uint8_t* data, size_t len) override  {…}
 
        virtual operator bool() override {
            return aac!=nullptr && (bool)*aac;
        }
        virtual operator bool() override  {…}
 
        void flush(){
        //     aac->flush();
        }
 
        static void infoCallback(_AACFrameInfo &i, void* ref){
            AACDecoderHelix *p_helix =  (AACDecoderHelix *)ref;
            if (p_helix!=nullptr){
                TRACED();
                AudioInfo baseInfo;
                baseInfo.channels = i.nChans;
                baseInfo.sample_rate = i.sampRateOut;
                baseInfo.bits_per_sample = i.bitsPerSample;
                //p_helix->audioChangeAACHelix->setAudioInfo(baseInfo);   
                LOGW("sample_rate: %d", i.sampRateOut);
                p_helix->setAudioInfo(baseInfo);
            }
        }
        static void infoCallback(_AACFrameInfo &i, void* ref) {…}
 
        size_t maxFrameSize() {
            return aac->maxFrameSize();
        }
        size_t maxFrameSize() {…}
 
        void setMaxFrameSize(size_t len){
            aac->setMaxFrameSize(len);
        }
        void setMaxFrameSize(size_t len) {…}
 
        void setAudioInfoNotifications(bool active){
            info_notifications_active = active;
        }
 
        size_t maxPCMSize() {
            return aac->maxPCMSize();
        }
        size_t maxPCMSize() {…}
 
        void setMaxPCMSize(size_t len) {
            aac->setMaxPCMSize(len);
        }
        void setMaxPCMSize(size_t len) {…}
 
    protected:
        libhelix::AACDecoderHelix *aac=nullptr;
        bool info_notifications_active = true;
 
};
class AACDecoderHelix : public AudioDecoder {…};
 
 
} // namespace