esphome 2025.4.2__py3-none-any.whl → 2025.5.0b3__py3-none-any.whl

esphome/components/i2s_audio/microphone/i2s_audio_microphone.cpp

@@ -2,20 +2,46 @@
 
 #ifdef USE_ESP32
 
+#ifdef USE_I2S_LEGACY
 #include <driver/i2s.h>
+#else
+#include <driver/i2s_std.h>
+#include <driver/i2s_pdm.h>
+#endif
 
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 
+#include "esphome/components/audio/audio.h"
+
 namespace esphome {
 namespace i2s_audio {
 
-static const size_t BUFFER_SIZE = 512;
+static const UBaseType_t MAX_LISTENERS = 16;
+
+static const uint32_t READ_DURATION_MS = 16;
+
+static const size_t TASK_STACK_SIZE = 4096;
+static const ssize_t TASK_PRIORITY = 23;
+
+// Use an exponential moving average to correct a DC offset with weight factor 1/1000
+static const int32_t DC_OFFSET_MOVING_AVERAGE_COEFFICIENT_DENOMINATOR = 1000;
 
 static const char *const TAG = "i2s_audio.microphone";
 
+enum MicrophoneEventGroupBits : uint32_t {
+  COMMAND_STOP = (1 << 0),  // stops the microphone task
+  TASK_STARTING = (1 << 10),
+  TASK_RUNNING = (1 << 11),
+  TASK_STOPPING = (1 << 12),
+  TASK_STOPPED = (1 << 13),
+
+  ALL_BITS = 0x00FFFFFF,  // All valid FreeRTOS event group bits
+};
+
 void I2SAudioMicrophone::setup() {
   ESP_LOGCONFIG(TAG, "Setting up I2S Audio Microphone...");
+#ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
   if (this->adc_) {
     if (this->parent_->get_port() != I2S_NUM_0) {
@@ -24,6 +50,7 @@ void I2SAudioMicrophone::setup() {
       return;
     }
   } else
+#endif
 #endif
   {
     if (this->pdm_) {
@@ -34,19 +61,75 @@ void I2SAudioMicrophone::setup() {
       }
     }
   }
+
+  this->active_listeners_semaphore_ = xSemaphoreCreateCounting(MAX_LISTENERS, MAX_LISTENERS);
+  if (this->active_listeners_semaphore_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to create semaphore");
+    this->mark_failed();
+    return;
+  }
+
+  this->event_group_ = xEventGroupCreate();
+  if (this->event_group_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to create event group");
+    this->mark_failed();
+    return;
+  }
+
+  this->configure_stream_settings_();
+}
+
+void I2SAudioMicrophone::configure_stream_settings_() {
+  uint8_t channel_count = 1;
+#ifdef USE_I2S_LEGACY
+  uint8_t bits_per_sample = this->bits_per_sample_;
+
+  if (this->channel_ == I2S_CHANNEL_FMT_RIGHT_LEFT) {
+    channel_count = 2;
+  }
+#else
+  uint8_t bits_per_sample = 16;
+  if (this->slot_bit_width_ != I2S_SLOT_BIT_WIDTH_AUTO) {
+    bits_per_sample = this->slot_bit_width_;
+  }
+
+  if (this->slot_mode_ == I2S_SLOT_MODE_STEREO) {
+    channel_count = 2;
+  }
+#endif
+
+#ifdef USE_ESP32_VARIANT_ESP32
+  // ESP32 reads audio aligned to a multiple of 2 bytes. For example, if configured for 24 bits per sample, then it will
+  // produce 32 bits per sample, where the actual data is in the most significant bits. Other ESP32 variants produce 24
+  // bits per sample in this situation.
+  if (bits_per_sample < 16) {
+    bits_per_sample = 16;
+  } else if ((bits_per_sample > 16) && (bits_per_sample <= 32)) {
+    bits_per_sample = 32;
+  }
+#endif
+
+  if (this->pdm_) {
+    bits_per_sample = 16;  // PDM mics are always 16 bits per sample
+  }
+
+  this->audio_stream_info_ = audio::AudioStreamInfo(bits_per_sample, channel_count, this->sample_rate_);
 }
 
 void I2SAudioMicrophone::start() {
   if (this->is_failed())
     return;
-  if (this->state_ == microphone::STATE_RUNNING)
-    return;  // Already running
-  this->state_ = microphone::STATE_STARTING;
+
+  xSemaphoreTake(this->active_listeners_semaphore_, 0);
 }
-void I2SAudioMicrophone::start_() {
+
+bool I2SAudioMicrophone::start_driver_() {
   if (!this->parent_->try_lock()) {
-    return;  // Waiting for another i2s to return lock
+    return false;  // Waiting for another i2s to return lock
   }
+  esp_err_t err;
+
+#ifdef USE_I2S_LEGACY
   i2s_driver_config_t config = {
       .mode = (i2s_mode_t) (this->i2s_mode_ | I2S_MODE_RX),
       .sample_rate = this->sample_rate_,
@@ -55,16 +138,14 @@ void I2SAudioMicrophone::start_() {
       .communication_format = I2S_COMM_FORMAT_STAND_I2S,
       .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
       .dma_buf_count = 4,
-      .dma_buf_len = 256,
+      .dma_buf_len = 240,  // Must be divisible by 3 to support 24 bits per sample on old driver and newer variants
       .use_apll = this->use_apll_,
       .tx_desc_auto_clear = false,
       .fixed_mclk = 0,
-      .mclk_multiple = I2S_MCLK_MULTIPLE_256,
+      .mclk_multiple = this->mclk_multiple_,
       .bits_per_chan = this->bits_per_channel_,
   };
 
-  esp_err_t err;
-
 #if SOC_I2S_SUPPORTS_ADC
   if (this->adc_) {
     config.mode = (i2s_mode_t) (config.mode | I2S_MODE_ADC_BUILT_IN);
@@ -72,20 +153,20 @@ void I2SAudioMicrophone::start_() {
     if (err != ESP_OK) {
       ESP_LOGW(TAG, "Error installing I2S driver: %s", esp_err_to_name(err));
       this->status_set_error();
-      return;
+      return false;
     }
 
     err = i2s_set_adc_mode(ADC_UNIT_1, this->adc_channel_);
     if (err != ESP_OK) {
       ESP_LOGW(TAG, "Error setting ADC mode: %s", esp_err_to_name(err));
       this->status_set_error();
-      return;
+      return false;
     }
     err = i2s_adc_enable(this->parent_->get_port());
     if (err != ESP_OK) {
       ESP_LOGW(TAG, "Error enabling ADC: %s", esp_err_to_name(err));
       this->status_set_error();
-      return;
+      return false;
     }
 
   } else
@@ -98,7 +179,7 @@ void I2SAudioMicrophone::start_() {
     if (err != ESP_OK) {
       ESP_LOGW(TAG, "Error installing I2S driver: %s", esp_err_to_name(err));
       this->status_set_error();
-      return;
+      return false;
     }
 
     i2s_pin_config_t pin_config = this->parent_->get_pin_config();
@@ -108,26 +189,122 @@ void I2SAudioMicrophone::start_() {
     if (err != ESP_OK) {
       ESP_LOGW(TAG, "Error setting I2S pin: %s", esp_err_to_name(err));
       this->status_set_error();
-      return;
+      return false;
+    }
+  }
+#else
+  i2s_chan_config_t chan_cfg = {
+      .id = this->parent_->get_port(),
+      .role = this->i2s_role_,
+      .dma_desc_num = 4,
+      .dma_frame_num = 256,
+      .auto_clear = false,
+  };
+  /* Allocate a new RX channel and get the handle of this channel */
+  err = i2s_new_channel(&chan_cfg, NULL, &this->rx_handle_);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "Error creating new I2S channel: %s", esp_err_to_name(err));
+    this->status_set_error();
+    return false;
+  }
+
+  i2s_clock_src_t clk_src = I2S_CLK_SRC_DEFAULT;
+#ifdef I2S_CLK_SRC_APLL
+  if (this->use_apll_) {
+    clk_src = I2S_CLK_SRC_APLL;
+  }
+#endif
+  i2s_std_gpio_config_t pin_config = this->parent_->get_pin_config();
+#if SOC_I2S_SUPPORTS_PDM_RX
+  if (this->pdm_) {
+    i2s_pdm_rx_clk_config_t clk_cfg = {
+        .sample_rate_hz = this->sample_rate_,
+        .clk_src = clk_src,
+        .mclk_multiple = this->mclk_multiple_,
+        .dn_sample_mode = I2S_PDM_DSR_8S,
+    };
+
+    i2s_pdm_rx_slot_config_t slot_cfg = I2S_PDM_RX_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, this->slot_mode_);
+    switch (this->std_slot_mask_) {
+      case I2S_STD_SLOT_LEFT:
+        slot_cfg.slot_mask = I2S_PDM_SLOT_LEFT;
+        break;
+      case I2S_STD_SLOT_RIGHT:
+        slot_cfg.slot_mask = I2S_PDM_SLOT_RIGHT;
+        break;
+      case I2S_STD_SLOT_BOTH:
+        slot_cfg.slot_mask = I2S_PDM_SLOT_BOTH;
+        break;
     }
+
+    /* Init the channel into PDM RX mode */
+    i2s_pdm_rx_config_t pdm_rx_cfg = {
+        .clk_cfg = clk_cfg,
+        .slot_cfg = slot_cfg,
+        .gpio_cfg =
+            {
+                .clk = pin_config.ws,
+                .din = this->din_pin_,
+                .invert_flags =
+                    {
+                        .clk_inv = pin_config.invert_flags.ws_inv,
+                    },
+            },
+    };
+    err = i2s_channel_init_pdm_rx_mode(this->rx_handle_, &pdm_rx_cfg);
+  } else
+#endif
+  {
+    i2s_std_clk_config_t clk_cfg = {
+        .sample_rate_hz = this->sample_rate_,
+        .clk_src = clk_src,
+        .mclk_multiple = this->mclk_multiple_,
+    };
+    i2s_std_slot_config_t std_slot_cfg =
+        I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) this->slot_bit_width_, this->slot_mode_);
+    std_slot_cfg.slot_bit_width = this->slot_bit_width_;
+    std_slot_cfg.slot_mask = this->std_slot_mask_;
+
+    pin_config.din = this->din_pin_;
+
+    i2s_std_config_t std_cfg = {
+        .clk_cfg = clk_cfg,
+        .slot_cfg = std_slot_cfg,
+        .gpio_cfg = pin_config,
+    };
+    /* Initialize the channel */
+    err = i2s_channel_init_std_mode(this->rx_handle_, &std_cfg);
   }
-  this->state_ = microphone::STATE_RUNNING;
-  this->high_freq_.start();
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "Error initializing I2S channel: %s", esp_err_to_name(err));
+    this->status_set_error();
+    return false;
+  }
+
+  /* Before reading data, start the RX channel first */
+  i2s_channel_enable(this->rx_handle_);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "Error enabling I2S Microphone: %s", esp_err_to_name(err));
+    this->status_set_error();
+    return false;
+  }
+#endif
+
   this->status_clear_error();
