CodecMP3LAME.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/AudioCodecs/HeaderParserMP3.h"
#include "MP3EncoderLAME.h"
 
namespace audio_tools {

struct AudioInfoLAME : public liblame::AudioInfo  {
    AudioInfoLAME () {
        sample_rate = 44100;
        channels = 2;
        bits_per_sample = 16;
    };
    AudioInfoLAME (const AudioInfoLAME  &) = default;
 
    int quality = 7; // 0..9.  0=best (very slow).  9=worst.
};

class MP3EncoderLAME : public AudioEncoder {
 
public:
    MP3EncoderLAME(bool splitFrames = false){
        TRACED();
        split_frames = splitFrames;
    }

    MP3EncoderLAME(Print &out_stream, bool splitFrames = false){
        TRACED();
        p_print = &out_stream;
        split_frames = splitFrames;
    }
 
    ~MP3EncoderLAME(){
        TRACED();
        end();
     }

    void setOutput(Print &out_stream){
        TRACED();
        p_print = &out_stream;
        if (split_frames) frames.setOutput(out_stream);
        if (enc!=nullptr){
            if (split_frames) {
                enc->setOutput(frame_writer);
            } else {
                enc->setOutput(out_stream);
            }
        }
    }

    void setAudioInfo(AudioInfo from) {
        TRACED();
        AudioEncoder::setAudioInfo(from);
        lame_info.channels = from.channels;
        lame_info.sample_rate = from.sample_rate;
        lame_info.bits_per_sample = from.bits_per_sample;
    }

    void setAudioInfo(AudioInfoLAME from) {
        TRACED();
        lame_info = from;
    }
 
    bool begin(AudioInfoLAME from) {
        setAudioInfo(from);
        return begin();
    }
 
    // starts the processing
    bool begin() {
        createEnc();
        if (enc==nullptr) return false;
        if (split_frames) {
            frames.resize(kMaxFrameSize);
            frames.reset();
        }
        enc->begin();
        return true;
    }
 
 
    AudioInfoLAME &audioInfoExt(){
        return lame_info;
    }
 
    AudioInfoLAME defaultConfig(){
        AudioInfoLAME def;
        return def;
    }
 
    // convert PCM data to convert into MP3
    size_t write(const uint8_t *data, size_t len){
        if (enc==nullptr) return 0;
        LOGD("write %d bytes", (int) len);
        return enc->write((uint8_t*)data, len);
    }
 
    // release resources
    void end(){
        TRACED();
        if (enc!=nullptr){
            enc->end();
            if (split_frames) frames.flush();
            delete enc;
            enc = nullptr;
        }
    }
 
    liblame::MP3EncoderLAME *driver() {
        return enc;
    }
 
    const char *mime() {
        return "audio/mpeg";
    }
 
    virtual operator bool() {
        return enc!=nullptr && (bool)(*enc);
    }
 
protected:
    class FrameWriter : public Print {
    public:
        FrameWriter(HeaderParserMP3 &frames) : frames(frames) {}
        size_t write(uint8_t c) override { return write(&c, 1); }
        size_t write(const uint8_t *data, size_t len) override {
            frames.write(data, len);
            frames.flush();  // writes all complete frames
            return len;
        }
    protected:
        HeaderParserMP3 &frames;
    };

    static constexpr int kMaxFrameSize = 2048;
 
    liblame::MP3EncoderLAME *enc=nullptr;
    AudioInfoLAME lame_info;
    Print *p_print=nullptr;
    bool split_frames = false;
    HeaderParserMP3 frames;
    FrameWriter frame_writer{frames};
 
    // Create enc only at begin so that we can use psram
    void createEnc(){
        TRACED();
        if (enc==nullptr){
            enc = new liblame::MP3EncoderLAME();
            if (p_print!=nullptr){
                setOutput(*p_print);
            } else {
                LOGE("Output undefined");
            }
            LOGI("LibLAME channels: %d", lame_info.channels);
            LOGI("LibLAME sample_rate: %d", lame_info.sample_rate);
            LOGI("LibLAME bits_per_sample: %d", lame_info.bits_per_sample);
            LOGI("LibLAME quality: %d", lame_info.quality);
            enc->setAudioInfo(lame_info);
        }
    }
 
};
 
}