I2SCodecStream.h

Go to the documentation of this file.

#pragma once
#include "AudioBoard.h"  // install audio-driver library
#include "AudioToolsConfig.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SStream.h"
 
 
//#pragma GCC diagnostic ignored "-Wclass-memaccess"
 
// Added to be compatible with the AudioKitStream.h
#ifndef PIN_AUDIO_KIT_SD_CARD_CS
#define PIN_AUDIO_KIT_SD_CARD_CS 13
#define PIN_AUDIO_KIT_SD_CARD_MISO 2
#define PIN_AUDIO_KIT_SD_CARD_MOSI 15
#define PIN_AUDIO_KIT_SD_CARD_CLK 14
#endif
 
namespace audio_tools {
// we heavily depend on the audio driver functionality
using namespace audio_driver;
 
// The legacy class name was DriverPins
#if !defined(AUDIO_DRIVER_USE_NEW_API)
  using DriverDeviceInfo = DriverPins;
#endif
 

struct I2SCodecConfig : public I2SConfig {
  input_device_t input_device = ADC_INPUT_LINE1;
  output_device_t output_device = DAC_OUTPUT_ALL;
  // to be compatible with the AudioKitStream -> do not activate SD spi if false
  bool sd_active = true;
  bool sdmmc_active = false;
  // define pin source in driver configuration
  PinFunction i2s_function = PinFunction::UNDEFINED; //CODEC;
  bool operator==(I2SCodecConfig alt) {
    return input_device == alt.input_device &&
           output_device == alt.output_device && *((AudioInfo *)this) == alt;
  }
 
  bool operator!=(I2SCodecConfig alt) { return !(*this == alt); }
};

class I2SCodecStream : public AudioStream, public VolumeSupport {
 public:
  I2SCodecStream() = default;
  I2SCodecStream(AudioBoard &board) { setBoard(board); }
  I2SCodecStream(AudioBoard *board) { setBoard(board); }

  I2SCodecConfig defaultConfig(RxTxMode mode = TX_MODE) {
    auto cfg_default = i2s.defaultConfig(mode);
    I2SCodecConfig cfg;
    cfg.copyFrom(cfg_default);
    cfg.input_device = ADC_INPUT_LINE1;
    cfg.output_device = DAC_OUTPUT_ALL;
    cfg.sd_active = true;
    cfg.rx_tx_mode = mode;
    return cfg;
  }
 
  bool begin() {
    TRACED();
    return begin(cfg);
  }

  virtual bool begin(I2SCodecConfig cfg) {
    TRACED();
    this->cfg = cfg;
    this->info = cfg;
    return begin1();
  }

  void end() {
    TRACED();
    if (p_board) p_board->end();
    i2s.end();
    is_active = false;
  }

  virtual void setAudioInfo(AudioInfo info) {
    TRACEI();
    AudioStream::setAudioInfo(info);
    i2s.setAudioInfo(info);
 
    cfg.sample_rate = info.sample_rate;
    cfg.bits_per_sample = info.bits_per_sample;
    cfg.channels = info.channels;
 
    // update codec_cfg
    codec_cfg.i2s.bits = toCodecBits(cfg.bits_per_sample);
    codec_cfg.i2s.rate = toRate(cfg.sample_rate);
 
    // return if we we are not ready
    if (!is_active || p_board == nullptr) {
      return;
    }
 
    // return if there is nothing to do
    if (cfg.sample_rate == info.sample_rate &&
        cfg.bits_per_sample == info.bits_per_sample &&
        cfg.channels == info.channels) {
      return;
    }
 
    // update cfg
    p_board->setConfig(codec_cfg);
  }

  virtual size_t write(const uint8_t *data, size_t len) {
    LOGD("I2SStream::write: %d", len);
    return i2s.write(data, len);
  }

  virtual size_t readBytes(uint8_t *data, size_t len) override {
    return i2s.readBytes(data, len);
  }

  virtual int available() override { return i2s.available(); }

  virtual int availableForWrite() override { return i2s.availableForWrite(); }

  bool setVolume(float vol) override {
    VolumeSupport::setVolume(vol);
    if (!is_active || p_board == nullptr) return false;
    return p_board->setVolume(vol * 100.0);
  }

