I2SStream.h

 
 
#pragma once
#include "AudioToolsConfig.h"
 
#if defined(USE_I2S)
 
#include "AudioTools/CoreAudio/AudioI2S/I2SConfig.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SESP32.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SESP32V1.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SESP8266.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SNanoSenseBLE.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SRP2040-MBED.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SRP2040.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SSAMD.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SSTM32.h"
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "AudioTools/CoreAudio/AudioTypes.h"
 
#if defined(IS_I2S_IMPLEMENTED)
 
namespace audio_tools {
 
class I2SStream : public AudioStream {
 public:
  I2SStream() = default;
  ~I2SStream() { end(); }
 
#ifdef ARDUINO
  I2SStream(int mute_pin) {
    TRACED();
    this->mute_pin = mute_pin;
    if (mute_pin > 0) {
      pinMode(mute_pin, OUTPUT);
      mute(true);
    }
  }
#endif
 
  I2SConfig defaultConfig(RxTxMode mode = TX_MODE) {
    return i2s.defaultConfig(mode);
  }
  I2SConfig defaultConfig(RxTxMode mode = TX_MODE) {…}
 
  bool begin() {
    TRACEI();
    I2SConfig cfg = i2s.config();
    if (!cfg){
      LOGE("unsuported AudioInfo: sample_rate: %d / channels: %d / bits_per_sample: %d", (int) cfg.sample_rate, (int)cfg.channels, (int)cfg.bits_per_sample);
      return false;
    }
    cfg.copyFrom(audioInfo());
    if (cfg.rx_tx_mode == UNDEFINED_MODE){
      cfg.rx_tx_mode = RXTX_MODE;
    }
    is_active = i2s.begin(cfg);
    mute(false);
    return is_active;
  }
 
  bool begin(I2SConfig cfg) {
    TRACED();
    if (!cfg){
      LOGE("unsuported AudioInfo: sample_rate: %d / channels: %d / bits_per_sample: %d", (int) cfg.sample_rate, (int)cfg.channels, (int)cfg.bits_per_sample);
      return false;
    }
    AudioStream::setAudioInfo(cfg);
    is_active = i2s.begin(cfg);
    // unmute
    mute(false);
    return is_active;
  }
  bool begin(I2SConfig cfg) {…}
 
  void end() {
    if (is_active) {
      TRACEI();
      is_active = false;
      mute(true);
      i2s.end();
    }
  }
  void end() {…}
 
  virtual void setAudioInfo(AudioInfo info) {
    TRACEI();
    assert(info.sample_rate != 0);
    assert(info.channels != 0);
    assert(info.bits_per_sample != 0);
    AudioStream::setAudioInfo(info);
    if (is_active) {
      if (!i2s.setAudioInfo(info)) {
        I2SConfig current_cfg = i2s.config();
        if (!info.equals(current_cfg)) {
          LOGI("restarting i2s");
          info.logInfo("I2SStream");
          i2s.end();
          current_cfg.copyFrom(info);
          i2s.begin(current_cfg);
        } else {
          LOGI("no change");
        }
      }
    }
  }
  virtual void setAudioInfo(AudioInfo info) {…}
 
  virtual size_t write(const uint8_t *data, size_t len) {
    LOGD("I2SStream::write: %d", len);
    if (data == nullptr || len == 0 || !is_active)  return 0;
    return i2s.writeBytes(data, len);
  }
  virtual size_t write(const uint8_t *data, size_t len) {…}
 
  virtual size_t readBytes(uint8_t *data, size_t len) override {
    return i2s.readBytes(data, len);
  }
  virtual size_t readBytes(uint8_t *data, size_t len) override  {…}
 
  virtual int available() override { return i2s.available(); }
 
  virtual int availableForWrite() override { return i2s.availableForWrite(); }
 
  void flush() override {}
 
  I2SDriver *driver() { return &i2s; }
 
  operator bool() override { return is_active; }
 
  bool isActive()  { return is_active;}
 
 protected:
  I2SDriver i2s;
  int mute_pin = -1;
  bool is_active = false;
 
  void mute(bool is_mute) {
#ifdef ARDUINO
    if (mute_pin > 0) {
      digitalWrite(mute_pin, is_mute ? SOFT_MUTE_VALUE : !SOFT_MUTE_VALUE);
    }
#endif
  }
  void mute(bool is_mute) {…}
};
class I2SStream : public AudioStream {…};
 
}  // namespace audio_tools
 
#endif
#endif