+  this->configure_stream_settings_();  // redetermine the settings in case some settings were changed after compilation
+  return true;
 }
 
 void I2SAudioMicrophone::stop() {
   if (this->state_ == microphone::STATE_STOPPED || this->is_failed())
     return;
-  if (this->state_ == microphone::STATE_STARTING) {
-    this->state_ = microphone::STATE_STOPPED;
-    return;
-  }
-  this->state_ = microphone::STATE_STOPPING;
+
+  xSemaphoreGive(this->active_listeners_semaphore_);
 }
 
-void I2SAudioMicrophone::stop_() {
+void I2SAudioMicrophone::stop_driver_() {
   esp_err_t err;
+#ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
   if (this->adc_) {
     err = i2s_adc_disable(this->parent_->get_port());
@@ -150,68 +327,181 @@ void I2SAudioMicrophone::stop_() {
     this->status_set_error();
     return;
   }
+#else
+  /* Have to stop the channel before deleting it */
+  err = i2s_channel_disable(this->rx_handle_);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "Error stopping I2S microphone: %s", esp_err_to_name(err));
+    this->status_set_error();
+    return;
+  }
+  /* If the handle is not needed any more, delete it to release the channel resources */
+  err = i2s_del_channel(this->rx_handle_);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "Error deleting I2S channel: %s", esp_err_to_name(err));
+    this->status_set_error();
+    return;
+  }
+#endif
   this->parent_->unlock();
