esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/http_request/update/__init__.py

@@ -16,14 +16,17 @@ HttpRequestUpdate = http_request_ns.class_(
 
 CONF_OTA_ID = "ota_id"
 
-CONFIG_SCHEMA = update.UPDATE_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(HttpRequestUpdate),
-        cv.GenerateID(CONF_OTA_ID): cv.use_id(OtaHttpRequestComponent),
-        cv.GenerateID(CONF_HTTP_REQUEST_ID): cv.use_id(HttpRequestComponent),
-        cv.Required(CONF_SOURCE): cv.url,
-    }
-).extend(cv.polling_component_schema("6h"))
+CONFIG_SCHEMA = (
+    update.update_schema(HttpRequestUpdate)
+    .extend(
+        {
+            cv.GenerateID(CONF_OTA_ID): cv.use_id(OtaHttpRequestComponent),
+            cv.GenerateID(CONF_HTTP_REQUEST_ID): cv.use_id(HttpRequestComponent),
+            cv.Required(CONF_SOURCE): cv.url,
+        }
+    )
+    .extend(cv.polling_component_schema("6h"))
+)
 
 
 async def to_code(config):

esphome/components/i2c/i2c.h

@@ -139,6 +139,10 @@ class I2CDevice {
   /// @param address of the device
   void set_i2c_address(uint8_t address) { address_ = address; }
 
+  /// @brief Returns the I2C address of the object.
+  /// @return the I2C address
+  uint8_t get_i2c_address() const { return this->address_; }
+
   /// @brief we store the pointer to the I2CBus to use
   /// @param bus pointer to the I2CBus object
   void set_i2c_bus(I2CBus *bus) { bus_ = bus; }

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -67,7 +67,7 @@ void IDFI2CBus::setup() {
       ESP_LOGV(TAG, "i2c_timeout set to %" PRIu32 " ticks (%" PRIu32 " us)", timeout_ * 80, timeout_);
     }
   }
-  err = i2c_driver_install(port_, I2C_MODE_MASTER, 0, 0, ESP_INTR_FLAG_IRAM);
+  err = i2c_driver_install(port_, I2C_MODE_MASTER, 0, 0, 0);
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "i2c_driver_install failed: %s", esp_err_to_name(err));
     this->mark_failed();

esphome/components/i2s_audio/__init__.py

@@ -8,7 +8,15 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S3,
 )
 import esphome.config_validation as cv
-from esphome.const import CONF_BITS_PER_SAMPLE, CONF_CHANNEL, CONF_ID, CONF_SAMPLE_RATE
+from esphome.const import (
+    CONF_BITS_PER_SAMPLE,
+    CONF_CHANNEL,
+    CONF_ID,
+    CONF_SAMPLE_RATE,
+    KEY_CORE,
+    KEY_FRAMEWORK_VERSION,
+)
+from esphome.core import CORE
 from esphome.cpp_generator import MockObjClass
 import esphome.final_validate as fv
 
@@ -31,10 +39,14 @@ CONF_SECONDARY = "secondary"
 
 CONF_USE_APLL = "use_apll"
 CONF_BITS_PER_CHANNEL = "bits_per_channel"
+CONF_MCLK_MULTIPLE = "mclk_multiple"
 CONF_MONO = "mono"
 CONF_LEFT = "left"
 CONF_RIGHT = "right"
 CONF_STEREO = "stereo"
+CONF_BOTH = "both"
+
+CONF_USE_LEGACY = "use_legacy"
 
 i2s_audio_ns = cg.esphome_ns.namespace("i2s_audio")
 I2SAudioComponent = i2s_audio_ns.class_("I2SAudioComponent", cg.Component)
@@ -50,6 +62,12 @@ I2S_MODE_OPTIONS = {
     CONF_SECONDARY: i2s_mode_t.I2S_MODE_SLAVE,  # NOLINT
 }
 
