AudioCodecsBase.h

#pragma once
 
#include "AudioToolsConfig.h"
#include "AudioLogger.h"
#include "AudioTools/CoreAudio/AudioBasic/Collections/Vector.h"
#include "AudioTools/CoreAudio/AudioTypes.h"
#include "AudioTools/CoreAudio/BaseStream.h"
#include "AudioTools/CoreAudio/AudioOutput.h"
 
namespace audio_tools {
 
class AudioDecoder : public AudioWriter, public AudioInfoSource {
 public:
  AudioDecoder() = default;
  virtual ~AudioDecoder() = default;
  AudioDecoder(AudioDecoder const &) = delete;
  AudioDecoder &operator=(AudioDecoder const &) = delete;
 
  AudioInfo audioInfo() override { return info; };
 
  void setAudioInfo(AudioInfo from) override {
    TRACED();
    if (info != from) {
      notifyAudioChange(from);
    }
    info = from;
  }
  void setAudioInfo(AudioInfo from) override  {…}
  virtual void setOutput(AudioStream &out_stream) {
    Print *p_print = &out_stream;
    setOutput(*p_print);
    addNotifyAudioChange(out_stream);
  }
  virtual void setOutput(AudioStream &out_stream) {…}
 
  virtual void setOutput(AudioOutput &out_stream) {
    Print *p_print = &out_stream;
    setOutput(*p_print);
    addNotifyAudioChange(out_stream);
  }
  virtual void setOutput(AudioOutput &out_stream) {…}
 
  virtual void setOutput(Print &out_stream) override { p_print = &out_stream; }
 
  virtual bool isResultPCM() { return true; }
  virtual bool begin(AudioInfo info) override {
    setAudioInfo(info);
    return begin();
  }
  bool begin() override { return true; }
  void end() override {}
 
  int id;
 
  Print* getOutput(){
    return p_print;
  }
 
  virtual size_t writeCodecConfig(const uint8_t* data, size_t len){
    LOGE("not implemented");
    return 0;
  }
  virtual size_t writeCodecConfig(const uint8_t* data, size_t len) {…}
 
 protected:
  Print *p_print = nullptr;
  AudioInfo info;
};
class AudioDecoder : public AudioWriter, public AudioInfoSource {…};
 
class ContainerDecoder : public AudioDecoder {
  bool isResultPCM() override { return true; }
};
class ContainerDecoder : public AudioDecoder {…};
 
class AudioEncoder : public AudioWriter {
 public:
  AudioEncoder() = default;
  virtual ~AudioEncoder() = default;
  AudioEncoder(AudioEncoder const &) = delete;
  AudioEncoder &operator=(AudioEncoder const &) = delete;
  virtual const char *mime() = 0;
  void setAudioInfo(AudioInfo from) override { info = from; }
  AudioInfo audioInfo() override { return info; }
 
 protected:
  AudioInfo info;
};
class AudioEncoder : public AudioWriter {…};
 
class AudioDecoderExt : public AudioDecoder {
 public:
  virtual void setBlockSize(int blockSize) = 0;
};
class AudioDecoderExt : public AudioDecoder {…};
 
class AudioEncoderExt : public AudioEncoder {
 public:
  virtual int blockSize() = 0;
};
class AudioEncoderExt : public AudioEncoder {…};
 
class CodecNOP : public AudioDecoder, public AudioEncoder {
 public:
  static CodecNOP *instance() {
    static CodecNOP self;
    return &self;
  }
 
  virtual bool begin() { return true; }
  virtual void end() {}
  virtual void setOutput(Print &out_stream) {}
  virtual void addNotifyAudioChange(AudioInfoSupport &bi) {}
  virtual void setAudioInfo(AudioInfo info) {}
 
  virtual AudioInfo audioInfo() {
    AudioInfo info;
    return info;
  }
  virtual AudioInfo audioInfo() {…}
  virtual operator bool() { return false; }
  virtual int readStream(Stream &in) { return 0; };
 
  // just output silence
  virtual size_t write(const uint8_t *data, size_t len) {
    memset((void *)data, 0, len);
    return len;
  }
 
  virtual const char *mime() { return nullptr; }
};
class CodecNOP : public AudioDecoder, public AudioEncoder {…};
 
class StreamingDecoder : public AudioInfoSource {
 public:
  virtual bool begin() = 0;
 
  virtual void end() = 0;
 
  virtual void setOutput(Print &out_stream) { p_print = &out_stream; }
 
  virtual void setOutput(AudioStream &out_stream) {
    Print *p_print = &out_stream;
    setOutput(*p_print);
    addNotifyAudioChange(out_stream);
  }
  virtual void setOutput(AudioStream &out_stream) {…}
 
  virtual void setOutput(AudioOutput &out_stream) {
    Print *p_print = &out_stream;
    setOutput(*p_print);
    addNotifyAudioChange(out_stream);
  }
  virtual void setOutput(AudioOutput &out_stream) {…}
 
  void setInput(Stream &inStream) { this->p_input = &inStream; }
 
  virtual AudioInfo audioInfo() = 0;
 
  virtual operator bool() = 0;
 
  virtual bool copy() = 0;
 
  bool copyAll() {
    bool result = false;
    while (copy()) {
      result = true;
    }
    return result;
  }
  bool copyAll() {…}
 
 protected:
  virtual size_t readBytes(uint8_t *data, size_t len) = 0;
  Print *p_print = nullptr;
  Stream *p_input = nullptr;
};
class StreamingDecoder : public AudioInfoSource {…};
 
class StreamingDecoderAdapter : public StreamingDecoder {
 public:
  StreamingDecoderAdapter(AudioDecoder &decoder,
                          int copySize = DEFAULT_BUFFER_SIZE) {
    p_decoder = &decoder;
    if (copySize > 0) resize(copySize);
  }
  bool begin() override { return p_input != nullptr && p_decoder->begin(); }
 
  void end() override { p_decoder->end(); }
 
  void setOutput(Print &out_stream) override {
    p_decoder->setOutput(out_stream);
  }
  void setOutput(Print &out_stream) override  {…}
 
  AudioInfo audioInfo() override { return p_decoder->audioInfo(); }
 
  virtual operator bool() override { return *p_decoder; }
 
  virtual bool copy() override {
    int read = readBytes(&buffer[0], buffer.size());
    int written = 0;
    if (read > 0) written = p_decoder->write(&buffer[0], read);
    return written > 0;
  }
  virtual bool copy() override  {…}
 
  void resize(int bufferSize) { buffer.resize(bufferSize); }
 
 protected:
  AudioDecoder *p_decoder = nullptr;
  Vector<uint8_t> buffer{0};
 
  size_t readBytes(uint8_t *data, size_t len) override {
    if (p_input == nullptr) return 0;
    return p_input->readBytes(data, len);
  }
};
class StreamingDecoderAdapter : public StreamingDecoder {…};
 
}  // namespace audio_tools
namespace audio_tools {…}