I2SStream.h

Go to the documentation of this file.

 
 
#pragma once
#include "AudioToolsConfig.h"
 
#if defined(USE_I2S)
 
#include "AudioTools/CoreAudio/AudioI2S/I2SConfig.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverESP32.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverESP32V1.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverESP8266.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverZephyr.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverNanoSenseBLE.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverRP2040-MBED.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverRP2040.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverSAMD.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverSTM32.h"
#include "AudioTools/CoreAudio/AudioI2S/I2SDriverTangNano.h"
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "AudioTools/CoreAudio/AudioTypes.h"
 
#if defined(IS_I2S_IMPLEMENTED)
 
#ifndef SOFT_MUTE_VALUE
#  define SOFT_MUTE_VALUE 0
#endif
 
namespace audio_tools {
 
class I2SStream : public AudioStream {
 public:
  I2SStream() = default;
  I2SStream(I2SDriverBase &driver) { p_driver = &driver; }
  ~I2SStream() { end(); }
 
  I2SStream(digital_pin_t mute_pin) {
    TRACED();
    this->mute_pin = mute_pin;
    if (IS_GPIO(mute_pin)) {
      pinMode(mute_pin, OUTPUT);
      mute(true);
    }
  }
 
  I2SConfig defaultConfig(RxTxMode mode = TX_MODE) {
    return p_driver->defaultConfig(mode);
  }
 
  bool begin() {
    TRACEI();
    I2SConfig cfg = p_driver->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 = p_driver->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 = p_driver->begin(cfg);
    // unmute
    mute(false);
    return is_active;
  }
 
  void end() {
    if (is_active) {
      TRACEI();
      is_active = false;
      mute(true);
      p_driver->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 (!p_driver->setAudioInfo(info)) {
        I2SConfig current_cfg = p_driver->config();
        if (!info.equals(current_cfg)) {
          LOGI("restarting i2s");
          info.logInfo("I2SStream");
          p_driver->end();
          current_cfg.copyFrom(info);
          p_driver->begin(current_cfg);
        } else {
          LOGI("no change");
        }
      }
    }
  }
 
  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 p_driver->writeBytes(data, len);
  }
 
  virtual size_t readBytes(uint8_t *data, size_t len) override {
    return p_driver->readBytes(data, len);
  }
 
  virtual int available() override { return p_driver->available(); }
 
  virtual int availableForWrite() override { return p_driver->availableForWrite(); }
 
  void flush() override {
    if (is_active) p_driver->flush();
  }
 
  I2SDriverBase* driver() { return p_driver; }
 
  operator bool() override { return is_active; }
 
  bool isActive()  { return is_active;}
 
 protected:
  I2SDriver i2s;
  I2SDriverBase* p_driver = &i2s;
  bool is_active = false;
  digital_pin_t mute_pin = GPIO_NONE;
 
  void mute(bool is_mute) {
    if (IS_GPIO(mute_pin)) {
      digitalWrite(mute_pin, is_mute ? SOFT_MUTE_VALUE : !SOFT_MUTE_VALUE);
    }
  }
};
 
}  // namespace audio_tools
 
#endif
#endif