+i2s_role_t = cg.global_ns.enum("i2s_role_t")
+I2S_ROLE_OPTIONS = {
+    CONF_PRIMARY: i2s_role_t.I2S_ROLE_MASTER,  # NOLINT
+    CONF_SECONDARY: i2s_role_t.I2S_ROLE_SLAVE,  # NOLINT
+}
+
 # https://github.com/espressif/esp-idf/blob/master/components/soc/{variant}/include/soc/soc_caps.h
 I2S_PORTS = {
     VARIANT_ESP32: 2,
@@ -60,10 +78,23 @@ I2S_PORTS = {
 
 i2s_channel_fmt_t = cg.global_ns.enum("i2s_channel_fmt_t")
 I2S_CHANNELS = {
-    CONF_MONO: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ALL_LEFT,
-    CONF_LEFT: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ONLY_LEFT,
-    CONF_RIGHT: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ONLY_RIGHT,
-    CONF_STEREO: i2s_channel_fmt_t.I2S_CHANNEL_FMT_RIGHT_LEFT,
+    CONF_MONO: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ALL_LEFT,  # left data to both channels
+    CONF_LEFT: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ONLY_LEFT,  # mono data
+    CONF_RIGHT: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ONLY_RIGHT,  # mono data
+    CONF_STEREO: i2s_channel_fmt_t.I2S_CHANNEL_FMT_RIGHT_LEFT,  # stereo data to both channels
+}
+
+i2s_slot_mode_t = cg.global_ns.enum("i2s_slot_mode_t")
+I2S_SLOT_MODE = {
+    CONF_MONO: i2s_slot_mode_t.I2S_SLOT_MODE_MONO,
+    CONF_STEREO: i2s_slot_mode_t.I2S_SLOT_MODE_STEREO,
+}
+
+i2s_std_slot_mask_t = cg.global_ns.enum("i2s_std_slot_mask_t")
+I2S_STD_SLOT_MASK = {
+    CONF_LEFT: i2s_std_slot_mask_t.I2S_STD_SLOT_LEFT,
+    CONF_RIGHT: i2s_std_slot_mask_t.I2S_STD_SLOT_RIGHT,
+    CONF_BOTH: i2s_std_slot_mask_t.I2S_STD_SLOT_BOTH,
 }
 
 i2s_bits_per_sample_t = cg.global_ns.enum("i2s_bits_per_sample_t")
@@ -83,9 +114,37 @@ I2S_BITS_PER_CHANNEL = {
     32: i2s_bits_per_chan_t.I2S_BITS_PER_CHAN_32BIT,
 }
 
+i2s_slot_bit_width_t = cg.global_ns.enum("i2s_slot_bit_width_t")
+I2S_SLOT_BIT_WIDTH = {
+    "default": i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_AUTO,
+    8: i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_8BIT,
+    16: i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_16BIT,
+    24: i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_24BIT,
+    32: i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_32BIT,
+}
+
+i2s_mclk_multiple_t = cg.global_ns.enum("i2s_mclk_multiple_t")
+I2S_MCLK_MULTIPLE = {
+    128: i2s_mclk_multiple_t.I2S_MCLK_MULTIPLE_128,
+    256: i2s_mclk_multiple_t.I2S_MCLK_MULTIPLE_256,
+    384: i2s_mclk_multiple_t.I2S_MCLK_MULTIPLE_384,
+    512: i2s_mclk_multiple_t.I2S_MCLK_MULTIPLE_512,
+}
+
 _validate_bits = cv.float_with_unit("bits", "bit")
 
 
+def validate_mclk_divisible_by_3(config):
+    if config[CONF_BITS_PER_SAMPLE] == 24 and config[CONF_MCLK_MULTIPLE] % 3 != 0:
+        raise cv.Invalid(
+            f"{CONF_MCLK_MULTIPLE} must be divisible by 3 when bits per sample is 24"
+        )
+    return config
+
+
+_use_legacy_driver = None
+
+
 def i2s_audio_component_schema(
     class_: MockObjClass,
     *,
@@ -97,43 +156,83 @@ def i2s_audio_component_schema(
         {
             cv.GenerateID(): cv.declare_id(class_),
             cv.GenerateID(CONF_I2S_AUDIO_ID): cv.use_id(I2SAudioComponent),
-            cv.Optional(CONF_CHANNEL, default=default_channel): cv.enum(I2S_CHANNELS),
+            cv.Optional(CONF_CHANNEL, default=default_channel): cv.one_of(
+                *I2S_CHANNELS
+            ),
             cv.Optional(CONF_SAMPLE_RATE, default=default_sample_rate): cv.int_range(
                 min=1
             ),
             cv.Optional(CONF_BITS_PER_SAMPLE, default=default_bits_per_sample): cv.All(
-                _validate_bits, cv.enum(I2S_BITS_PER_SAMPLE)
+                _validate_bits, cv.one_of(*I2S_BITS_PER_SAMPLE)
             ),
-            cv.Optional(CONF_I2S_MODE, default=CONF_PRIMARY): cv.enum(
-                I2S_MODE_OPTIONS, lower=True
+            cv.Optional(CONF_I2S_MODE, default=CONF_PRIMARY): cv.one_of(
+                *I2S_MODE_OPTIONS, lower=True
             ),
             cv.Optional(CONF_USE_APLL, default=False): cv.boolean,
             cv.Optional(CONF_BITS_PER_CHANNEL, default="default"): cv.All(
                 cv.Any(cv.float_with_unit("bits", "bit"), "default"),
-                cv.enum(I2S_BITS_PER_CHANNEL),
+                cv.one_of(*I2S_BITS_PER_CHANNEL),
             ),
+            cv.Optional(CONF_MCLK_MULTIPLE, default=256): cv.one_of(*I2S_MCLK_MULTIPLE),
         }
     )
 
 
 async def register_i2s_audio_component(var, config):
     await cg.register_parented(var, config[CONF_I2S_AUDIO_ID])
-
-    cg.add(var.set_i2s_mode(config[CONF_I2S_MODE]))
-    cg.add(var.set_channel(config[CONF_CHANNEL]))
+    if use_legacy():
+        cg.add(var.set_i2s_mode(I2S_MODE_OPTIONS[config[CONF_I2S_MODE]]))
+        cg.add(var.set_channel(I2S_CHANNELS[config[CONF_CHANNEL]]))
+        cg.add(
+            var.set_bits_per_sample(I2S_BITS_PER_SAMPLE[config[CONF_BITS_PER_SAMPLE]])
+        )
+        cg.add(
+            var.set_bits_per_channel(
+                I2S_BITS_PER_CHANNEL[config[CONF_BITS_PER_CHANNEL]]
+            )
+        )
+    else:
+        cg.add(var.set_i2s_role(I2S_ROLE_OPTIONS[config[CONF_I2S_MODE]]))
+        slot_mode = config[CONF_CHANNEL]
+        if slot_mode != CONF_STEREO:
+            slot_mode = CONF_MONO
+        slot_mask = config[CONF_CHANNEL]
+        if slot_mask not in [CONF_LEFT, CONF_RIGHT]:
+            slot_mask = CONF_BOTH
+        cg.add(var.set_slot_mode(I2S_SLOT_MODE[slot_mode]))
+        cg.add(var.set_std_slot_mask(I2S_STD_SLOT_MASK[slot_mask]))
+        cg.add(var.set_slot_bit_width(I2S_SLOT_BIT_WIDTH[config[CONF_BITS_PER_SAMPLE]]))
     cg.add(var.set_sample_rate(config[CONF_SAMPLE_RATE]))
-    cg.add(var.set_bits_per_sample(config[CONF_BITS_PER_SAMPLE]))
-    cg.add(var.set_bits_per_channel(config[CONF_BITS_PER_CHANNEL]))
     cg.add(var.set_use_apll(config[CONF_USE_APLL]))
+    cg.add(var.set_mclk_multiple(I2S_MCLK_MULTIPLE[config[CONF_MCLK_MULTIPLE]]))
+
+
+def validate_use_legacy(value):
+    global _use_legacy_driver  # noqa: PLW0603
+    if CONF_USE_LEGACY in value:
+        if (_use_legacy_driver is not None) and (
+            _use_legacy_driver != value[CONF_USE_LEGACY]
+        ):
+            raise cv.Invalid(
+                f"All i2s_audio components must set {CONF_USE_LEGACY} to the same value."
+            )
+        if (not value[CONF_USE_LEGACY]) and (CORE.using_arduino):
+            raise cv.Invalid("Arduino supports only the legacy i2s driver.")
+        _use_legacy_driver = value[CONF_USE_LEGACY]
+    return value
 
 
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(I2SAudioComponent),
-        cv.Required(CONF_I2S_LRCLK_PIN): pins.internal_gpio_output_pin_number,
-        cv.Optional(CONF_I2S_BCLK_PIN): pins.internal_gpio_output_pin_number,
-        cv.Optional(CONF_I2S_MCLK_PIN): pins.internal_gpio_output_pin_number,
-    }
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(I2SAudioComponent),
+            cv.Required(CONF_I2S_LRCLK_PIN): pins.internal_gpio_output_pin_number,
+            cv.Optional(CONF_I2S_BCLK_PIN): pins.internal_gpio_output_pin_number,
+            cv.Optional(CONF_I2S_MCLK_PIN): pins.internal_gpio_output_pin_number,
+            cv.Optional(CONF_USE_LEGACY): cv.boolean,
+        },
+    ),
+    validate_use_legacy,
 )
 
 
