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) {…}
 
  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(Print &out_stream, AudioInfoSupport &bi) {…}
 
  ~MP3DecoderHelix() {
    if (mp3 != nullptr) delete mp3;
  }
  ~MP3DecoderHelix() {…}
 
  void setOutput(Print &outStream) override {
    AudioDecoder::setOutput(outStream);
    if (mp3 != nullptr) mp3->setOutput(outStream);
  }
  void setOutput(Print &outStream) override  {…}
 
  bool begin() override {
    TRACEI();
    if (mp3 == nullptr) {
      LOGE("Not enough memory for libhelix");
      return false;
    }
    mp3->begin();
    return true;
  }
  bool begin() override  {…}
 
  void end() override {
    TRACED();
    if (mp3 != nullptr) mp3->end();
  }
  void end() override  {…}
 
  MP3FrameInfo audioInfoEx() { return mp3->audioInfo(); }
 
  AudioInfo audioInfo() override {
    AudioInfo baseInfo;
    MP3FrameInfo i = audioInfoEx();
    if (i.nChans != 0 && i.samprate != 0 && i.bitsPerSample != 0) {
      baseInfo.channels = i.nChans;
      baseInfo.sample_rate = i.samprate;
      baseInfo.bits_per_sample = i.bitsPerSample;
    }
    return baseInfo;
  }
  AudioInfo audioInfo() override  {…}
 
  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);
  }
  size_t write(const uint8_t *data, size_t len) override  {…}
 
  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);
  }
  void addNotifyAudioChange(AudioInfoSupport &bi) override  {…}
 
  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");
    }
  }
  static void infoCallback(MP3FrameInfo &i, void *ref) {…}
 
  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;
};
class MP3DecoderHelix : public AudioDecoder {…};
 
}  // namespace audio_tools