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) {
      info = from;
      notifyAudioChange(from);
    }
  }
  virtual void setOutput(AudioStream &out_stream) {
    Print *p_print = &out_stream;
    setOutput(*p_print);
    addNotifyAudioChange(out_stream);
  }
 
  virtual void setOutput(AudioOutput &out_stream) {
    Print *p_print = &out_stream;
    setOutput(*p_print);
    addNotifyAudioChange(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 bool setCodecConfig(const uint8_t* data, size_t len){
    LOGE("not implemented");
    return false;
  }
 
 protected:
  Print *p_print = nullptr;
  AudioInfo info;
};
 
class ContainerDecoder : public AudioDecoder {
  bool isResultPCM() override { return true; }
};
 
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 AudioDecoderExt : public AudioDecoder {
 public:
  virtual void setBlockSize(int blockSize) = 0;
};
 
class AudioEncoderExt : public AudioEncoder {
 public:
  virtual int blockSize() = 0;
};
 
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 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; }
};
 
}  // namespace audio_tools