@@ -148,12 +247,22 @@ def _final_validate(_):
         )
 
 
+def use_legacy():
+    framework_version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
+    if CORE.using_esp_idf and framework_version >= cv.Version(5, 0, 0):
+        if not _use_legacy_driver:
+            return False
+    return True
+
+
 FINAL_VALIDATE_SCHEMA = _final_validate
 
 
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
+    if use_legacy():
+        cg.add_define("USE_I2S_LEGACY")
 
     cg.add(var.set_lrclk_pin(config[CONF_I2S_LRCLK_PIN]))
     if CONF_I2S_BCLK_PIN in config:

esphome/components/i2s_audio/i2s_audio.h

@@ -2,9 +2,14 @@
 
 #ifdef USE_ESP32
 
-#include <driver/i2s.h>
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/defines.h"
+#ifdef USE_I2S_LEGACY
+#include <driver/i2s.h>
+#else
+#include <driver/i2s_std.h>
+#endif
 
 namespace esphome {
 namespace i2s_audio {
@@ -13,20 +18,36 @@ class I2SAudioComponent;
 
 class I2SAudioBase : public Parented<I2SAudioComponent> {
  public:
+#ifdef USE_I2S_LEGACY
   void set_i2s_mode(i2s_mode_t mode) { this->i2s_mode_ = mode; }
   void set_channel(i2s_channel_fmt_t channel) { this->channel_ = channel; }
-  void set_sample_rate(uint32_t sample_rate) { this->sample_rate_ = sample_rate; }
   void set_bits_per_sample(i2s_bits_per_sample_t bits_per_sample) { this->bits_per_sample_ = bits_per_sample; }
   void set_bits_per_channel(i2s_bits_per_chan_t bits_per_channel) { this->bits_per_channel_ = bits_per_channel; }
+#else
+  void set_i2s_role(i2s_role_t role) { this->i2s_role_ = role; }
+  void set_slot_mode(i2s_slot_mode_t slot_mode) { this->slot_mode_ = slot_mode; }
+  void set_std_slot_mask(i2s_std_slot_mask_t std_slot_mask) { this->std_slot_mask_ = std_slot_mask; }
+  void set_slot_bit_width(i2s_slot_bit_width_t slot_bit_width) { this->slot_bit_width_ = slot_bit_width; }
+#endif
+  void set_sample_rate(uint32_t sample_rate) { this->sample_rate_ = sample_rate; }
   void set_use_apll(uint32_t use_apll) { this->use_apll_ = use_apll; }
+  void set_mclk_multiple(i2s_mclk_multiple_t mclk_multiple) { this->mclk_multiple_ = mclk_multiple; }
 
  protected:
+#ifdef USE_I2S_LEGACY
   i2s_mode_t i2s_mode_{};
   i2s_channel_fmt_t channel_;
-  uint32_t sample_rate_;
   i2s_bits_per_sample_t bits_per_sample_;
   i2s_bits_per_chan_t bits_per_channel_;
+#else
+  i2s_role_t i2s_role_{};
+  i2s_slot_mode_t slot_mode_;
+  i2s_std_slot_mask_t std_slot_mask_;
+  i2s_slot_bit_width_t slot_bit_width_;
+#endif
+  uint32_t sample_rate_;
   bool use_apll_;
+  i2s_mclk_multiple_t mclk_multiple_;
 };
 
 class I2SAudioIn : public I2SAudioBase {};
@@ -37,6 +58,7 @@ class I2SAudioComponent : public Component {
  public:
   void setup() override;
 
+#ifdef USE_I2S_LEGACY
   i2s_pin_config_t get_pin_config() const {
     return {
         .mck_io_num = this->mclk_pin_,
@@ -46,6 +68,20 @@ class I2SAudioComponent : public Component {
         .data_in_num = I2S_PIN_NO_CHANGE,
     };
   }
+#else
+  i2s_std_gpio_config_t get_pin_config() const {
+    return {.mclk = (gpio_num_t) this->mclk_pin_,
+            .bclk = (gpio_num_t) this->bclk_pin_,
+            .ws = (gpio_num_t) this->lrclk_pin_,
+            .dout = I2S_GPIO_UNUSED,  // add local ports
+            .din = I2S_GPIO_UNUSED,
+            .invert_flags = {
+                .mclk_inv = false,
+                .bclk_inv = false,
+                .ws_inv = false,
+            }};
+  }
+#endif
 
   void set_mclk_pin(int pin) { this->mclk_pin_ = pin; }
   void set_bclk_pin(int pin) { this->bclk_pin_ = pin; }
@@ -62,9 +98,13 @@ class I2SAudioComponent : public Component {
 
   I2SAudioIn *audio_in_{nullptr};
   I2SAudioOut *audio_out_{nullptr};
-
+#ifdef USE_I2S_LEGACY
   int mclk_pin_{I2S_PIN_NO_CHANGE};
   int bclk_pin_{I2S_PIN_NO_CHANGE};
+#else
+  int mclk_pin_{I2S_GPIO_UNUSED};
+  int bclk_pin_{I2S_GPIO_UNUSED};
+#endif
   int lrclk_pin_;
   i2s_port_t port_{};
 };

esphome/components/i2s_audio/media_player/__init__.py

@@ -2,7 +2,7 @@ from esphome import pins
 import esphome.codegen as cg
 from esphome.components import esp32, media_player
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_MODE
+from esphome.const import CONF_MODE
 
 from .. import (
     CONF_I2S_AUDIO_ID,
@@ -14,6 +14,7 @@ from .. import (
     I2SAudioComponent,
     I2SAudioOut,
     i2s_audio_ns,
+    use_legacy,
 )
 
 CODEOWNERS = ["@jesserockz"]
@@ -56,16 +57,17 @@ def validate_esp32_variant(config):
 CONFIG_SCHEMA = cv.All(
     cv.typed_schema(
         {
-            "internal": media_player.MEDIA_PLAYER_SCHEMA.extend(
+            "internal": media_player.media_player_schema(I2SAudioMediaPlayer)
+            .extend(
                 {
-                    cv.GenerateID(): cv.declare_id(I2SAudioMediaPlayer),
                     cv.GenerateID(CONF_I2S_AUDIO_ID): cv.use_id(I2SAudioComponent),
                     cv.Required(CONF_MODE): cv.enum(INTERNAL_DAC_OPTIONS, lower=True),
                 }
-            ).extend(cv.COMPONENT_SCHEMA),
-            "external": media_player.MEDIA_PLAYER_SCHEMA.extend(
+            )
+            .extend(cv.COMPONENT_SCHEMA),
+            "external": media_player.media_player_schema(I2SAudioMediaPlayer)
+            .extend(
                 {
-                    cv.GenerateID(): cv.declare_id(I2SAudioMediaPlayer),
                     cv.GenerateID(CONF_I2S_AUDIO_ID): cv.use_id(I2SAudioComponent),
                     cv.Required(
                         CONF_I2S_DOUT_PIN
@@ -78,7 +80,8 @@ CONFIG_SCHEMA = cv.All(
                         *I2C_COMM_FMT_OPTIONS, lower=True
                     ),
                 }
-            ).extend(cv.COMPONENT_SCHEMA),
+            )
+            .extend(cv.COMPONENT_SCHEMA),
         },
         key=CONF_DAC_TYPE,
     ),
@@ -87,10 +90,17 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
+def _final_validate(_):
+    if not use_legacy():
+        raise cv.Invalid("I2S media player is only compatible with legacy i2s driver.")
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await media_player.new_media_player(config)
     await cg.register_component(var, config)
-    await media_player.register_media_player(var, config)
 
     await cg.register_parented(var, config[CONF_I2S_AUDIO_ID])
 

esphome/components/i2s_audio/microphone/__init__.py

@@ -1,17 +1,28 @@
 from esphome import pins
 import esphome.codegen as cg
-from esphome.components import esp32, microphone
+from esphome.components import audio, esp32, microphone
 from esphome.components.adc import ESP32_VARIANT_ADC1_PIN_TO_CHANNEL, validate_adc_pin
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_NUMBER
+from esphome.const import (
+    CONF_BITS_PER_SAMPLE,
+    CONF_CHANNEL,
+    CONF_ID,
+    CONF_NUM_CHANNELS,
+    CONF_NUMBER,
+    CONF_SAMPLE_RATE,
+)
 
 from .. import (
     CONF_I2S_DIN_PIN,
+    CONF_LEFT,
+    CONF_MONO,
     CONF_RIGHT,
     I2SAudioIn,
     i2s_audio_component_schema,
     i2s_audio_ns,
     register_i2s_audio_component,
+    use_legacy,
+    validate_mclk_divisible_by_3,
 )
 
 CODEOWNERS = ["@jesserockz"]
@@ -19,6 +30,7 @@ DEPENDENCIES = ["i2s_audio"]
 
 CONF_ADC_PIN = "adc_pin"
 CONF_ADC_TYPE = "adc_type"
+CONF_CORRECT_DC_OFFSET = "correct_dc_offset"
 CONF_PDM = "pdm"
 
 I2SAudioMicrophone = i2s_audio_ns.class_(
@@ -29,7 +41,7 @@ INTERNAL_ADC_VARIANTS = [esp32.const.VARIANT_ESP32]
 PDM_VARIANTS = [esp32.const.VARIANT_ESP32, esp32.const.VARIANT_ESP32S3]
 
 
-def validate_esp32_variant(config):
+def _validate_esp32_variant(config):
     variant = esp32.get_esp32_variant()
     if config[CONF_ADC_TYPE] == "external":
         if config[CONF_PDM]:
@@ -43,16 +55,47 @@ def validate_esp32_variant(config):
     raise NotImplementedError
 
 
+def _validate_channel(config):
+    if config[CONF_CHANNEL] == CONF_MONO:
+        raise cv.Invalid(f"I2S microphone does not support {CONF_MONO}.")
+    return config
+
+
+def _set_num_channels_from_config(config):
+    if config[CONF_CHANNEL] in (CONF_LEFT, CONF_RIGHT):
+        config[CONF_NUM_CHANNELS] = 1
+    else:
+        config[CONF_NUM_CHANNELS] = 2
+
+    return config
+
+
+def _set_stream_limits(config):
+    audio.set_stream_limits(
+        min_bits_per_sample=config.get(CONF_BITS_PER_SAMPLE),
+        max_bits_per_sample=config.get(CONF_BITS_PER_SAMPLE),
+        min_channels=config.get(CONF_NUM_CHANNELS),
+        max_channels=config.get(CONF_NUM_CHANNELS),
+        min_sample_rate=config.get(CONF_SAMPLE_RATE),
+        max_sample_rate=config.get(CONF_SAMPLE_RATE),
+    )(config)
+
+    return config
+
+
 BASE_SCHEMA = microphone.MICROPHONE_SCHEMA.extend(
     i2s_audio_component_schema(
         I2SAudioMicrophone,
         default_sample_rate=16000,
         default_channel=CONF_RIGHT,
         default_bits_per_sample="32bit",
+    ).extend(
+        {
+            cv.Optional(CONF_CORRECT_DC_OFFSET, default=False): cv.boolean,
+        }
     )
 ).extend(cv.COMPONENT_SCHEMA)
 
-
 CONFIG_SCHEMA = cv.All(
     cv.typed_schema(
         {
@@ -70,10 +113,23 @@ CONFIG_SCHEMA = cv.All(
         },
         key=CONF_ADC_TYPE,
     ),
-    validate_esp32_variant,
+    _validate_esp32_variant,
+    _validate_channel,
+    _set_num_channels_from_config,
+    _set_stream_limits,
+    validate_mclk_divisible_by_3,
 )
 
 
+def _final_validate(config):
+    if not use_legacy():
+        if config[CONF_ADC_TYPE] == "internal":
+            raise cv.Invalid("Internal ADC is only compatible 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)
@@ -88,3 +144,5 @@ async def to_code(config):
     else:
         cg.add(var.set_din_pin(config[CONF_I2S_DIN_PIN]))
         cg.add(var.set_pdm(config[CONF_PDM]))
+
+    cg.add(var.set_correct_dc_offset(config[CONF_CORRECT_DC_OFFSET]))