CodecBasic.h

#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/AudioCodecs/CodecG7xx.h"
 
namespace audio_tools {
 
class DecoderBasic : public AudioDecoder {
public:
  DecoderBasic() { TRACED(); }
 
  DecoderBasic(Print &out_stream, bool active = true) {
    TRACED();
    setOutput(out_stream);
  }
  DecoderBasic(Print &out_stream, bool active = true) {…}
 
  DecoderBasic(Print &out_stream, AudioInfoSupport &bi) {
    TRACED();
    setOutput(out_stream);
    addNotifyAudioChange(bi);
  }
  DecoderBasic(Print &out_stream, AudioInfoSupport &bi) {…}
 
  void setOutput(Print &out_stream) override {
    decoder.setOutput(out_stream);
  }
  void setOutput(Print &out_stream) override  {…}
 
  void addNotifyAudioChange(AudioInfoSupport &bi) override {
    decoder.addNotifyAudioChange(bi);
  }
  void addNotifyAudioChange(AudioInfoSupport &bi) override  {…}
 
  AudioInfo audioInfo() override { return decoder.audioInfo(); }
 
  bool begin(AudioInfo info) { 
    decoder.setAudioInfo(info);
    return decoder.begin(); 
  }
 
  bool begin() override {
    TRACED();
    return decoder.begin();
  }
 
  void end() override { decoder.end(); }
 
  virtual size_t write(const uint8_t *data, size_t len) override {
    return decoder.write((uint8_t *)data, len);
  }
 
  virtual operator bool() override { return decoder; }
 
protected:
  G711_ULAWDecoder decoder;
};
class DecoderBasic : public AudioDecoder {…};
 
class EncoderBasic : public AudioEncoder {
public:
  // Empty Constructor - the output stream must be provided with begin()
  EncoderBasic() {}
 
  // Constructor providing the output stream
  EncoderBasic(Print &out) { setOutput(out); }
 
  void setOutput(Print &out) override { encoder.setOutput(out); }
 
  const char *mime() override { return "audio/basic"; }
 
  virtual void setAudioInfo(AudioInfo from) override {
    AudioEncoder::setAudioInfo(from);
    encoder.setAudioInfo(from);
  }
  virtual void setAudioInfo(AudioInfo from) override  {…}
 
  bool begin() override { return encoder.begin(); }
 
  void end() override { encoder.end(); }
 
  virtual size_t write(const uint8_t *in_ptr, size_t in_size) override {
    return encoder.write((uint8_t *)in_ptr, in_size);
  }
  virtual size_t write(const uint8_t *in_ptr, size_t in_size) override  {…}
 
  operator bool() override {
    return encoder;
  }
 
  bool isOpen() { return encoder; }
 
protected:
  G711_ULAWEncoder encoder;
};
class EncoderBasic : public AudioEncoder {…};
 
} // namespace audio_tools