CodecL8.h

#pragma once
 
#include "AudioCodecs/AudioEncoded.h"
 
namespace audio_tools {
 
class DecoderL8 : public AudioDecoder {
 public:
  DecoderL8(bool isSigned = false) {
    TRACED();
    setSigned(isSigned);
  }
 
  DecoderL8(Print &out_stream, bool active = true) {
    TRACED();
    p_print = &out_stream;
  }
 
  DecoderL8(Print &out_stream, AudioInfoSupport &bi) {
    TRACED();
    setOutput(out_stream);
    addNotifyAudioChange(bi);
  }
 
  void setSigned(bool isSigned) { is_signed = isSigned; }
 
  virtual void setAudioInfo(AudioInfo from) override {
    TRACED();
    if (from.bits_per_sample!=16){
      LOGE("Bits per sample not supported: %d", from.bits_per_sample);
    }
    from.bits_per_sample = 16;
    if (info != from) {
      notifyAudioChange(from);
    }
    info = from;
  }
 
  virtual size_t write(const void *in_ptr, size_t in_size) override {
    if (p_print == nullptr) return 0;
    buffer.resize(in_size);
    memset(buffer.data(), 0, in_size * 2);
    if (is_signed) {
      int8_t *pt8 = (int8_t *)in_ptr;
      for (size_t j = 0; j < in_size; j++) {
        buffer[j] = convertSample(pt8[j]);
      }
    } else {
      uint8_t *pt8 = (uint8_t *)in_ptr;
      for (size_t j = 0; j < in_size; j++) {
        buffer[j] = convertSample(pt8[j]);
      }
    }
    int write_byte_count = in_size * sizeof(int16_t);
    size_t result = p_print->write((uint8_t *)buffer.data(), write_byte_count);
    LOGD("DecoderL8 %d -> %d -> %d", (int)in_size, write_byte_count, (int)result);
    return result / sizeof(int16_t);
  }
 
  int16_t convertSample(int16_t in) {
    int32_t tmp = in;
    if (!is_signed) {
      tmp -= 129;
    }
    return NumberConverter::clip<int16_t>(tmp * 258);
  }
 
  virtual operator bool() override { return p_print!=nullptr; }
 
 
 protected:
  bool is_signed = false;
  Vector<int16_t> buffer;
};
 
class EncoderL8 : public AudioEncoder {
 public:
  // Empty Constructor - the output stream must be provided with begin()
  EncoderL8(bool isSigned = false) {
    TRACED();
    setSigned(isSigned);
  }
 
  // Constructor providing the output stream
  EncoderL8(Print &out) { p_print = &out; }
 
  void setSigned(bool isSigned) { is_signed = isSigned; }
 
  void setOutput(Print &out_stream) override { p_print = &out_stream; }
 
  const char *mime() override { return "audio/l8"; }
 
  bool begin() override { is_open = true; return true;}
 
  bool begin(Print &out) {
    p_print = &out;
    return begin();
  }
 
  void end() override { is_open = false; }
 
  size_t write(const void *in_ptr, size_t in_size) override {
    if (p_print == nullptr) return 0;
    int16_t *pt16 = (int16_t *)in_ptr;
    size_t samples = in_size / 2;
    buffer.resize(samples);
    memset(buffer.data(), 0, samples);
    for (size_t j = 0; j < samples; j++) {
      buffer[j] = convertSample(pt16[j]);
    }
 
    size_t result = p_print->write((uint8_t *)buffer.data(), samples);
    LOGD("EncoderL8 %d -> %d -> %d", (int)in_size,(int) samples, (int)result);
    return result * sizeof(int16_t);
  }
 
  operator bool() override { return is_open; }
 
  int16_t convertSample(int16_t sample) {
    int16_t tmp = NumberConverter::clip<int8_t>(sample / 258);
    if (!is_signed) {
      tmp += 129;
      // clip to range
      if (tmp < 0) {
        tmp = 0;
      } else if (tmp > 255) {
        tmp = 255;
      }
    }
    return tmp;
  }
 
  bool isOpen() { return is_open; }
 
 protected:
  Print *p_print = nullptr;
  bool is_open;
  bool is_signed = false;
  Vector<int8_t> buffer;
};
 
}  // namespace audio_tools