MP3EncoderLAME.h

#pragma once
 
#include "lame_log.h"
#include "liblame/lame.h"
#include <stdint.h>
#include <unistd.h>
 
namespace liblame {
 
typedef void (*MP3CallbackFDK)(uint8_t *mp3_data, size_t len);
struct AudioInfo {
  AudioInfo() = default;
  AudioInfo(const AudioInfo &) = default;
  int sample_rate = 16000;
  int channels = 1;
  int bits_per_sample = 16; // we assume int16_t
  int quality = 7;          // 0..9.  0=best (very slow).  9=worst.
  int frame_size = 0;       // determined by decoder
};
 
class MP3EncoderLAME {
 
public:
  MP3EncoderLAME() { LOG_LAME(Debug, __FUNCTION__); }
 
  MP3EncoderLAME(MP3CallbackFDK cb) {
    LOG_LAME(Debug, __FUNCTION__);
    setDataCallback(cb);
  }
 
  void setDataCallback(MP3CallbackFDK cb) {
    LOG_LAME(Debug, __FUNCTION__);
    this->MP3Callback = cb;
  }
 
#ifdef ARDUINO
 
  MP3EncoderLAME(Print &out_stream) {
    LOG_LAME(Debug, __FUNCTION__);
    this->out = &out_stream;
  }
 
  void setOutput(Print &out_stream) {
    LOG_LAME(Debug, __FUNCTION__);
    this->out = &out_stream;
  }
 
#endif
 
  ~MP3EncoderLAME() {
    LOG_LAME(Debug, __FUNCTION__);
    end();
    // release buffers
    if (convert_buffer != nullptr)
      delete[] convert_buffer;
    if (mp3_buffer != nullptr)
      delete[] mp3_buffer;
  }
 
  void begin() {
    LOG_LAME(Debug, __FUNCTION__);
    active = setup();
  }
 
  void begin(AudioInfo in) {
    LOG_LAME(Debug, __FUNCTION__);
    setAudioInfo(in);
    active = setup();
  }
 
  void begin(int input_channels, int input_sample_rate,
             int input_bits_per_sample) {
    LOG_LAME(Debug, __FUNCTION__);
    AudioInfo ai;
    ai.channels = input_channels;
    ai.sample_rate = input_sample_rate;
    ai.bits_per_sample = input_bits_per_sample;
    setAudioInfo(ai);
    active = setup();
  }
 
  void setAudioInfo(AudioInfo in) { this->info = in; }
 
  AudioInfo audioInfo() { return info; }
 
  int32_t write(void *pcm_samples, int bytes) {
    int32_t result = 0;
    if (active) {
      LOG_LAME(Debug, "write %d bytes", bytes);
 
      // convert to required input format
      short *buffer = convertToShort(pcm_samples, bytes);
      if (buffer == nullptr) {
        return 0;
      }
 
      // setup output buffer if necessary
      int nsamples = bytes / (info.bits_per_sample / 8) / info.channels;
      int outbuf_size = 7200 + (1.25 * nsamples);
      if (!setupOutputBuffer(outbuf_size)) {
        return 0;
      }
 
      // encode based on the number of channels
      int mp3_len = 0;
      if (info.channels == 1) {
        mp3_len =
            lame_encode_buffer(lame, buffer, NULL, nsamples, mp3_buffer, 0);
      } else {
        mp3_len = lame_encode_buffer_interleaved(lame, buffer, nsamples,
                                                 mp3_buffer, 0);
      }
 
      if (mp3_len > 0) {
        provideResult((uint8_t *)mp3_buffer, mp3_len);
      }
      result = bytes;
    }
    return result;
  }
 
  void end() {
    LOG_LAME(Debug, __FUNCTION__);
    lame_close(lame);
    lame = nullptr;
  }
 
  operator boolean() { return active; }
 
protected:
  bool active;
  MP3CallbackFDK MP3Callback = nullptr;
  AudioInfo info;
  // lame
  lame_t lame = nullptr;
  // mp3 result buffer
  uint8_t *mp3_buffer = nullptr;
  int mp3_buffer_size = 0;
  // conversion to short
  short *convert_buffer = nullptr;
  int convert_buffer_size = 0;
 
#ifdef ARDUINO
  Print *out;
#endif
 
  bool setupOutputBuffer(int size) {
    if (size > mp3_buffer_size) {
      LOG_LAME(Debug, __FUNCTION__);
      if (mp3_buffer != nullptr)
        delete[] mp3_buffer;
      mp3_buffer = new uint8_t[size];
      mp3_buffer_size = size;
    }
    return mp3_buffer != nullptr;
  }
 
  bool setup() {
    LOG_LAME(Debug, __FUNCTION__);
    if (lame==nullptr){
      lame = lame_init();
    }
    if (lame == nullptr) {
      LOG_LAME(Error, "lame_init failed");
      return false;
    }
 
    lame_set_VBR(lame, vbr_default);
    lame_set_num_channels(lame, info.channels);
    if (info.channels == 1) {
      lame_set_mode(lame, MONO);
    }
    lame_set_in_samplerate(lame, info.sample_rate);
    lame_set_quality(lame, info.quality);
 
    int initRet = lame_init_params(lame);
    if (initRet < 0) {
      LOG_LAME(Error, "lame_init_params\n");
      return false;
    }
 
    info.frame_size = lame_get_framesize(lame);
    LOG_LAME(Info, "Framesize = %d\n", info.frame_size);
    return true;
  }
 
  short *convertToShort(void *pcm_samples, int bytes) {
    int bytes_per_sample = info.bits_per_sample / 8;
    // input is already in correct format
    if (sizeof(short) == bytes_per_sample) {
      return (short *)pcm_samples;
    }
 
    // if we got here conversion is required
    LOG_LAME(Debug, __FUNCTION__);
 
    // allocate conversion buffer
    int samples = bytes / bytes_per_sample;
    if (convert_buffer == nullptr || samples > convert_buffer_size) {
      if (convert_buffer != nullptr) {
        delete[] convert_buffer;
      }
      convert_buffer = new short[samples];
      convert_buffer_size = samples;
    }
 
    if (convert_buffer == nullptr) {
      LOG_LAME(Error, "not enough memory to allocate conversion buffer - decrise "
                 "the size of written bytes!")
      lame_abort();
      return nullptr;
    }
 
    // convert input to short
    switch (info.bits_per_sample) {
    case 8: {
      int8_t *ptr = (int8_t *)pcm_samples;
      for (int j = 0; j < samples; j++) {
        convert_buffer[j] = ptr[j];
      }
      return convert_buffer;
    }
    case 16: {
      int16_t *ptr = (int16_t *)pcm_samples;
      for (int j = 0; j < samples; j++) {
        convert_buffer[j] = ptr[j];
      }
      return convert_buffer;
    }
    case 32: {
      int32_t *ptr = (int32_t *)pcm_samples;
      for (int j = 0; j < samples; j++) {
        convert_buffer[j] = ptr[j];
      }
      return convert_buffer;
    }
    default:
      LOG_LAME(Error, "Unsupported bits_per_sample: %d", info.bits_per_sample);
      return nullptr;
    }
  }
 
  void provideResult(uint8_t *data, size_t bytes) {
    if (bytes > 0) {
      LOG_LAME(Debug, "provideResult: %zu samples", bytes);
      // provide result
      if (MP3Callback != nullptr) {
        // output via callback
        MP3Callback(data, bytes);
      }
#ifdef ARDUINO
      if (out != nullptr) {
        out->write((uint8_t *)data, bytes);
      }
#endif
    }
  }
};
 
} // namespace liblame