  float volume() override {
    if (p_board == nullptr) return 0.0f;
    return static_cast<float>(p_board->getVolume()) / 100.0f;
  }

  float getVolume()  { return volume(); }

  bool setMute(bool mute) {
    if (p_board == nullptr) return false;
    return p_board->setMute(mute);
  }

  bool setMute(bool mute, int line) {
    if (p_board == nullptr) return false;
    return p_board->setMute(mute, line);
  }

  bool setPAPower(bool active) {
    if (p_board == nullptr) return false;
    return p_board->setPAPower(active);
  }

  bool setInputVolume(float vol){
    if (!is_active || p_board == nullptr) return false;
    return p_board->setInputVolume(100.0 * vol);
  }

  AudioBoard &board() { return *p_board; }
  void setBoard(AudioBoard &board) { p_board = &board; }
  void setBoard(AudioBoard *board) { p_board = board; }
  bool hasBoard() { return p_board != nullptr; }

  digital_pin_t getPinID(PinFunction function) {
    if (p_board == nullptr) return GPIO_NONE;
    return p_board->getPins().getPinID(function);
  }

  digital_pin_t getPinID(PinFunction function, int pos) {
    if (p_board == nullptr) return GPIO_NONE;
    return p_board->getPins().getPinID(function, pos);
  }

  digital_pin_t getKey(int pos) { return getPinID(PinFunction::KEY, pos); }

  DriverDeviceInfo &getPins() { return p_board->getPins(); }

  I2SDriverBase* driver() { return i2s.driver(); }

  void digitalWrite(digital_pin_t pin, bool value) {
    p_board->getPins().getGPIO().digitalWrite(pin, value);
  }

  bool digitalRead(digital_pin_t pin) {
    return p_board->getPins().getGPIO().digitalRead(pin);
  }
 
 protected:
  I2SStream i2s;
  I2SCodecConfig cfg;
  CodecConfig codec_cfg;
  AudioBoard *p_board = nullptr;
  bool is_active = false;
 
  bool begin1() {
    TRACED();
    setupI2SFunction();
    setupI2SPins();
 
    if (!i2s.begin(cfg)){
      TRACEE();
      is_active = false;
      return false;
    }
 
    delay(200); // wait for codec to be ready
 
    if (!beginCodec(cfg)) {
      TRACEE();
      is_active = false;
      return false;
    }
 
    // setVolume()/setMute()/setAudioInfo() all gate on is_active - without
    // this, they silently no-op forever (including the cached-volume
    // reapply right below), regardless of whether the caller sets the
    // volume before or after begin().
    is_active = true;
 
    // if setvolume was called before begin
    float tobeVol = VolumeSupport::volume();
    if (tobeVol >= 0.0f) {
      setVolume(tobeVol);
    }
    return true;
  }

  void setupI2SFunction() {
    if (cfg.i2s_function == PinFunction::UNDEFINED){
      if (cfg.rx_tx_mode == RX_MODE){
          auto i2s = p_board->getPins().getI2SPins(PinFunction::CODEC_ADC);
          if (i2s){
            cfg.i2s_function = PinFunction::CODEC_ADC;
            LOGI("using i2s_function: CODEC_ADC");
          } else {
            cfg.i2s_function = PinFunction::CODEC;
          }
      } else {
          cfg.i2s_function = PinFunction::CODEC;
      }
    }
  }

  void setupI2SPins() {
    TRACED();
    // determine relevant I2S pins from driver configuration
    auto i2s = getI2SPins();
    if (i2s) {
      // determine i2s pins from board definition
      PinsI2S i2s_pins = i2s.value();
#if defined(__zephyr__)
      // use device from audio-driver library
      if (i2s_pins.dev != nullptr){
        cfg.dev = i2s_pins.dev;
      }
#else
      cfg.pin_bck = i2s_pins.bck;
      cfg.pin_mck = i2s_pins.mclk;
      cfg.pin_ws = i2s_pins.ws;
      switch (cfg.rx_tx_mode) {
        case RX_MODE:
          cfg.pin_data = i2s_pins.data_in;
          break;
        case TX_MODE:
          cfg.pin_data = i2s_pins.data_out;
          break;
        default:
          cfg.pin_data = i2s_pins.data_out;
          cfg.pin_data_rx = i2s_pins.data_in;
          break;
      }
#endif
    }
  }
 