-  this->state_ = microphone::STATE_STOPPED;
-  this->high_freq_.stop();
   this->status_clear_error();
 }
 
-size_t I2SAudioMicrophone::read(int16_t *buf, size_t len) {
+void I2SAudioMicrophone::mic_task(void *params) {
+  I2SAudioMicrophone *this_microphone = (I2SAudioMicrophone *) params;
+
+  xEventGroupSetBits(this_microphone->event_group_, MicrophoneEventGroupBits::TASK_STARTING);
+
+  uint8_t start_counter = 0;
+  bool started = this_microphone->start_driver_();
+  while (!started && start_counter < 10) {
+    // Attempt to load the driver again in 100 ms. Doesn't slow down main loop since its in a task.
+    vTaskDelay(pdMS_TO_TICKS(100));
+    ++start_counter;
+    started = this_microphone->start_driver_();
+  }
+
+  if (started) {
+    xEventGroupSetBits(this_microphone->event_group_, MicrophoneEventGroupBits::TASK_RUNNING);
+    const size_t bytes_to_read = this_microphone->audio_stream_info_.ms_to_bytes(READ_DURATION_MS);
+    std::vector<uint8_t> samples;
+    samples.reserve(bytes_to_read);
+
+    while (!(xEventGroupGetBits(this_microphone->event_group_) & COMMAND_STOP)) {
+      if (this_microphone->data_callbacks_.size() > 0) {
+        samples.resize(bytes_to_read);
+        size_t bytes_read = this_microphone->read_(samples.data(), bytes_to_read, 2 * pdMS_TO_TICKS(READ_DURATION_MS));
+        samples.resize(bytes_read);
+        if (this_microphone->correct_dc_offset_) {
+          this_microphone->fix_dc_offset_(samples);
+        }
+        this_microphone->data_callbacks_.call(samples);
+      } else {
+        vTaskDelay(pdMS_TO_TICKS(READ_DURATION_MS));
+      }
+    }
+  }
+
+  xEventGroupSetBits(this_microphone->event_group_, MicrophoneEventGroupBits::TASK_STOPPING);
+  this_microphone->stop_driver_();
+
+  xEventGroupSetBits(this_microphone->event_group_, MicrophoneEventGroupBits::TASK_STOPPED);
+  while (true) {
+    // Continuously delay until the loop method deletes the task
+    vTaskDelay(pdMS_TO_TICKS(10));
+  }
+}
+
+void I2SAudioMicrophone::fix_dc_offset_(std::vector<uint8_t> &data) {
+  const size_t bytes_per_sample = this->audio_stream_info_.samples_to_bytes(1);
+  const uint32_t total_samples = this->audio_stream_info_.bytes_to_samples(data.size());
+
+  if (total_samples == 0) {
+    return;
+  }
+
+  int64_t offset_accumulator = 0;
+  for (uint32_t sample_index = 0; sample_index < total_samples; ++sample_index) {
+    const uint32_t byte_index = sample_index * bytes_per_sample;
+    int32_t sample = audio::unpack_audio_sample_to_q31(&data[byte_index], bytes_per_sample);
+    offset_accumulator += sample;
+    sample -= this->dc_offset_;
+    audio::pack_q31_as_audio_sample(sample, &data[byte_index], bytes_per_sample);
+  }
+
+  const int32_t new_offset = offset_accumulator / total_samples;
+  this->dc_offset_ = new_offset / DC_OFFSET_MOVING_AVERAGE_COEFFICIENT_DENOMINATOR +
+                     (DC_OFFSET_MOVING_AVERAGE_COEFFICIENT_DENOMINATOR - 1) * this->dc_offset_ /
+                         DC_OFFSET_MOVING_AVERAGE_COEFFICIENT_DENOMINATOR;
+}
+
+size_t I2SAudioMicrophone::read_(uint8_t *buf, size_t len, TickType_t ticks_to_wait) {
   size_t bytes_read = 0;
-  esp_err_t err = i2s_read(this->parent_->get_port(), buf, len, &bytes_read, (100 / portTICK_PERIOD_MS));
-  if (err != ESP_OK) {
+#ifdef USE_I2S_LEGACY
+  esp_err_t err = i2s_read(this->parent_->get_port(), buf, len, &bytes_read, ticks_to_wait);
+#else
+  // i2s_channel_read expects the timeout value in ms, not ticks
+  esp_err_t err = i2s_channel_read(this->rx_handle_, buf, len, &bytes_read, pdTICKS_TO_MS(ticks_to_wait));
+#endif
+  if ((err != ESP_OK) && ((err != ESP_ERR_TIMEOUT) || (ticks_to_wait != 0))) {
+    // Ignore ESP_ERR_TIMEOUT if ticks_to_wait = 0, as it will read the data on the next call
     ESP_LOGW(TAG, "Error reading from I2S microphone: %s", esp_err_to_name(err));
     this->status_set_warning();
     return 0;
   }
-  if (bytes_read == 0) {
+  if ((bytes_read == 0) && (ticks_to_wait > 0)) {
     this->status_set_warning();
     return 0;
   }
   this->status_clear_warning();
-  // ESP-IDF I2S implementation right-extends 8-bit data to 16 bits,
-  // and 24-bit data to 32 bits.
-  switch (this->bits_per_sample_) {
-    case I2S_BITS_PER_SAMPLE_8BIT:
-    case I2S_BITS_PER_SAMPLE_16BIT:
-      return bytes_read;
-    case I2S_BITS_PER_SAMPLE_24BIT:
-    case I2S_BITS_PER_SAMPLE_32BIT: {
-      size_t samples_read = bytes_read / sizeof(int32_t);
-      for (size_t i = 0; i < samples_read; i++) {
-        int32_t temp = reinterpret_cast<int32_t *>(buf)[i] >> 14;
-        buf[i] = clamp<int16_t>(temp, INT16_MIN, INT16_MAX);
-      }
-      return samples_read * sizeof(int16_t);
+#if defined(USE_ESP32_VARIANT_ESP32) and not defined(USE_I2S_LEGACY)
+  // For ESP32 8/16 bit standard mono mode samples need to be switched.
+  if (this->slot_mode_ == I2S_SLOT_MODE_MONO && this->slot_bit_width_ <= 16 && !this->pdm_) {
+    size_t samples_read = bytes_read / sizeof(int16_t);
+    for (int i = 0; i < samples_read; i += 2) {
+      int16_t tmp = buf[i];
+      buf[i] = buf[i + 1];
+      buf[i + 1] = tmp;
     }
-    default:
-      ESP_LOGE(TAG, "Unsupported bits per sample: %d", this->bits_per_sample_);
-      return 0;
   }
-}
-
-void I2SAudioMicrophone::read_() {
-  std::vector<int16_t> samples;
-  samples.resize(BUFFER_SIZE);
-  size_t bytes_read = this->read(samples.data(), BUFFER_SIZE / sizeof(int16_t));
-  samples.resize(bytes_read / sizeof(int16_t));
-  this->data_callbacks_.call(samples);
+#endif
+  return bytes_read;
 }
 
 void I2SAudioMicrophone::loop() {
+  uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
+
+  if (event_group_bits & MicrophoneEventGroupBits::TASK_STARTING) {
+    ESP_LOGD(TAG, "Task has started, attempting to setup I2S audio driver");
+    xEventGroupClearBits(this->event_group_, MicrophoneEventGroupBits::TASK_STARTING);
+  }
+
+  if (event_group_bits & MicrophoneEventGroupBits::TASK_RUNNING) {
+    ESP_LOGD(TAG, "Task is running and reading data");
+
+    xEventGroupClearBits(this->event_group_, MicrophoneEventGroupBits::TASK_RUNNING);
+    this->state_ = microphone::STATE_RUNNING;
+  }
+
+  if (event_group_bits & MicrophoneEventGroupBits::TASK_STOPPING) {
+    ESP_LOGD(TAG, "Task is stopping, attempting to unload the I2S audio driver");
+    xEventGroupClearBits(this->event_group_, MicrophoneEventGroupBits::TASK_STOPPING);
+  }
+
+  if ((event_group_bits & MicrophoneEventGroupBits::TASK_STOPPED)) {
+    ESP_LOGD(TAG, "Task is finished, freeing resources");
+    vTaskDelete(this->task_handle_);
+    this->task_handle_ = nullptr;
+    xEventGroupClearBits(this->event_group_, ALL_BITS);
+    this->state_ = microphone::STATE_STOPPED;
+  }
+
+  if ((uxSemaphoreGetCount(this->active_listeners_semaphore_) < MAX_LISTENERS) &&
+      (this->state_ == microphone::STATE_STOPPED)) {
+    this->state_ = microphone::STATE_STARTING;
+  }
+  if ((uxSemaphoreGetCount(this->active_listeners_semaphore_) == MAX_LISTENERS) &&
+      (this->state_ == microphone::STATE_RUNNING)) {
+    this->state_ = microphone::STATE_STOPPING;
+  }
+
   switch (this->state_) {
-    case microphone::STATE_STOPPED:
-      break;
     case microphone::STATE_STARTING:
-      this->start_();
+      if ((this->task_handle_ == nullptr) && !this->status_has_error()) {
+        xTaskCreate(I2SAudioMicrophone::mic_task, "mic_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
+                    &this->task_handle_);
+
+        if (this->task_handle_ == nullptr) {
+          this->status_momentary_error("Task failed to start, attempting again in 1 second", 1000);
+        }
+      }
       break;
     case microphone::STATE_RUNNING:
-      if (this->data_callbacks_.size() > 0) {
-        this->read_();
-      }
       break;
     case microphone::STATE_STOPPING:
-      this->stop_();
+      xEventGroupSetBits(this->event_group_, MicrophoneEventGroupBits::COMMAND_STOP);
+      break;
+    case microphone::STATE_STOPPED:
       break;
   }
 }

esphome/components/i2s_audio/microphone/i2s_audio_microphone.h

@@ -7,6 +7,11 @@
 #include "esphome/components/microphone/microphone.h"
 #include "esphome/core/component.h"
 
+#include <freertos/FreeRTOS.h>
+#include <freertos/event_groups.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
 namespace esphome {
 namespace i2s_audio {
 
@@ -18,31 +23,60 @@ class I2SAudioMicrophone : public I2SAudioIn, public microphone::Microphone, pub
 
   void loop() override;
 
+  void set_correct_dc_offset(bool correct_dc_offset) { this->correct_dc_offset_ = correct_dc_offset; }
+
+#ifdef USE_I2S_LEGACY
   void set_din_pin(int8_t pin) { this->din_pin_ = pin; }
-  void set_pdm(bool pdm) { this->pdm_ = pdm; }
+#else
+  void set_din_pin(int8_t pin) { this->din_pin_ = (gpio_num_t) pin; }
+#endif
 
-  size_t read(int16_t *buf, size_t len) override;
+  void set_pdm(bool pdm) { this->pdm_ = pdm; }
 
+#ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
   void set_adc_channel(adc1_channel_t channel) {
     this->adc_channel_ = channel;
     this->adc_ = true;
   }
+#endif
 #endif
 
  protected:
-  void start_();
-  void stop_();
-  void read_();
+  bool start_driver_();
+  void stop_driver_();
+
+  /// @brief Attempts to correct a microphone DC offset; e.g., a microphones silent level is offset from 0. Applies a
+  /// correction offset that is updated using an exponential moving average for all samples away from 0.
+  /// @param data
+  void fix_dc_offset_(std::vector<uint8_t> &data);
 
+  size_t read_(uint8_t *buf, size_t len, TickType_t ticks_to_wait);
+
+  /// @brief Sets the Microphone ``audio_stream_info_`` member variable to the configured I2S settings.
+  void configure_stream_settings_();
+
+  static void mic_task(void *params);
+
+  SemaphoreHandle_t active_listeners_semaphore_{nullptr};
+  EventGroupHandle_t event_group_{nullptr};
+
+  TaskHandle_t task_handle_{nullptr};
+
+#ifdef USE_I2S_LEGACY
   int8_t din_pin_{I2S_PIN_NO_CHANGE};
 #if SOC_I2S_SUPPORTS_ADC
   adc1_channel_t adc_channel_{ADC1_CHANNEL_MAX};
   bool adc_{false};
+#endif
+#else
+  gpio_num_t din_pin_{I2S_GPIO_UNUSED};
+  i2s_chan_handle_t rx_handle_;
 #endif
   bool pdm_{false};
 
-  HighFrequencyLoopRequester high_freq_;
+  bool correct_dc_offset_;
+  int32_t dc_offset_{0};
 };
 
 }  // namespace i2s_audio

esphome/components/i2s_audio/speaker/__init__.py

@@ -26,6 +26,8 @@ from .. import (
     i2s_audio_component_schema,
     i2s_audio_ns,
     register_i2s_audio_component,
+    use_legacy,
+    validate_mclk_divisible_by_3,
 )
 
 AUTO_LOAD = ["audio"]
@@ -60,7 +62,7 @@ I2C_COMM_FMT_OPTIONS = {
     "pcm_long": i2s_comm_format_t.I2S_COMM_FORMAT_PCM_LONG,
 }
 
-NO_INTERNAL_DAC_VARIANTS = [esp32.const.VARIANT_ESP32S2]
+INTERNAL_DAC_VARIANTS = [esp32.const.VARIANT_ESP32]
 
 
 def _set_num_channels_from_config(config):
@@ -101,7 +103,7 @@ def _validate_esp32_variant(config):
     if config[CONF_DAC_TYPE] != "internal":
         return config
     variant = esp32.get_esp32_variant()
-    if variant in NO_INTERNAL_DAC_VARIANTS:
+    if variant not in INTERNAL_DAC_VARIANTS:
         raise cv.Invalid(f"{variant} does not have an internal DAC")
     return config
 
@@ -143,8 +145,8 @@ CONFIG_SCHEMA = cv.All(
                     cv.Required(
                         CONF_I2S_DOUT_PIN
                     ): pins.internal_gpio_output_pin_number,
-                    cv.Optional(CONF_I2S_COMM_FMT, default="stand_i2s"): cv.enum(
-                        I2C_COMM_FMT_OPTIONS, lower=True
+                    cv.Optional(CONF_I2S_COMM_FMT, default="stand_i2s"): cv.one_of(
+                        *I2C_COMM_FMT_OPTIONS, lower=True
                     ),
                 }
             ),
@@ -154,9 +156,23 @@ CONFIG_SCHEMA = cv.All(
     _validate_esp32_variant,
     _set_num_channels_from_config,
     _set_stream_limits,
+    validate_mclk_divisible_by_3,
 )
 
 
+def _final_validate(config):
+    if not use_legacy():
+        if config[CONF_DAC_TYPE] == "internal":
+            raise cv.Invalid("Internal DAC is only compatible with legacy i2s driver.")
+        if config[CONF_I2S_COMM_FMT] == "stand_max":
+            raise cv.Invalid(
+                "I2S standard max format only implemented with legacy i2s driver."
+            )
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
@@ -167,7 +183,17 @@ async def to_code(config):
         cg.add(var.set_internal_dac_mode(config[CONF_CHANNEL]))
     else:
         cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
-        cg.add(var.set_i2s_comm_fmt(config[CONF_I2S_COMM_FMT]))
+        if use_legacy():
+            cg.add(
+                var.set_i2s_comm_fmt(I2C_COMM_FMT_OPTIONS[config[CONF_I2S_COMM_FMT]])
+            )
+        else:
+            fmt = "std"  # equals stand_i2s, stand_pcm_long, i2s_msb, pcm_long
+            if config[CONF_I2S_COMM_FMT] in ["stand_msb", "i2s_lsb"]:
+                fmt = "msb"
+            elif config[CONF_I2S_COMM_FMT] in ["stand_pcm_short", "pcm_short", "pcm"]:
+                fmt = "pcm"
+            cg.add(var.set_i2s_comm_fmt(fmt))
     if config[CONF_TIMEOUT] != CONF_NEVER:
         cg.add(var.set_timeout(config[CONF_TIMEOUT]))
     cg.add(var.set_buffer_duration(config[CONF_BUFFER_DURATION]))