CodecAACFDK.h

#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AACDecoderFDK.h"
#include "AACEncoderFDK.h"
 
 
namespace audio_tools {
 
// audio change notification target
AudioInfoSupport *audioChangeFDK = nullptr;
 
class AACDecoderFDK : public AudioDecoder  {
    public:
        AACDecoderFDK(int output_buffer_size = FDK_OUT_BUFFER_DEFAULT_SIZE){
            TRACED();
            dec = new aac_fdk::AACDecoderFDK(output_buffer_size);
        }
 
        AACDecoderFDK(Print &out_stream, int output_buffer_size = 2048){
            TRACED();
            dec = new aac_fdk::AACDecoderFDK(out_stream, output_buffer_size);
        }
 
        virtual ~AACDecoderFDK(){
            delete dec;
        }
 
        void setOutput(Print &out_stream){
            dec->setOutput(out_stream);
        }
 
        bool begin(){
            return dec->begin(TT_MP4_ADTS, 1);
        }
 
        // opens the decoder
        bool begin(TRANSPORT_TYPE transportType, UINT nrOfLayers){
            return dec->begin(transportType, nrOfLayers);
        }
 
        AAC_DECODER_ERROR configure(uint8_t *conf, const uint32_t &length) {
            return dec->configure(conf, length);
        }
 
        // write AAC data to be converted to PCM data
        virtual size_t write(const uint8_t *data, size_t len) {
            return dec->write(data, len);
        }
 
        // provides detailed information about the stream
        CStreamInfo audioInfoEx(){
            return dec->audioInfo();
        }
 
        // provides common information
        AudioInfo audioInfo() override {
            AudioInfo result;
            CStreamInfo i = audioInfoEx();
            result.channels = i.numChannels;
            result.sample_rate = i.sampleRate;
            result.bits_per_sample = 16;
            return result;
        }
 
        // release the resources
        void end(){
             TRACED();
            dec->end();
        }
 
        virtual operator bool() {
            return (bool)*dec;
        }
 
        aac_fdk::AACDecoderFDK *driver() {
            return dec;
        }
 
        static void audioChangeCallback(CStreamInfo &info){
            if (audioChangeFDK!=nullptr){
                AudioInfo base;
                base.channels = info.numChannels;
                base.sample_rate = info.sampleRate;
                base.bits_per_sample = 16;
                // notify audio change
                audioChangeFDK->setAudioInfo(base);
            }
        }
 
        void addNotifyAudioChange(AudioInfoSupport &bi) override {
            audioChangeFDK = &bi;
            // register audio change handler
            dec->setInfoCallback(audioChangeCallback);
        }
 
    protected:
        aac_fdk::AACDecoderFDK *dec=nullptr;
};
 
 
class AACEncoderFDK : public AudioEncoder {
 
public:
 
    AACEncoderFDK(){
        enc = new aac_fdk::AACEncoderFDK();
    }
 
    AACEncoderFDK(Print &out_stream){
        enc = new aac_fdk::AACEncoderFDK();
        enc->setOutput(out_stream);
    }
 
     ~AACEncoderFDK(){
         delete enc;
     }
 
     void setOutput(Print &out_stream){
         enc->setOutput(out_stream);
     }
 
    virtual void setBitrate(int bitrate){
        enc->setBitrate(bitrate);
    }
 
    virtual void setAudioObjectType(int aot){
        enc->setAudioObjectType(aot);
    }
 
    virtual void setAfterburner(bool afterburner){
        enc->setAfterburner(afterburner);
    }
 
    virtual void setSpectralBandReplication(int eld_sbr){
        enc->setSpectralBandReplication(eld_sbr);
    }
 
    virtual void setVariableBitrateMode(int vbr){
        enc->setVariableBitrateMode(vbr);
    }
    
    virtual void setOutputBufferSize(int outbuf_size){
        enc->setOutputBufferSize(outbuf_size);
    }
 
    void setAudioInfo(AudioInfo from) override {
        TRACED();
        AudioEncoder::setAudioInfo(from);
        aac_fdk::AudioInfo info;
        info.channels = from.channels;
        info.sample_rate = from.sample_rate;
        info.bits_per_sample = from.bits_per_sample;
        enc->setAudioInfo(info);
    }
 
    virtual bool begin(AudioInfo info) {
        TRACED();
        return enc->begin(info.channels,info.sample_rate, info.bits_per_sample);
    }
 
    virtual bool begin(int input_channels=2, int input_sample_rate=44100, int input_bits_per_sample=16) {
        TRACED();
        return enc->begin(input_channels,input_sample_rate, input_bits_per_sample);
    }
 
    // starts the processing
    bool begin() {
        enc->begin();
        return true;
    }
    
    // convert PCM data to AAC
    size_t write(const uint8_t *data, size_t len){
        LOGD("write %d bytes", (int)len);
        return enc->write((uint8_t*)data, len);
    }
 
    // release resources
    void end(){
        TRACED();
        enc->end();
    }
 
    UINT getParameter(const AACENC_PARAM param) {
        return enc->getParameter(param);
    }
    
    int setParameter(AACENC_PARAM param, uint32_t value){
        return enc->setParameter(param, value);
    }
 
    aac_fdk::AACEncoderFDK *driver() {
        return enc;
    }
 
    const char *mime() {
        return "audio/aac";
    }
 
    operator bool(){
        return (bool) *enc;
    }
 
 
protected:
    aac_fdk::AACEncoderFDK *enc=nullptr;
 
};
 
}