  audio_driver_local::Optional<PinsI2S> getI2SPins(){
    TRACED();
     audio_driver_local::Optional<PinsI2S> i2s;
    // Deterine I2S pins
    return  p_board->getPins().getI2SPins(cfg.i2s_function);
  }
 
  bool beginCodec(I2SCodecConfig info) {
    TRACED();
    switch (cfg.rx_tx_mode) {
      case RX_MODE:
        codec_cfg.input_device = info.input_device;
        codec_cfg.output_device = DAC_OUTPUT_NONE;
        break;
      case TX_MODE:
        codec_cfg.output_device = info.output_device;
        codec_cfg.input_device = ADC_INPUT_NONE;
        break;
      default:
        codec_cfg.input_device = info.input_device;
        codec_cfg.output_device = info.output_device;
        break;
    }
    codec_cfg.sd_active = info.sd_active;
    codec_cfg.sdmmc_active = info.sdmmc_active;
    LOGD("input: %d", info.input_device);
    LOGD("output: %d", info.output_device);
    codec_cfg.i2s.bits = toCodecBits(info.bits_per_sample);
    codec_cfg.i2s.rate = toRate(info.sample_rate);
    codec_cfg.i2s.fmt = toFormat(info.i2s_format);
#ifndef __zephyr__
    codec_cfg.i2s.signal_type = (signal_t) info.signal_type;
#endif
    // use reverse logic for codec setting
    codec_cfg.i2s.mode = info.is_master ? MODE_SLAVE : MODE_MASTER;
    if (p_board == nullptr) return false;
 
    // setup driver only on changes
    return p_board->begin(codec_cfg);
  }
 
  sample_bits_t toCodecBits(int bits) {
    switch (bits) {
      case 16:
        LOGD("BIT_LENGTH_16BITS");
        return BIT_LENGTH_16BITS;
      case 24:
        LOGD("BIT_LENGTH_24BITS");
        return BIT_LENGTH_24BITS;
      case 32:
        LOGD("BIT_LENGTH_32BITS");
        return BIT_LENGTH_32BITS;
    }
    LOGE("Unsupported bits: %d", bits);
    return BIT_LENGTH_16BITS;
  }
  samplerate_t toRate(int rate) {
    if (rate <= 8000) {
      LOGD("RATE_8K");
      return RATE_8K;
    }
    if (rate <= 11000) {
      LOGD("RATE_11K");
      return RATE_11K;
    }
    if (rate <= 16000) {
      LOGD("RATE_16K");
      return RATE_16K;
    }
    if (rate <= 22050) {
      LOGD("RATE_22K");
      return RATE_22K;
    }
    if (rate <= 32000) {
      LOGD("RATE_32K");
      return RATE_32K;
    }
    if (rate <= 44100) {
      LOGD("RATE_44K");
      return RATE_44K;
    }
    if (rate <= 48000 || rate > 48000) {
      LOGD("RATE_48K");
      return RATE_48K;
    }
    LOGE("Invalid rate: %d using 44K", rate);
    return RATE_44K;
  }
 
  i2s_format_t toFormat(I2SFormat fmt) {
    switch (fmt) {
      case I2S_PHILIPS_FORMAT:
      case I2S_STD_FORMAT:
        LOGD("I2S_NORMAL");
        return I2S_NORMAL;
      case I2S_LEFT_JUSTIFIED_FORMAT:
      case I2S_MSB_FORMAT:
        LOGD("I2S_LEFT");
        return I2S_LEFT;
      case I2S_RIGHT_JUSTIFIED_FORMAT:
      case I2S_LSB_FORMAT:
        LOGD("I2S_RIGHT");
        return I2S_RIGHT;
      case I2S_PCM:
        LOGD("I2S_DSP");
        return I2S_DSP;
      default:
        LOGE("unsupported mode");
        return I2S_NORMAL;
    }
  }
};
 
}  // namespace audio_tools