From 86addea62785d1bb1afcfcccb0af82cf0aec708b Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Thu, 23 Jul 2026 20:37:01 -0400
Subject: [PATCH 01/34] Removed redundant advancedMode definitions.

---
 html/index.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/html/index.html b/html/index.html
index bd48cf942..42ce3dcbb 100644
--- a/html/index.html
+++ b/html/index.html
@@ -685,7 +685,7 @@
 
                     <!-- Advanced Mode -->
                     <div class="hidden AdvancedMode">
-                        <div class="form-group hidden AdvancedMode">
+                        <div class="form-group">
                             <label class="control-label col-sm-2 esp32" for="sdspeed">SD Speed (MHz)</label>
                             <div class="col-sm-2 esp32">
                                 <input type="number" class="form-control is-valid esp32" id="sdspeed" step="1"
@@ -694,7 +694,7 @@
                             </div>
                         </div>
 
-                        <div class="form-group hidden AdvancedMode">
+                        <div class="form-group">
                             <label class="control-label col-sm-2" for="miso_pin">SD MISO Pin</label>
                             <div class="col-sm-4">
                                 <input type="number" class="form-control is-valid" id="miso_pin" step="1" min="0"

From 8881ae1ca19bbd929303fedc5e6908234b9b994b Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Thu, 23 Jul 2026 20:38:54 -0400
Subject: [PATCH 02/34] Fixed issue that removed the ability to modify the
 output GPIO values

---
 html/js/script.js | 45 +++++++++++++++++++++++++++++++++++++++------
 1 file changed, 39 insertions(+), 6 deletions(-)

diff --git a/html/js/script.js b/html/js/script.js
index a56bfd1ae..63bd14170 100644
--- a/html/js/script.js
+++ b/html/js/script.js
@@ -11,6 +11,10 @@ var System_Config = null;
 var Fseq_File_List = [];
 var selector = [];
 var ajaxQueue = $({}); // Create an empty jQuery object to act as a queue
+/**
+ * @type {string[]}
+ */
+var ListOfLoadedOutputElements = [];
 
 var SdCardIsInstalled = false;
 var FseqFileTransferStartTime = new Date();
@@ -621,14 +625,38 @@ function UpdateAdvancedOptionsMode(){
     let am = $('#AdvancedOptions');
     let AdvancedModeState = am.prop("checked");
 
-    $(".AdvancedMode").each(function () {
-        if (true === AdvancedModeState) {
-            $(this).removeClass("hidden");
+    const collection = document.getElementsByClassName('AdvancedMode');
+    $(collection).each(function (p, element)
+    {
+        // console.debug("Processing element: ", element);
+        if (true === AdvancedModeState)
+        {
+            $(element).removeClass("hidden");
         }
-        else {
-            $(this).addClass("hidden");
+        else
+        {
+            $(element).addClass("hidden");
         }
     });
+
+    $(ListOfLoadedOutputElements).each(function (p, element)
+    {
+        // console.debug("Processing loaded output element: ", element);
+        const subElements = $(element).find('.AdvancedMode');
+        $(subElements).each(function (p, element)
+        {
+            // console.debug("Processing loaded output element: ", element);
+            if (true === AdvancedModeState)
+            {
+                $(element).removeClass("hidden");
+            }
+            else
+            {
+                $(element).addClass("hidden");
+            }
+        });
+    });
+
 } // UpdateAdvancedOptionsMode
 
 function UpdateChannelCounts() {
@@ -1448,7 +1476,9 @@ function ProcessConfigElements(StartingElementId, channelConfig)
         // console.debug("LoadLocation: " + LoadLocation);
         $(LoadLocation).load(LoadName, function()
         {
+            ListOfLoadedOutputElements.push(LoadLocation);
             ProcessConfigElements(LoadLocation, channelConfig);
+            UpdateAdvancedOptionsMode();
         });
         return $(this).attr('id');
     }).get();
@@ -1513,7 +1543,10 @@ function ProcessModeConfigurationData(channelId, ChannelType, JsonConfig) {
         // console.debug("ModeDisplayName: " + ModeDisplayName);
         $(modeControlName + ' #Title')[0].innerHTML = ModeDisplayName;
     }
-
+    if("output" === ChannelType)
+    {
+        ListOfLoadedOutputElements = [];
+    }
     ProcessConfigElements(modeControlName, channelConfig);
 
     // by default, do not show the ECB config data

From bf7ed3381ddf838be1c7b9fba39d52880525b97a Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Thu, 23 Jul 2026 20:40:15 -0400
Subject: [PATCH 03/34] Updated to most recent settings.

---
 boards/seeed_xiao_esp32s3-custom.json | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/boards/seeed_xiao_esp32s3-custom.json b/boards/seeed_xiao_esp32s3-custom.json
index 703ad5d8b..46a9ec1aa 100644
--- a/boards/seeed_xiao_esp32s3-custom.json
+++ b/boards/seeed_xiao_esp32s3-custom.json
@@ -8,6 +8,7 @@
     "core": "esp32",
     "extra_flags": [
       "-DARDUINO_ESP32S3_DEV",
+      "-DARDUINO_XIAO_ESP32S3",
       "-DARDUINO_USB_MODE=1",
       "-DARDUINO_USB_CDC_ON_BOOT=1",
       "-DARDUINO_RUNNING_CORE=1",
@@ -27,7 +28,7 @@
       ]
     ],
     "mcu": "esp32s3",
-    "variant": "esp32s3"
+    "variant": "XIAO_ESP32S3"
   },
   "connectivity": [
     "wifi"
@@ -53,4 +54,4 @@
   },
   "url": "https://www.seeedstudio.com/XIAO-ESP32S3-p-5627.html",
   "vendor": "Seeed Studio"
-}
\ No newline at end of file
+}

From e412871c5453362c9fd498493f57ce48f74f6a9a Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 10 Aug 2026 22:03:19 -0400
Subject: [PATCH 04/34] Checkpoint

---
 include/output/OutputI2S.hpp | 112 +++++++++++
 src/output/OutputI2S.cpp     | 355 +++++++++++++++++++++++++++++++++++
 2 files changed, 467 insertions(+)
 create mode 100644 include/output/OutputI2S.hpp
 create mode 100644 src/output/OutputI2S.cpp

diff --git a/include/output/OutputI2S.hpp b/include/output/OutputI2S.hpp
new file mode 100644
index 000000000..bb6d715b2
--- /dev/null
+++ b/include/output/OutputI2S.hpp
@@ -0,0 +1,112 @@
+#pragma once
+/*
+* OutputI2S.hpp - I2S driver code for ESPixelStick I2S Channel
+*
+* Project: ESPixelStick - An ESP8266 / ESP32 and E1.31 based pixel driver
+* Copyright (c) 2026 Shelby Merrick
+* http://www.forkineye.com
+*
+*  This program is provided free for you to use in any way that you wish,
+*  subject to the laws and regulations where you are using it.  Due diligence
+*  is strongly suggested before using this code.  Please give credit where due.
+*
+*  The Author makes no warranty of any kind, express or implied, with regard
+*  to this program or the documentation contained in this document.  The
+*  Author shall not be liable in any event for incidental or consequential
+*  damages in connection with, or arising out of, the furnishing, performance
+*  or use of these programs.
+*
+*/
+
+#ifdef ARDUINO_ARCH_ESP32
+#include "ESPixelStick.h"
+#include "OutputCommon.hpp"
+#include "m_i2s.h"
+#include "driver/gpio.h"
+
+// a slot is one bit in the output item
+#define I2S_NUM_SLOTA           i2s_bits_per_chan_t::I2S_BITS_PER_CHAN_16BIT
+union I2S_item_t
+{
+    struct
+    {
+        uint8_t data;
+        uint8_t reserved;
+    };
+    uint16_t RawData;
+};
+
+class c_OutputI2S
+{
+public:
+    struct OutputI2SSlotConfig_t
+    {
+        uint32_t            I2SChannelId                = uint32_t(-1);
+        gpio_num_t          DataPin                     = gpio_num_t(-1);
+        void                *arg                        = nullptr;
+        bool                (*ISR_GetNextIntensityBit)  (void*arg, I2S_item_t&data, uint32_t &numSlices) = nullptr;
+    };
+
+private:
+
+    // list of GPIOs for the I2S slots 24 is the 
+    // max # slots and must be present no matter how many 
+    // slots are actually used
+    gpio_num_t GpioDataPins[24];
+    const int clock_pin = I2S_PIN_NO_CHANGE; // Pixel Clock
+
+    OutputI2SSlotConfig_t   OutputI2SSlotConfigs[I2S_NUM_SLOTA];
+
+    bool                OutputIsPaused = false;
+
+    uint32_t SetBitSliceLen (uint8_t ChanId, double BitSliceLenNs);
+    void StartSendingData   ();
+    void StopSendingData    ();
+    void InitI2Sdriver      ();
+
+#ifndef HasBeenInitialized
+    bool HasBeenInitialized = false;
+#endif // ndef HasBeenInitialized
+
+    TaskHandle_t I2sTaskHandle = NULL;
+
+public:
+    c_OutputI2S ();
+    virtual ~c_OutputI2S ();
+
+    void Begin              ();
+    void RegisterSlotDevice (OutputI2SSlotConfig_t config, c_OutputCommon * pParent);
+    void RemoveSlotDevice   (OutputI2SSlotConfig_t config);
+    void GetStatus          (ArduinoJson::JsonObject& jsonStatus);
+    void PauseOutput        (bool State);
+    void GetDriverName      (String &value)  { value = F("I2S"); }
+    void ISR_ProcessDma     ();
+
+// #define USE_I2S_DEBUG_COUNTERS
+#ifdef USE_I2S_DEBUG_COUNTERS
+// #define IncludeBufferData
+   // debug counters
+    struct I2SDebugCounters_t
+    {
+        uint32_t DataTaskcounter = 0;
+        uint32_t IntensityBitsSent = 0;
+        uint32_t IntensityBitsSentLastFrame = 0;
+        uint32_t I2SEntriesTransfered = 0;
+        uint32_t I2SXmtFills = 0;
+        uint32_t ISRpaused = 0;
+        uint32_t WriteToBuffer = 0;
+    } ;
+    I2SDebugCounters_t I2SDebugCounters;
+
+#define I2S_DEBUG_INC_COUNTER(p) (++I2SDebugCounters.p)
+#define I2S_DEBUG_COUNTER(p)  (I2SDebugCounters.p)
+
+#else
+
+#define I2S_DEBUG_INC_COUNTER(p)
+#define I2S_DEBUG_COUNTER(p)
+
+#endif // def USE_I2S_DEBUG_COUNTERS
+
+};
+#endif // def #ifdef ARDUINO_ARCH_ESP32
\ No newline at end of file
diff --git a/src/output/OutputI2S.cpp b/src/output/OutputI2S.cpp
new file mode 100644
index 000000000..0feab0710
--- /dev/null
+++ b/src/output/OutputI2S.cpp
@@ -0,0 +1,355 @@
+/*
+* OutputI2S.cpp - driver code for ESPixelStick I2S Channel
+*
+* Project: ESPixelStick - An ESP8266 / ESP32 and E1.31 based pixel driver
+* Copyright (c) 2026, 2026 Shelby Merrick
+* http://www.forkineye.com
+*
+*  This program is provided free for you to use in any way that you wish,
+*  subject to the laws and regulations where you are using it.  Due diligence
+*  is strongly suggested before using this code.  Please give credit where due.
+*
+*  The Author makes no warranty of any kind, express or implied, with regard
+*  to this program or the documentation contained in this document.  The
+*  Author shall not be liable in any event for incidental or consequential
+*  damages in connection with, or arising out of, the furnishing, performance
+*  or use of these programs.
+*
+*/
+#include "ESPixelStick.h"
+#if defined(ARDUINO_ARCH_ESP32)
+
+#include "output/OutputI2S.hpp"
+#include "m_i2s.h"
+#include "driver/gpio.h"
+#include "soc/io_mux_reg.h"
+#include "esp_rom_gpio.h"
+
+#define I2S_DeviceID i2s_port_t::I2S_NUM_0
+#define I2S_Device I2S0
+#define I2S_DataStartSignal I2S0O_DATA_OUT8_IDX
+
+struct I2S_ListOfRegisteredChannels_t
+{
+    void * pThis;
+    void (*GetMoreDate)(void*, I2S_item_t*, uint32_t);
+    bool IsActive;
+};
+
+static I2S_ListOfRegisteredChannels_t I2S_ListOfRegisteredChannels[I2S_NUM_SLOTA];
+#define                               I2S_NumSendBufferItems 128
+static I2S_item_t                     I2S_SendBuffer[I2S_NumSendBufferItems];
+
+void FillBufferWithTestData(uint8_t testData)
+{
+    for (uint32_t i = 0; i < I2S_NumSendBufferItems; ++i)
+    {
+        I2S_SendBuffer[i].data = testData;
+    }
+}
+//----------------------------------------------------------------------------
+void I2S_Task(void*)
+{
+    size_t bytes_written = 0;
+    DEBUG_V(String("Current CPU ID: ") + String(xPortGetCoreID()));
+
+    int index = 0;
+    while(index < I2S_NumSendBufferItems)
+    {
+        I2S_SendBuffer[index++].data = 0xFE;
+        I2S_SendBuffer[index++].data = 0xFF;
+    }
+    while(true)
+    {
+        // test code to send data to the I2S driver
+        // DEBUG_V("Sending data to I2S driver");
+        FillBufferWithTestData(0xFF);
+        m_i2s_write(I2S_DeviceID, I2S_SendBuffer, sizeof(I2S_SendBuffer), &bytes_written, portMAX_DELAY);
+        FillBufferWithTestData(0xFE);
+        m_i2s_write(I2S_DeviceID, I2S_SendBuffer, sizeof(I2S_SendBuffer), &bytes_written, portMAX_DELAY);
+        // DEBUG_V(String("Bytes written: ") + String(bytes_written) + " bytes");
+
+        // DEBUG_V("Processing all possible channels");
+        for (I2S_ListOfRegisteredChannels_t & CurrentChannel : I2S_ListOfRegisteredChannels)
+        {
+            // DEBUG_V(String("Processing channel: 0x") + String(uint32_t(CurrentChannel.pThis), HEX));
+            // do we have a driver on this channel?
+            if(true == CurrentChannel.IsActive)
+            {
+                DEBUG_V(String("Getting more data for channel: 0x") + String(uint32_t(CurrentChannel.pThis), HEX));
+                // digitalWrite(17, LOW);
+
+                // invoke the channel
+                CurrentChannel.GetMoreDate(CurrentChannel.pThis, I2S_SendBuffer, I2S_NumSendBufferItems);
+                // send the data to the I2S driver
+                size_t bytes_written = 0;
+                m_i2s_write(I2S_DeviceID, &I2S_SendBuffer, I2S_NumSendBufferItems, &bytes_written, portMAX_DELAY);
+                DEBUG_V(String("Bytes written: ") + String(bytes_written) + " bytes");
+            }
+        }
+    }
+}
+
+//----------------------------------------------------------------------------
+c_OutputI2S::c_OutputI2S()
+{
+    // DEBUG_START;
+
+    for(auto &CurrGpio : GpioDataPins)
+    {
+        // DEBUG_V(String("Configuring GPIO: ") + String(CurrGpio));
+        CurrGpio = gpio_num_t(-1);
+    }
+
+    for (I2S_ListOfRegisteredChannels_t & CurrentChannel : I2S_ListOfRegisteredChannels)
+    {
+        CurrentChannel.pThis = nullptr;
+        CurrentChannel.GetMoreDate = nullptr;
+        CurrentChannel.IsActive = false;
+    }
+
+    // DEBUG_END;
+} // c_OutputI2S
+
+//----------------------------------------------------------------------------
+c_OutputI2S::~c_OutputI2S ()
+{
+    // DEBUG_START;
+
+    if (HasBeenInitialized)
+    {
+
+    }
+
+    // DEBUG_END;
+} // ~c_OutputI2S
+
+//----------------------------------------------------------------------------
+void c_OutputI2S::InitI2Sdriver ()
+{
+        // 1. Configure the core I2S settings
+        i2s_config_t i2s_config;
+            i2s_config.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX);
+            i2s_config.sample_rate = 10; // This is over written later
+            i2s_config.bits_per_chan = i2s_bits_per_chan_t::I2S_BITS_PER_CHAN_DEFAULT; // follow bits_per_sample
+            i2s_config.bits_per_sample = i2s_bits_per_sample_t::I2S_BITS_PER_SAMPLE_16BIT;
+            i2s_config.channel_format = i2s_channel_fmt_t::I2S_CHANNEL_FMT_RIGHT_LEFT;
+            i2s_config.communication_format = i2s_comm_format_t::I2S_COMM_FORMAT_STAND_I2S;
+            i2s_config.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
+            i2s_config.dma_buf_count = 4;
+            i2s_config.dma_buf_len = sizeof(I2S_SendBuffer);
+            i2s_config.use_apll = false;
+            i2s_config.fixed_mclk = 0;
+            i2s_config.tx_desc_auto_clear = true;
+
+        // DEBUG_V(String("Install driver onto I2S Port ") + String(I2S_DeviceID));
+        if(ESP_OK != m_i2s_driver_install(I2S_DeviceID, &i2s_config, 0, NULL))
+        {
+            logcon(F("Failed to install I2S driver"));
+        }
+
+        //DEBUG_V("Stop I2S Driver");
+        m_i2s_stop(I2S_DeviceID);
+
+        // DEBUG_V("Set clock pins");
+        i2s_pin_config_t pin_config =
+        {
+            .mck_io_num = I2S_PIN_NO_CHANGE,
+            .bck_io_num = I2S_PIN_NO_CHANGE,
+            .ws_io_num = I2S_PIN_NO_CHANGE,
+            .data_out_num = I2S_PIN_NO_CHANGE,
+            .data_in_num = I2S_PIN_NO_CHANGE
+        };
+        if(ESP_OK != m_i2s_set_pin(I2S_DeviceID, &pin_config))
+        {
+            logcon(F("Failed to set I2S pin configuration"));
+        }
+
+        // DEBUG_V("Set i2s mode to LCD mode");
+        // I2S_Device.conf2.val = 0;
+        I2S_Device.conf2.lcd_en = true;
+//        I2S_Device.conf2.data_enable = false;
+        I2S_Device.conf2.camera_en = false;
+//        I2S_Device.conf2.lcd_tx_sdx2_en = true;
+//        I2S_Device.conf2.lcd_tx_wrx2_en = true;
+
+        // Setup i2s clock
+        // I2S_Device.sample_rate_conf.val = 0;
+        // I2S_Device.sample_rate_conf.rx_bits_mod = i2s_bits_per_chan_t::I2S_NUM_SLOTA;
+//        I2S_Device.sample_rate_conf.tx_bits_mod = i2s_bits_per_chan_t::I2S_NUM_SLOTA;
+        // I2S_Device.sample_rate_conf.rx_bck_div_num = 1;
+        I2S_Device.sample_rate_conf.tx_bck_div_num = 1;
+
+        // I2S_Device.clkm_conf.val = 0;
+        I2S_Device.clkm_conf.clka_en = false;
+        I2S_Device.clkm_conf.clk_en = false; // Use PLL_D2_CLK (160MHz)
+        I2S_Device.clkm_conf.clkm_div_num = 24; // 160MH / 800kh / 3 slots per bit
+        I2S_Device.clkm_conf.clkm_div_a = 8; // Adjust based on source
+        I2S_Device.clkm_conf.clkm_div_b = 7; // Adjust based on source
+        I2S_Device.sample_rate_conf.tx_bck_div_num = 4;
+
+        // I2S_Device.fifo_conf.val = 0;
+        // Dictated by datasheet
+        I2S_Device.fifo_conf.tx_fifo_mod_force_en = true;
+        I2S_Device.fifo_conf.tx_fifo_mod = 2; // I2S_TX_CHAN_MODE_MONO;
+//        I2S_Device.fifo_conf.tx_fifo_mod = 1; // twice
+        // I2S_Device.fifo_conf.tx_data_num = 32; 
+        // I2S_Device.fifo_conf.rx_data_num = 32; //Thresholds. 
+        // I2S_Device.fifo_conf.rx_fifo_mod_force_en = 1;
+
+        // I2S_Device.conf1.val = 0;
+        I2S_Device.conf1.tx_stop_en = false;
+        I2S_Device.conf1.tx_zeros_rm_en = false;
+//        I2S_Device.conf1.tx_pcm_conf = 0;
+        I2S_Device.conf1.tx_pcm_bypass = true;
+
+        // I2S_Device.conf_chan.val = 0;
+        // Tx in mono mode, read 32 bit per sample from fifo
+//        I2S_Device.conf_chan.tx_chan_mod = 1; // Both slots transmit the left channel data.
+        // I2S_Device.conf_chan.rx_chan_mod = 1;
+
+        // DEBUG_V("3. Enable LCD mode specific register flags");
+        I2S_Device.conf.val = 0;
+//        I2S_Device.conf.tx_right_first = true;
+//        I2S_Device.conf.tx_msb_right = false;
+        I2S_Device.conf.tx_slave_mod = false;
+
+        // 4. Clear standard serial pin allocations 
+
+        // DEBUG_V("5. Route parallel data lines manually via GPIO matrix");
+        // I2S0 data output signals start at I2S_DataStartSignal 
+        int GpioTableIndex = 0;
+        for (auto gpioValue : GpioDataPins)
+        {
+            // DEBUG_V(String("Configuring GPIO pin: ") + String(GpioDataPins[i]));
+            m_gpio_matrix_out_check_and_set(gpioValue, I2S_DataStartSignal + GpioTableIndex, false, false);
+            GpioTableIndex++;
+        }
+
+        // set the reserved bits to 1 to avoid sending garbage data
+        memset(&I2S_SendBuffer, 0xFF, sizeof(I2S_SendBuffer));
+
+        // DEBUG_V("Start the peripheral clocking");
+        if(ESP_OK != m_i2s_start(I2S_DeviceID))
+        {
+            logcon(F("Failed to start I2S peripheral"));
+        }
+} // InitI2Sdriver
+
+//----------------------------------------------------------------------------
+void c_OutputI2S::Begin ()
+{
+    // DEBUG_START;
+
+    do // once
+    {
+        GpioDataPins[0] = gpio_num_t(0);
+        GpioDataPins[1] = gpio_num_t(1);
+        GpioDataPins[2] = gpio_num_t(2);
+        GpioDataPins[3] = gpio_num_t(3);
+        GpioDataPins[4] = gpio_num_t(4);
+        GpioDataPins[5] = gpio_num_t(5);
+        GpioDataPins[6] = gpio_num_t(12);
+        GpioDataPins[7] = gpio_num_t(13);
+
+        InitI2Sdriver();
+
+        // DEBUG_V();
+        xTaskCreatePinnedToCore(I2S_Task, "I2S_Task", 4096, NULL, 5, &I2sTaskHandle, 1);
+        vTaskPrioritySet(I2sTaskHandle, 5);
+
+        HasBeenInitialized = true;
+    } while (false);
+
+    // DEBUG_END;
+
+} // Begin
+
+//----------------------------------------------------------------------------
+void c_OutputI2S::GetStatus (ArduinoJson::JsonObject& jsonStatus)
+{
+    // // DEBUG_START;
+
+#ifdef USE_I2S_DEBUG_COUNTERS
+    jsonStatus[F("OutputIsPaused")] = OutputIsPaused;
+    JsonObject debugStatus = jsonStatus["I2S Debug"].to<JsonObject>();
+    debugStatus["I2SChannelId"]                 = OutputI2SConfig.I2SChannelId;
+    debugStatus["GPIO"]                         = OutputI2SConfig.DataPin;
+
+    debugStatus["IntensityBitsSent"]            = I2S_DEBUG_COUNTER(IntensityBitsSent);
+    debugStatus["I2SEntriesTransfered"]         = I2S_DEBUG_COUNTER(I2SEntriesTransfered);
+    debugStatus["I2SXmtFills"]                  = I2S_DEBUG_COUNTER(I2SXmtFills);
+#endif // def USE_I2S_DEBUG_COUNTERS
+    // // DEBUG_END;
+} // GetStatus
+
+//----------------------------------------------------------------------------
+uint32_t c_OutputI2S::SetBitSliceLen (uint8_t ChanId, double BitSliceLenNs)
+{
+    // DEBUG_START;
+    uint32_t Result = 0;
+
+    // DEBUG_END;
+    return Result;
+} // SetBitDuration
+
+//----------------------------------------------------------------------------
+void c_OutputI2S::PauseOutput(bool PauseOutput)
+{
+    /// DEBUG_START;
+
+    if (OutputIsPaused == PauseOutput)
+    {
+        ///DEBUG_V("no change. Ignore the call");
+    }
+    else if (PauseOutput)
+    {
+        ///DEBUG_V("stop the output");
+        // Stop the transmitter
+        m_i2s_stop(I2S_DeviceID);
+    }
+
+    OutputIsPaused = PauseOutput;
+
+    ///DEBUG_END;
+} // PauseOutput
+
+//----------------------------------------------------------------------------
+void c_OutputI2S::StopSendingData ()
+{
+    // DEBUG_START;
+
+    do // once
+    {
+    } while(false);
+
+    // DEBUG_END;
+} // StopSendingData
+
+//----------------------------------------------------------------------------
+void c_OutputI2S::StartSendingData ()
+{
+    // DEBUG_START;
+
+    do // once
+    {
+        if(OutputIsPaused)
+        {
+            // DEBUG_V("Paused");
+            break;
+        }
+
+        // DEBUG_V();
+
+    } while(false);
+
+    // DEBUG_END;
+} // StartSendingData
+
+//----------------------------------------------------------------------------
+void IRAM_ATTR c_OutputI2S::ISR_ProcessDma ()
+{
+
+} // ISR_ProcessDma
+
+#endif // defined(ARDUINO_ARCH_ESP32)

From 1c41650c930ee3ef2271a3ccbf7ba36cfcc92988 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 10 Aug 2026 22:04:51 -0400
Subject: [PATCH 05/34] Remove idftest from default build

---
 platformio.ini | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platformio.ini b/platformio.ini
index 5c082a1fc..62357ff64 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -4,7 +4,7 @@
 ; Local configuration should be done in platformio_user.ini
 
 [platformio]
-default_envs = esp32_idftest, esp8266_espsv3, esp8266_wemos_d1_mini, esp8266_wemos_d1_mini_pro, esp8266_esp01s, esp32_lolin_d1_pro, esp32_lolin_d1_pro_eth, esp32_cam, esp32_ttgo_t8, esp32_bong69, esp32_wt32eth01, esp32_quinled_quad, esp32_quinled_quad_p5, esp32_quinled_quad_ae_plus, esp32_quinled_quad_ae_plus_8, esp32_quinled_quad_eth, esp32_quinled_quad_eth_p5, esp32_quinled_uno, esp32_quinled_uno_ae_plus, esp32_quinled_uno_eth, esp32_quinled_dig_octa, esp32_d1_mini_mhetesp32minikit, esp32_olimex_gw, esp32_d1_mini_twilightlord, esp32_d1_mini_twilightlord_eth, esp32_devkitc, esp32_devkitc6, esp32_quinled_uno_eth_espsv3, esp32_quinled_uno_espsv3, esp32_m5stack_atom, esp32_deuxquatro_dmx, esp32_wasatch, esp32_tetra2go, esp32_tetra2go_eth, esp32_octa2go, esp32_octa2go_eth, esp32_solo2go, esp32_solo2go_eth, esp32_kr_lights_msm, esp32_ka, esp32_ka_4, esp32_breakdancev2, esp32_foo, esp32s3_seeed_xiao, esp32_wemos_d1_mini32, esp32_wemos_d1_mini32_eth, esp32s3_devkitc, esp32s3_devkitc_Internal_SD, esp32_devkitv_eth, esp32s3_fh4r2, esp32_relayboardx8
+default_envs = esp8266_espsv3, esp8266_wemos_d1_mini, esp8266_wemos_d1_mini_pro, esp8266_esp01s, esp32_lolin_d1_pro, esp32_lolin_d1_pro_eth, esp32_cam, esp32_ttgo_t8, esp32_bong69, esp32_wt32eth01, esp32_quinled_quad, esp32_quinled_quad_p5, esp32_quinled_quad_ae_plus, esp32_quinled_quad_ae_plus_8, esp32_quinled_quad_eth, esp32_quinled_quad_eth_p5, esp32_quinled_uno, esp32_quinled_uno_ae_plus, esp32_quinled_uno_eth, esp32_quinled_dig_octa, esp32_d1_mini_mhetesp32minikit, esp32_olimex_gw, esp32_d1_mini_twilightlord, esp32_d1_mini_twilightlord_eth, esp32_devkitc, esp32_devkitc6, esp32_quinled_uno_eth_espsv3, esp32_quinled_uno_espsv3, esp32_m5stack_atom, esp32_deuxquatro_dmx, esp32_wasatch, esp32_tetra2go, esp32_tetra2go_eth, esp32_octa2go, esp32_octa2go_eth, esp32_solo2go, esp32_solo2go_eth, esp32_kr_lights_msm, esp32_ka, esp32_ka_4, esp32_breakdancev2, esp32_foo, esp32s3_seeed_xiao, esp32_wemos_d1_mini32, esp32_wemos_d1_mini32_eth, esp32s3_devkitc, esp32s3_devkitc_Internal_SD, esp32_devkitv_eth, esp32s3_fh4r2, esp32_relayboardx8
 ;default_envs = esp32_idftest
 
 src_dir = ./src

From ad89cce44cae50f3e380489b612c81714be0f2ba Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 10 Aug 2026 22:08:16 -0400
Subject: [PATCH 06/34] Added conditional I2S support.

---
 src/output/OutputMgr.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/output/OutputMgr.cpp b/src/output/OutputMgr.cpp
index 9fbaf1c91..bc2069737 100644
--- a/src/output/OutputMgr.cpp
+++ b/src/output/OutputMgr.cpp
@@ -53,6 +53,10 @@
 
 #include "input/InputMgr.hpp"
 
+#ifdef SUPPORT_I2S
+    #include "output/OutputI2S.hpp"
+#endif // def SUPPORT_I2S
+
 #ifdef ARDUINO_ARCH_ESP32
     #define CLASS_TYPE_NAME(n)      n ## Rmt
 #else
@@ -240,6 +244,11 @@ struct alignas(32) DriverInfo_t
 static DriverInfo_t * pOutputChannelDrivers  = nullptr;;
 
 static uint8_t OutputBuffer[OM_MAX_NUM_CHANNELS];
+
+#ifdef SUPPORT_I2S
+static c_OutputI2S OutputI2S;
+#endif // def SUPPORT_I2S
+
 //-----------------------------------------------------------------------------
 // Methods
 //-----------------------------------------------------------------------------
@@ -352,6 +361,10 @@ void c_OutputMgr::Begin ()
         digitalWrite (LED_FLASH_GPIO, LED_FLASH_OFF);
         #endif // def LED_FLASH_GPIO
 
+    #ifdef SUPPORT_I2S
+        OutputI2S.Begin();
+    #endif // def SUPPORT_I2S
+    
         // make sure the pointers are set up properly
         for (uint8_t index = 0; index < NumOutputPorts; ++index)
         {
@@ -602,6 +615,7 @@ void c_OutputMgr::GetStatus (JsonObject & jsonStatus)
     // DEBUG_START;
 
 #if defined(ARDUINO_ARCH_ESP32)
+    OutputI2S.GetStatus(jsonStatus);
     // jsonStatus["PollCount"] = PollCount;
 #endif // defined(ARDUINO_ARCH_ESP32)
 

From 9f0cf32896c6eef6ff852a3cd0d0f1c7aa3323c7 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 10 Aug 2026 22:16:40 -0400
Subject: [PATCH 07/34] changed compile trigger

---
 include/service/m_i2s.h  |  518 +++++++++
 src/output/OutputI2S.cpp |    4 +-
 src/service/m_i2s.c      | 2327 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 2847 insertions(+), 2 deletions(-)
 create mode 100644 include/service/m_i2s.h
 create mode 100644 src/service/m_i2s.c

diff --git a/include/service/m_i2s.h b/include/service/m_i2s.h
new file mode 100644
index 000000000..501e3d4f1
--- /dev/null
+++ b/include/service/m_i2s.h
@@ -0,0 +1,518 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+#ifdef SUPPORT_I2S
+
+#include "esp_types.h"
+#include "esp_err.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include "soc/i2s_periph.h"
+#include "soc/rtc_periph.h"
+#include "soc/soc_caps.h"
+#include "hal/i2s_types.h"
+#include "driver/periph_ctrl.h"
+#include "esp_intr_alloc.h"
+
+#if SOC_I2S_SUPPORTS_ADC
+#include "driver/adc.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define I2S_PIN_NO_CHANGE (-1) /*!< Use in i2s_pin_config_t for pins which should not be changed */
+
+/**
+ * @brief I2S port number, the max port number is (I2S_NUM_MAX -1).
+ */
+typedef enum {
+    I2S_NUM_0 = 0,                 /*!< I2S port 0 */
+#if SOC_I2S_NUM > 1
+    I2S_NUM_1 = 1,                 /*!< I2S port 1 */
+#endif
+    I2S_NUM_MAX,                   /*!< I2S port max */
+} i2s_port_t;
+
+#if SOC_I2S_SUPPORTS_PCM
+/**
+ * @brief I2S PCM configuration
+ *
+ */
+typedef struct {
+    i2s_pcm_compress_t  pcm_type;       /*!< I2S PCM a/u-law decompress or compress type */
+} i2s_pcm_cfg_t;
+#endif
+
+#if SOC_I2S_SUPPORTS_PDM_TX
+/**
+ * @brief Default I2S PDM Up-Sampling Rate configuration
+ */
+#define I2S_PDM_DEFAULT_UPSAMPLE_CONFIG(rate) { \
+        .sample_rate = rate,                    \
+        .fp = 960,                              \
+        .fs = (rate) / 100,                     \
+    }
+
+/**
+ * @brief I2S PDM up-sample rate configuration
+ * @note  TX PDM can only be set to the following two upsampling rate configurations:
+ *        1: fp = 960, fs = sample_rate / 100, in this case, Fpdm = 128*48000
+ *        2: fp = 960, fs = 480, in this case, Fpdm = 128*Fpcm = 128*sample_rate
+ *        If the pdm receiver do not care the pdm serial clock, it's recommended set Fpdm = 128*48000.
+ *        Otherwise, the second configuration should be applied.
+ */
+typedef struct  {
+    int sample_rate;                    /*!< I2S PDM sample rate */
+    int fp;                             /*!< I2S PDM TX upsampling paramater. Normally it should be set to 960 */
+    int fs;                             /*!< I2S PDM TX upsampling paramater. When it is set to 480, the pdm clock frequency Fpdm = 128 * sample_rate, when it is set to sample_rate / 100， Fpdm will be fixed to 128*48000 */
+} i2s_pdm_tx_upsample_cfg_t;
+#endif
+
+/**
+ * @brief I2S pin number for i2s_set_pin
+ *
+ */
+typedef struct {
+    int mck_io_num;     /*!< MCK in out pin. Note that ESP32 supports setting MCK on GPIO0/GPIO1/GPIO3 only*/
+    int bck_io_num;     /*!< BCK in out pin*/
+    int ws_io_num;      /*!< WS in out pin*/
+    int data_out_num;   /*!< DATA out pin*/
+    int data_in_num;    /*!< DATA in pin*/
+} i2s_pin_config_t;
+
+/**
+ * @brief I2S driver configuration parameters
+ *
+ */
+typedef struct {
+
+    i2s_mode_t              mode;                       /*!< I2S work mode */
+    uint32_t                sample_rate;                /*!< I2S sample rate */
+    i2s_bits_per_sample_t   bits_per_sample;            /*!< I2S sample bits in one channel */
+    i2s_channel_fmt_t       channel_format;             /*!< I2S channel format.*/
+    i2s_comm_format_t       communication_format;       /*!< I2S communication format */
+    int                     intr_alloc_flags;           /*!< Flags used to allocate the interrupt. One or multiple (ORred) ESP_INTR_FLAG_* values. See esp_intr_alloc.h for more info */
+    int                     dma_buf_count;              /**< The total number of DMA buffers to receive/transmit data.
+                                                          * A descriptor includes some information such as buffer address,
+                                                          * the address of the next descriptor, and the buffer length.
+                                                          * Since one descriptor points to one buffer, therefore, 'dma_desc_num' can be interpreted as the total number of DMA buffers used to store data from DMA interrupt.
+                                                          * Notice that these buffers are internal to'i2s_read' and descriptors are created automatically inside of the I2S driver.
+                                                          * Users only need to set the buffer number while the length is derived from the parameter described below.
+                                                          */
+    int                     dma_buf_len;                /**< Number of frames in a DMA buffer.
+                                                          *  A frame means the data of all channels in a WS cycle.
+                                                          *  The real_dma_buf_size = dma_buf_len * chan_num * bits_per_chan / 8.
+                                                          *  For example, if two channels in stereo mode (i.e., 'channel_format' is set to 'I2S_CHANNEL_FMT_RIGHT_LEFT') are active,
+                                                          *  and each channel transfers 32 bits (i.e., 'bits_per_sample' is set to 'I2S_BITS_PER_CHAN_32BIT'),
+                                                          *  then the total number of bytes of a frame is 'channel_format' * 'bits_per_sample' = 2 * 32 / 8 = 8 bytes.
+                                                          *  We assume that the current 'dma_buf_len' is 100, then the real length of the DMA buffer is 8 * 100 = 800 bytes.
+                                                          *  Note that the length of an internal real DMA buffer shouldn't be greater than 4092.
+                                                          */
+
+    bool                    use_apll;                   /*!< I2S using APLL as main I2S clock, enable it to get accurate clock */
+    bool                    tx_desc_auto_clear;         /*!< I2S auto clear tx descriptor if there is underflow condition (helps in avoiding noise in case of data unavailability) */
+    int                     fixed_mclk;                 /*!< I2S using fixed MCLK output. If use_apll = true and fixed_mclk > 0, then the clock output for i2s is fixed and equal to the fixed_mclk value. If fixed_mclk set, mclk_multiple won't take effect */
+    i2s_mclk_multiple_t     mclk_multiple;              /*!< The multiple of I2S master clock(MCLK) to sample rate */
+    i2s_bits_per_chan_t     bits_per_chan;              /*!< I2S total bits in one channel， only take effect when larger than 'bits_per_sample', default '0' means equal to 'bits_per_sample' */
+
+#if SOC_I2S_SUPPORTS_TDM
+    i2s_channel_t           chan_mask;                  /*!< I2S active channel bit mask, set value in `i2s_channel_t` to enable specific channel, the bit map of active channel can not exceed (0x1<<total_chan). */
+    uint32_t                total_chan;                 /*!< I2S Total number of channels. If it is smaller than the biggest active channel number, it will be set to this number automatically. */
+    bool                    left_align;                 /*!< Set to enable left alignment */
+    bool                    big_edin;                   /*!< Set to enable big edin */
+    bool                    bit_order_msb;              /*!< Set to enable msb order */
+    bool                    skip_msk;                   /*!< Set to enable skip mask. If it is enabled, only the data of the enabled channels will be sent, otherwise all data stored in DMA TX buffer will be sent */
+#endif // SOC_I2S_SUPPORTS_TDM
+
+} i2s_driver_config_t;
+
+typedef i2s_driver_config_t i2s_config_t;       // for backward compatible
+typedef intr_handle_t i2s_isr_handle_t;         // for backward compatible
+
+/**
+ * @brief I2S event queue types
+ *
+ */
+typedef enum {
+    I2S_EVENT_DMA_ERROR,
+    I2S_EVENT_TX_DONE,     /*!< I2S DMA finish sent 1 buffer*/
+    I2S_EVENT_RX_DONE,     /*!< I2S DMA finish received 1 buffer*/
+    I2S_EVENT_TX_Q_OVF,    /*!< I2S DMA sent queue overflow*/
+    I2S_EVENT_RX_Q_OVF,    /*!< I2S DMA receive queue overflow*/
+    I2S_EVENT_MAX,         /*!< I2S event max index*/
+} i2s_event_type_t;
+
+/**
+ * @brief Event structure used in I2S event queue
+ *
+ */
+typedef struct {
+    i2s_event_type_t    type;   /*!< I2S event type */
+    size_t              size;   /*!< I2S data size for I2S_DATA event*/
+} i2s_event_t;
+
+/**
+ * @brief Set I2S pin number
+ *
+ * @note
+ * The I2S peripheral output signals can be connected to multiple GPIO pads.
+ * However, the I2S peripheral input signal can only be connected to one GPIO pad.
+ *
+ * @param   i2s_num     I2S port number
+ *
+ * @param   pin         I2S Pin structure, or NULL to set 2-channel 8-bit internal DAC pin configuration (GPIO25 & GPIO26)
+ *
+ * Inside the pin configuration structure, set I2S_PIN_NO_CHANGE for any pin where
+ * the current configuration should not be changed.
+ *
+ * @note if *pin is set as NULL, this function will initialize both of the built-in DAC channels by default.
+ *       if you don't want this to happen and you want to initialize only one of the DAC channels, you can call i2s_set_dac_mode instead.
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_FAIL            IO error
+ */
+esp_err_t m_i2s_set_pin(i2s_port_t i2s_num, const i2s_pin_config_t *pin);
+
+#if SOC_I2S_SUPPORTS_PDM_RX
+/**
+ * @brief Set PDM mode down-sample rate
+ *        In PDM RX mode, there would be 2 rounds of downsample process in hardware.
+ *        In the first downsample process, the sampling number can be 16 or 8.
+ *        In the second downsample process, the sampling number is fixed as 8.
+ *        So the clock frequency in PDM RX mode would be (fpcm * 64) or (fpcm * 128) accordingly.
+ * @param i2s_num I2S port number
+ * @param downsample i2s RX down sample rate for PDM mode.
+ *
+ * @note After calling this function, it would call i2s_set_clk inside to update the clock frequency.
+ *       Please call this function after I2S driver has been initialized.
+ *
+ * @return
+ *     - ESP_OK Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ */
+esp_err_t m_i2s_set_pdm_rx_down_sample(i2s_port_t i2s_num, i2s_pdm_dsr_t downsample);
+#endif
+
+#if SOC_I2S_SUPPORTS_PDM_TX
+/**
+ * @brief Set TX PDM mode up-sample rate
+ * @note  If you have set PDM mode while calling 'i2s_driver_install',
+ *        default PDM TX upsample parameters have already been set,
+ *        no need to call this function again if you don't have to change the default configuration
+ *
+ * @param i2s_num I2S port number
+ * @param upsample_cfg Set I2S PDM up-sample rate configuration
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ */
+esp_err_t m_i2s_set_pdm_tx_up_sample(i2s_port_t i2s_num, const i2s_pdm_tx_upsample_cfg_t *upsample_cfg);
+#endif
+
+/**
+ * @brief Install and start I2S driver.
+ *
+ * @param i2s_num         I2S port number
+ *
+ * @param i2s_config      I2S configurations - see i2s_config_t struct
+ *
+ * @param queue_size      I2S event queue size/depth.
+ *
+ * @param i2s_queue       I2S event queue handle, if set NULL, driver will not use an event queue.
+ *
+ * This function must be called before any I2S driver read/write operations.
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ *     - ESP_ERR_INVALID_STATE  Current I2S port is in use
+ */
+esp_err_t m_i2s_driver_install(i2s_port_t i2s_num, const i2s_config_t *i2s_config, int queue_size, void *i2s_queue);
+
+/**
+ * @brief Uninstall I2S driver.
+ *
+ * @param i2s_num  I2S port number
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_INVALID_STATE I2S port has been uninstalled by others (e.g. LCD i80)
+ */
+esp_err_t m_i2s_driver_uninstall(i2s_port_t i2s_num);
+
+/**
+ * @brief Write data to I2S DMA transmit buffer.
+ *
+ * @param i2s_num             I2S port number
+ *
+ * @param src                 Source address to write from
+ *
+ * @param size                Size of data in bytes
+ *
+ * @param[out] bytes_written  Number of bytes written, if timeout, the result will be less than the size passed in.
+ *
+ * @param ticks_to_wait       TX buffer wait timeout in RTOS ticks. If this
+ * many ticks pass without space becoming available in the DMA
+ * transmit buffer, then the function will return (note that if the
+ * data is written to the DMA buffer in pieces, the overall operation
+ * may still take longer than this timeout.) Pass portMAX_DELAY for no
+ * timeout.
+ *
+ * @return
+ *     - ESP_OK               Success
+ *     - ESP_ERR_INVALID_ARG  Parameter error
+ */
+esp_err_t m_i2s_write(i2s_port_t i2s_num, const void *src, size_t size, size_t *bytes_written, TickType_t ticks_to_wait);
+
+/**
+ * @brief Write data to I2S DMA transmit buffer while expanding the number of bits per sample. For example, expanding 16-bit PCM to 32-bit PCM.
+ *
+ * @param i2s_num             I2S port number
+ *
+ * @param src                 Source address to write from
+ *
+ * @param size                Size of data in bytes
+ *
+ * @param src_bits            Source audio bit
+ *
+ * @param aim_bits            Bit wanted, no more than 32, and must be greater than src_bits
+ *
+ * @param[out] bytes_written  Number of bytes written, if timeout, the result will be less than the size passed in.
+ *
+ * @param ticks_to_wait       TX buffer wait timeout in RTOS ticks. If this
+ * many ticks pass without space becoming available in the DMA
+ * transmit buffer, then the function will return (note that if the
+ * data is written to the DMA buffer in pieces, the overall operation
+ * may still take longer than this timeout.) Pass portMAX_DELAY for no
+ * timeout.
+ *
+ * Format of the data in source buffer is determined by the I2S
+ * configuration (see i2s_config_t).
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_write_expand(i2s_port_t i2s_num, const void *src, size_t size, size_t src_bits, size_t aim_bits, size_t *bytes_written, TickType_t ticks_to_wait);
+
+/**
+ * @brief Read data from I2S DMA receive buffer
+ *
+ * @param i2s_num         I2S port number
+ *
+ * @param dest            Destination address to read into
+ *
+ * @param size            Size of data in bytes
+ *
+ * @param[out] bytes_read Number of bytes read, if timeout, bytes read will be less than the size passed in.
+ *
+ * @param ticks_to_wait   RX buffer wait timeout in RTOS ticks. If this many ticks pass without bytes becoming available in the DMA receive buffer, then the function will return (note that if data is read from the DMA buffer in pieces, the overall operation may still take longer than this timeout.) Pass portMAX_DELAY for no timeout.
+ *
+ * @note If the built-in ADC mode is enabled, we should call i2s_adc_enable and i2s_adc_disable around the whole reading process,
+ *       to prevent the data getting corrupted.
+ *
+ * @return
+ *     - ESP_OK               Success
+ *     - ESP_ERR_INVALID_ARG  Parameter error
+ */
+esp_err_t m_i2s_read(i2s_port_t i2s_num, void *dest, size_t size, size_t *bytes_read, TickType_t ticks_to_wait);
+
+/**
+ * @brief Set sample rate used for I2S RX and TX.
+ *
+ * The bit clock rate is determined by the sample rate and i2s_config_t configuration parameters (number of channels, bits_per_sample).
+ *
+ * `bit_clock = rate * (number of channels) * bits_per_sample`
+ *
+ * @param i2s_num  I2S port number
+ *
+ * @param rate I2S sample rate (ex: 8000, 44100...)
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ */
+esp_err_t m_i2s_set_sample_rates(i2s_port_t i2s_num, uint32_t rate);
+
+/**
+ * @brief Stop I2S driver
+ *
+ * There is no need to call i2s_stop() before calling i2s_driver_uninstall().
+ *
+ * Disables I2S TX/RX, until i2s_start() is called.
+ *
+ * @param i2s_num  I2S port number
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_stop(i2s_port_t i2s_num);
+
+/**
+ * @brief Start I2S driver
+ *
+ * It is not necessary to call this function after i2s_driver_install() (it is started automatically), however it is necessary to call it after i2s_stop().
+ *
+ *
+ * @param i2s_num  I2S port number
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_start(i2s_port_t i2s_num);
+
+/**
+ * @brief Zero the contents of the TX DMA buffer.
+ *
+ * Pushes zero-byte samples into the TX DMA buffer, until it is full.
+ *
+ * @param i2s_num  I2S port number
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_zero_dma_buffer(i2s_port_t i2s_num);
+
+#if SOC_I2S_SUPPORTS_PCM
+/**
+ * @brief Configure I2S a/u-law decompress or compress
+ *
+ * @note  This function should be called after i2s driver installed
+ *        Only take effecttive when the i2s 'communication_format' is set to 'I2S_COMM_FORMAT_STAND_PCM_SHORT' or 'I2S_COMM_FORMAT_STAND_PCM_LONG'
+ *
+ * @param i2s_num  I2S port number
+ *
+ * @param pcm_cfg  including mode selection and a/u-law decompress or compress configuration paramater
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t i2s_pcm_config(i2s_port_t i2s_num, const i2s_pcm_cfg_t *pcm_cfg);
+#endif
+
+/**
+ * @brief Set clock & bit width used for I2S RX and TX.
+ *
+ * Similar to i2s_set_sample_rates(), but also sets bit width.
+ *
+ * 1. stop i2s;
+ * 2. calculate mclk, bck, bck_factor
+ * 3. malloc dma buffer;
+ * 4. start i2s
+ *
+ * @param i2s_num  I2S port number
+ *
+ * @param rate I2S sample rate (ex: 8000, 44100...)
+ *
+ * @param bits_cfg I2S bits configuration
+ *             the low 16 bits is for data bits per sample in one channel (see 'i2s_bits_per_sample_t')
+ *             the high 16 bits is for total bits in one channel (see 'i2s_bits_per_chan_t')
+ *             high 16bits =0 means same as the bits per sample.
+ *
+ * @param ch I2S channel, (I2S_CHANNEL_MONO, I2S_CHANNEL_STEREO or specific channel in TDM mode)
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ */
+esp_err_t m_i2s_set_clk(i2s_port_t i2s_num, uint32_t rate, uint32_t bits_cfg, i2s_channel_t ch);
+
+/**
+ * @brief get clock set on particular port number.
+ *
+ * @param i2s_num  I2S port number
+ *
+ * @return
+ *     - actual clock set by i2s driver
+ */
+float m_i2s_get_clk(i2s_port_t i2s_num);
+
+#if SOC_I2S_SUPPORTS_ADC
+/**
+ * @brief Set built-in ADC mode for I2S DMA, this function will initialize ADC pad,
+ *        and set ADC parameters.
+ * @note  In this mode, the ADC maximum sampling rate is 150KHz. Set the sampling rate through ``i2s_config_t``.
+ * @param adc_unit    SAR ADC unit index
+ * @param adc_channel ADC channel index
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_set_adc_mode(adc_unit_t adc_unit, adc1_channel_t adc_channel);
+
+/**
+ * @brief Start to use I2S built-in ADC mode
+ * @note This function would acquire the lock of ADC to prevent the data getting corrupted
+ *       during the I2S peripheral is being used to do fully continuous ADC sampling.
+ *
+ * @param i2s_num i2s port index
+ * @return
+ *     - ESP_OK                Success
+ *     - ESP_ERR_INVALID_ARG   Parameter error
+ *     - ESP_ERR_INVALID_STATE Driver state error
+ */
+esp_err_t m_i2s_adc_enable(i2s_port_t i2s_num);
+
+/**
+ * @brief Stop to use I2S built-in ADC mode
+ * @param i2s_num i2s port index
+ * @note This function would release the lock of ADC so that other tasks can use ADC.
+ * @return
+ *     - ESP_OK                 Success
+ *     - ESP_ERR_INVALID_ARG    Parameter error
+ *     - ESP_ERR_INVALID_STATE  Driver state error
+ */
+esp_err_t m_i2s_adc_disable(i2s_port_t i2s_num);
+#endif // SOC_I2S_SUPPORTS_ADC
+
+#if SOC_I2S_SUPPORTS_DAC
+/**
+ * @brief Set I2S dac mode, I2S built-in DAC is disabled by default
+ *
+ * @param dac_mode DAC mode configurations - see i2s_dac_mode_t
+ *
+ * @note Built-in DAC functions are only supported on I2S0 for current ESP32 chip.
+ *       If either of the built-in DAC channel are enabled, the other one can not
+ *       be used as RTC DAC function at the same time.
+ *
+ * @return
+ *     - ESP_OK               Success
+ *     - ESP_ERR_INVALID_ARG  Parameter error
+ */
+esp_err_t m_i2s_set_dac_mode(i2s_dac_mode_t dac_mode);
+#endif //SOC_I2S_SUPPORTS_DAC
+
+/**
+ * @brief Associate GPIO MUX signal with GPIO pad.
+ *
+ * @param gpio Pad identifier or -1 for no connection
+ * @param signal_idx Signal index to connect
+ * @param out_inv Output inversion flag
+ * @param oen_inv Output enable inversion flag
+ *
+ */
+void m_gpio_matrix_out_check_and_set(gpio_num_t gpio, uint32_t signal_idx, bool out_inv, bool oen_inv);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // defined(SUPPORT_I2S)
diff --git a/src/output/OutputI2S.cpp b/src/output/OutputI2S.cpp
index 0feab0710..f4768d8cb 100644
--- a/src/output/OutputI2S.cpp
+++ b/src/output/OutputI2S.cpp
@@ -17,7 +17,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_I2S)
 
 #include "output/OutputI2S.hpp"
 #include "m_i2s.h"
@@ -352,4 +352,4 @@ void IRAM_ATTR c_OutputI2S::ISR_ProcessDma ()
 
 } // ISR_ProcessDma
 
-#endif // defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_I2S)
diff --git a/src/service/m_i2s.c b/src/service/m_i2s.c
new file mode 100644
index 000000000..20e0b6042
--- /dev/null
+++ b/src/service/m_i2s.c
@@ -0,0 +1,2327 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <string.h>
+#include <stdbool.h>
+#include <math.h>
+#include <esp_types.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+
+#include "soc/lldesc.h"
+#include "driver/gpio.h"
+#include "m_i2s.h"
+#include "hal/gpio_hal.h"
+#include "hal/i2s_hal.h"
+#if _SOC_I2S_SUPPORTS_DAC
+#include "driver/dac.h"
+#endif // _SOC_I2S_SUPPORTS_DAC
+
+#if _SOC_I2S_SUPPORTS_ADC
+#include "adc1_private.h"
+#endif // _SOC_I2S_SUPPORTS_ADC
+
+#if SOC_GDMA_SUPPORTED
+#include "esp_private/gdma.h"
+#endif
+
+#include "soc/clk_ctrl_os.h"
+#include "esp_intr_alloc.h"
+#include "esp_err.h"
+#include "esp_check.h"
+#include "esp_attr.h"
+#include "esp_log.h"
+#include "esp_pm.h"
+#include "esp_efuse.h"
+#include "esp_rom_gpio.h"
+#include "esp_private/i2s_platform.h"
+#include "esp_private/sar_periph_ctrl.h"
+
+#include "sdkconfig.h"
+
+static const char *TAG = "I2S";
+
+#define I2S_ENTER_CRITICAL_ISR(i2s_num)          portENTER_CRITICAL_ISR(&i2s_spinlock[i2s_num])
+#define I2S_EXIT_CRITICAL_ISR(i2s_num)           portEXIT_CRITICAL_ISR(&i2s_spinlock[i2s_num])
+#define I2S_ENTER_CRITICAL(i2s_num)              portENTER_CRITICAL(&i2s_spinlock[i2s_num])
+#define I2S_EXIT_CRITICAL(i2s_num)               portEXIT_CRITICAL(&i2s_spinlock[i2s_num])
+
+#define I2S_DMA_BUFFER_MAX_SIZE     4092
+
+#if !SOC_GDMA_SUPPORTED
+#define I2S_INTR_IN_SUC_EOF   BIT(9)
+#define I2S_INTR_OUT_EOF      BIT(12)
+#define I2S_INTR_IN_DSCR_ERR  BIT(13)
+#define I2S_INTR_OUT_DSCR_ERR BIT(14)
+#define I2S_INTR_MAX          (~0)
+#endif
+
+/**
+ * @brief DMA buffer object
+ *
+ */
+typedef struct {
+    char **buf;
+    int buf_size;
+    volatile int rw_pos;
+    volatile void *curr_ptr;
+    SemaphoreHandle_t mux;
+    xQueueHandle queue;
+    lldesc_t **desc;
+} i2s_dma_t;
+
+/**
+ * @brief I2S object instance
+ *
+ */
+typedef struct {
+    i2s_port_t i2s_num;         /*!< I2S port number*/
+    int queue_size;             /*!< I2S event queue size*/
+    QueueHandle_t i2s_queue;    /*!< I2S queue handler*/
+    int dma_buf_count;          /*!< DMA buffer count, number of buffer*/
+    int dma_buf_len;            /*!< DMA buffer length, length of each buffer*/
+    uint32_t last_buf_size;     /*!< DMA last buffer size */
+    i2s_dma_t *tx;              /*!< DMA Tx buffer*/
+    i2s_dma_t *rx;              /*!< DMA Rx buffer*/
+#if SOC_GDMA_SUPPORTED
+    gdma_channel_handle_t rx_dma_chan;  /*!< I2S rx gDMA channel handle*/
+    gdma_channel_handle_t tx_dma_chan;  /*!< I2S tx gDMA channel handle*/
+#else
+    i2s_isr_handle_t i2s_isr_handle; /*!< I2S Interrupt handle*/
+#endif
+    bool tx_desc_auto_clear;    /*!< I2S auto clear tx descriptor on underflow */
+    bool use_apll;              /*!< I2S use APLL clock */
+    int fixed_mclk;             /*!< I2S fixed MLCK clock */
+    i2s_mclk_multiple_t mclk_multiple; /*!< The multiple of I2S master clock(MCLK) to sample rate */
+
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_handle_t pm_lock;
+#endif
+    i2s_hal_context_t hal;      /*!< I2S hal context*/
+    i2s_channel_fmt_t   init_chan_fmt;  /*!< The initial channel format while installing, used for keep left or right mono when switch between mono and stereo */
+    i2s_hal_config_t hal_cfg;   /*!< I2S hal configurations*/
+} i2s_obj_t;
+
+static i2s_obj_t *p_i2s[SOC_I2S_NUM];
+static portMUX_TYPE i2s_platform_spinlock = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED;
+static portMUX_TYPE i2s_spinlock[SOC_I2S_NUM] = {
+    [0 ... SOC_I2S_NUM - 1] = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED,
+};
+
+#if _SOC_I2S_SUPPORTS_ADC
+static int _i2s_adc_unit = -1;
+static int _i2s_adc_channel = -1;
+#endif
+
+/*
+ * This block is an overview of APIs in i2s.c
+ * Functions with [main] tag are summary functions that provide main i2s service
+ * Functions with [helper] tag are helper functions that served for summary functions
+ * Functions with [intr] tag are interrupt handling functions or interrupt callback functions
+  -------------------------------------------------------------
+                    I2S GPIO operation
+  -------------------------------------------------------------
+   - [helper]   gpio_matrix_out_check_and_set
+   - [helper]   gpio_matrix_in_check_and_set
+   - [helper]   i2s_check_set_mclk
+   - [main]     i2s_set_pin
+  -------------------------------------------------------------
+                    I2S DMA operation
+  -------------------------------------------------------------
+   - [intr]     i2s_dma_rx_callback
+   - [intr]     i2s_dma_tx_callback
+   - [intr]     i2s_intr_handler_default
+   - [helper]   i2s_dma_intr_init
+   - [helper]   i2s_tx_reset
+   - [helper]   i2s_rx_reset
+   - [helper]   i2s_tx_start
+   - [helper]   i2s_rx_start
+   - [helper]   i2s_tx_stop
+   - [helper]   i2s_rx_stop
+  -------------------------------------------------------------
+                   I2S buffer operation
+  -------------------------------------------------------------
+   - [helper]   i2s_get_buf_size
+   - [helper]   i2s_delete_dma_buffer
+   - [helper]   i2s_alloc_dma_buffer
+   - [main]     i2s_realloc_dma_buffer
+   - [main]     i2s_destroy_dma_object
+   - [main]     i2s_create_dma_object
+   - [main]     i2s_zero_dma_buffer
+  -------------------------------------------------------------
+                   I2S clock operation
+  -------------------------------------------------------------
+   - [helper]   i2s_config_source_clock
+   - [helper]   i2s_calculate_adc_dac_clock
+   - [helper]   i2s_calculate_pdm_tx_clock
+   - [helper]   i2s_calculate_pdm_rx_clock
+   - [helper]   i2s_calculate_common_clock
+   - [main]     i2s_calculate_clock
+  -------------------------------------------------------------
+                   I2S configuration
+  -------------------------------------------------------------
+   - [helper]   i2s_get_max_channel_num
+   - [helper]   i2s_get_active_channel_num
+   - [helper]   i2s_set_dac_mode
+   - [helper]   _i2s_adc_mode_recover
+   - [main]     i2s_set_adc_mode
+   - [main]     i2s_adc_enable
+   - [main]     i2s_adc_disable
+   - [helper]   i2s_set_sample_rates
+   - [main]     i2s_pcm_config
+   - [helper]   i2s_set_pdm_rx_down_sample
+   - [helper]   i2s_set_pdm_tx_up_sample
+   - [helper]   i2s_check_cfg_validity
+   - [helper]   i2s_tx_set_clk_and_channel
+   - [helper]   i2s_rx_set_clk_and_channel
+   - [main]     i2s_get_clk
+   - [main]     i2s_set_clk
+  -------------------------------------------------------------
+                   I2S driver operation
+  -------------------------------------------------------------
+   - [main]     i2s_start
+   - [main]     i2s_stop
+   - [helper]   i2s_driver_init
+   - [helper]   i2s_dma_object_init
+   - [main]     i2s_driver_install
+   - [main]     i2s_driver_uninstall
+   - [main]     i2s_write
+   - [main]     i2s_write_expand
+   - [main]     i2s_read
+  -------------------------------------------------------------*/
+
+/*-------------------------------------------------------------
+                    I2S GPIO operation
+  -------------------------------------------------------------*/
+/**
+ * @brief   I2S GPIO matrix set ouput
+ *
+ * @param   gpio          GPIO number
+ * @param   singal_idx    GPIO singnal ID, refer to 'gpio_sig_map.h'
+ * @param   out_inv       Output invert enable
+ * @param   oen_inv       Output eanble control invert enable
+ */
+void m_gpio_matrix_out_check_and_set(gpio_num_t gpio, uint32_t signal_idx, bool out_inv, bool oen_inv)
+{
+    //if pin = -1, disconnect the signal from GPIO matrix, and connect the signal to SIG_GPIO_OUT_IDX, which is a dummy output signal.
+    if (gpio == -1) 
+    {
+        esp_rom_gpio_connect_out_signal(signal_idx, SIG_GPIO_OUT_IDX, false, false);
+    }
+    else
+    {
+        gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
+        gpio_set_direction(gpio, GPIO_MODE_OUTPUT);
+        esp_rom_gpio_connect_out_signal(gpio, signal_idx, out_inv, oen_inv);
+    }
+}
+
+/**
+ * @brief   I2S GPIO matrix set input
+ *
+ * @param   gpio          GPIO number
+ * @param   singal_idx    GPIO singnal ID, refer to 'gpio_sig_map.h'
+ * @param   out_inv       Output invert enable
+ * @param   oen_inv       Output eanble control invert enable
+ */
+static void m_gpio_matrix_in_check_and_set(gpio_num_t gpio, uint32_t signal_idx, bool inv)
+{
+    if (gpio != -1) {
+        gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
+        /* Set direction, for some GPIOs, the input function are not enabled as default */
+        gpio_set_direction(gpio, GPIO_MODE_INPUT);
+        esp_rom_gpio_connect_in_signal(gpio, signal_idx, inv);
+    }
+}
+
+/**
+ * @brief   I2S set GPIO for mclk
+ *
+ * @param   i2s_num     I2S device number
+ * @param   gpio_num    GPIO number for mclk
+ * @return
+ *      - ESP_OK                Check or set success
+ *      - ESP_ERR_INVALID_ARG   GPIO is not available
+ */
+static esp_err_t m_i2s_check_set_mclk(i2s_port_t i2s_num, gpio_num_t gpio_num)
+{
+    if (gpio_num == -1) {
+        return ESP_OK;
+    }
+#if CONFIG_IDF_TARGET_ESP32
+    ESP_RETURN_ON_FALSE((gpio_num == GPIO_NUM_0 || gpio_num == GPIO_NUM_1 || gpio_num == GPIO_NUM_3),
+                        ESP_ERR_INVALID_ARG, TAG,
+                        "ESP32 only support to set GPIO0/GPIO1/GPIO3 as mclk signal, error GPIO number:%d", gpio_num);
+    bool is_i2s0 = i2s_num == I2S_NUM_0;
+    if (gpio_num == GPIO_NUM_0) {
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0_CLK_OUT1);
+        WRITE_PERI_REG(PIN_CTRL, is_i2s0 ? 0xFFF0 : 0xFFFF);
+    } else if (gpio_num == GPIO_NUM_1) {
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_U0TXD_CLK_OUT3);
+        WRITE_PERI_REG(PIN_CTRL, is_i2s0 ? 0xF0F0 : 0xF0FF);
+    } else {
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_U0RXD_CLK_OUT2);
+        WRITE_PERI_REG(PIN_CTRL, is_i2s0 ? 0xFF00 : 0xFF0F);
+    }
+#else
+    ESP_RETURN_ON_FALSE(GPIO_IS_VALID_GPIO(gpio_num), ESP_ERR_INVALID_ARG, TAG, "mck_io_num invalid");
+    gpio_matrix_out_check_and_set(gpio_num, i2s_periph_signal[i2s_num].mck_out_sig, 0, 0);
+#endif
+    ESP_LOGI(TAG, "I2S%d, MCLK output by GPIO%d", i2s_num, gpio_num);
+    return ESP_OK;
+}
+
+/**
+ * @brief   Set gpio pins for I2S
+ *
+ * @param   i2s_num     I2S device number
+ * @param   pin         Pin configuration
+ * @return
+ *      - ESP_OK                Set pin success
+ *      - ESP_ERR_INVALID_ARG   GPIO is not available
+ */
+esp_err_t m_i2s_set_pin(i2s_port_t i2s_num, const i2s_pin_config_t *pin)
+{
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    if (pin == NULL) {
+#if _SOC_I2S_SUPPORTS_DAC
+        return m_i2s_set_dac_mode(I2S_DAC_CHANNEL_BOTH_EN);
+#else
+        return ESP_ERR_INVALID_ARG;
+#endif
+    }
+    /* Check validity of selected pins */
+    ESP_RETURN_ON_FALSE((pin->bck_io_num == -1 || GPIO_IS_VALID_GPIO(pin->bck_io_num)),
+                        ESP_ERR_INVALID_ARG, TAG, "bck_io_num invalid");
+    ESP_RETURN_ON_FALSE((pin->ws_io_num == -1 || GPIO_IS_VALID_GPIO(pin->ws_io_num)),
+                        ESP_ERR_INVALID_ARG, TAG, "ws_io_num invalid");
+    ESP_RETURN_ON_FALSE((pin->data_out_num == -1 || GPIO_IS_VALID_GPIO(pin->data_out_num)),
+                        ESP_ERR_INVALID_ARG, TAG, "data_out_num invalid");
+    ESP_RETURN_ON_FALSE((pin->data_in_num == -1 || GPIO_IS_VALID_GPIO(pin->data_in_num)),
+                        ESP_ERR_INVALID_ARG, TAG, "data_in_num invalid");
+
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_SLAVE) {
+        /* For "tx + rx + slave" or "rx + slave" mode, we should select RX signal index for ws and bck */
+        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+            m_gpio_matrix_in_check_and_set(pin->ws_io_num, i2s_periph_signal[i2s_num].s_rx_ws_sig, 0);
+            m_gpio_matrix_in_check_and_set(pin->bck_io_num, i2s_periph_signal[i2s_num].s_rx_bck_sig, 0);
+            /* For "tx + slave" mode, we should select TX signal index for ws and bck */
+        } else {
+            m_gpio_matrix_in_check_and_set(pin->ws_io_num, i2s_periph_signal[i2s_num].s_tx_ws_sig, 0);
+            m_gpio_matrix_in_check_and_set(pin->bck_io_num, i2s_periph_signal[i2s_num].s_tx_bck_sig, 0);
+        }
+    } else {
+        /* mclk only available in master mode */
+        ESP_RETURN_ON_ERROR(m_i2s_check_set_mclk(i2s_num, pin->mck_io_num), TAG, "mclk config failed");
+        /* For "tx + rx + master" or "tx + master" mode, we should select TX signal index for ws and bck */
+        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+            m_gpio_matrix_out_check_and_set(pin->ws_io_num, i2s_periph_signal[i2s_num].m_tx_ws_sig, 0, 0);
+            m_gpio_matrix_out_check_and_set(pin->bck_io_num, i2s_periph_signal[i2s_num].m_tx_bck_sig, 0, 0);
+            /* For "rx + master" mode, we should select RX signal index for ws and bck */
+        } else {
+            m_gpio_matrix_out_check_and_set(pin->ws_io_num, i2s_periph_signal[i2s_num].m_rx_ws_sig, 0, 0);
+            m_gpio_matrix_out_check_and_set(pin->bck_io_num, i2s_periph_signal[i2s_num].m_rx_bck_sig, 0, 0);
+        }
+    }
+
+    /* Set data input/ouput GPIO */
+    m_gpio_matrix_out_check_and_set(pin->data_out_num, i2s_periph_signal[i2s_num].data_out_sig, 0, 0);
+    m_gpio_matrix_in_check_and_set(pin->data_in_num, i2s_periph_signal[i2s_num].data_in_sig, 0);
+    return ESP_OK;
+}
+
+/*-------------------------------------------------------------
+                    I2S DMA operation
+  -------------------------------------------------------------*/
+#if SOC_GDMA_SUPPORTED
+/**
+ * @brief   GDMA rx callback function
+ * @note    This function is called by GDMA default ISR handler
+ *
+ * @param   dma_chan    GDMA channel handler
+ * @param   event_data  GDMA rx event data
+ * @param   user_data   GDMA user data
+ * @return
+ *      - true  need yield
+ *      - false no need
+ */
+static bool IRAM_ATTR m_i2s_dma_rx_callback(gdma_channel_handle_t dma_chan, gdma_event_data_t *event_data, void *user_data)
+{
+    i2s_obj_t *p_i2s = (i2s_obj_t *) user_data;
+    portBASE_TYPE need_awoke = 0;
+    portBASE_TYPE tmp = 0;
+    int dummy;
+    i2s_event_t i2s_event;
+    uint32_t finish_desc;
+
+    if (p_i2s->rx) {
+        finish_desc = event_data->rx_eof_desc_addr;
+        i2s_event.size = ((lldesc_t *)finish_desc)->size;
+        if (xQueueIsQueueFullFromISR(p_i2s->rx->queue)) {
+            xQueueReceiveFromISR(p_i2s->rx->queue, &dummy, &tmp);
+            need_awoke |= tmp;
+            if (p_i2s->i2s_queue) {
+                i2s_event.type = I2S_EVENT_RX_Q_OVF;
+                xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
+                need_awoke |= tmp;
+            }
+        }
+        xQueueSendFromISR(p_i2s->rx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
+        need_awoke |= tmp;
+        if (p_i2s->i2s_queue) {
+            i2s_event.type = I2S_EVENT_RX_DONE;
+            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
+            need_awoke |= tmp;
+        }
+    }
+    return need_awoke;
+}
+
+/**
+ * @brief   GDMA tx callback function
+ * @note    This function is called by GDMA default ISR handler
+ *
+ * @param   dma_chan    GDMA channel handler
+ * @param   event_data  GDMA tx event data
+ * @param   user_data   GDMA user data
+ * @return
+ *      - whether need yield
+ */
+static bool IRAM_ATTR m_i2s_dma_tx_callback(gdma_channel_handle_t dma_chan, gdma_event_data_t *event_data, void *user_data)
+{
+    i2s_obj_t *p_i2s = (i2s_obj_t *) user_data;
+    portBASE_TYPE need_awoke = 0;
+    portBASE_TYPE tmp = 0;
+    int dummy;
+    i2s_event_t i2s_event;
+    uint32_t finish_desc;
+    if (p_i2s->tx) {
+        finish_desc = event_data->tx_eof_desc_addr;
+        i2s_event.size = ((lldesc_t *)finish_desc)->size;
+        if (xQueueIsQueueFullFromISR(p_i2s->tx->queue)) {
+            xQueueReceiveFromISR(p_i2s->tx->queue, &dummy, &tmp);
+            need_awoke |= tmp;
+            if (p_i2s->i2s_queue) {
+                i2s_event.type = I2S_EVENT_TX_Q_OVF;
+                i2s_event.size = p_i2s->tx->buf_size;
+                xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
+                need_awoke |= tmp;
+            }
+        }
+        if (p_i2s->tx_desc_auto_clear) {
+            memset((void *) (((lldesc_t *)finish_desc)->buf), 0, p_i2s->tx->buf_size);
+        }
+        xQueueSendFromISR(p_i2s->tx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
+        need_awoke |= tmp;
+        if (p_i2s->i2s_queue) {
+            i2s_event.type = I2S_EVENT_TX_DONE;
+            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
+            need_awoke |= tmp;
+        }
+    }
+    return need_awoke;
+}
+
+#else
+
+/**
+ * @brief   I2S defalut interrupt handler
+ * @note    This function is triggered by I2S dedicated DMA interrupt
+ *
+ * @param   arg      Argument transport to ISR, here is the pointer to I2S object
+ */
+static void IRAM_ATTR m_i2s_intr_handler_default(void *arg)
+{
+    i2s_obj_t *p_i2s = (i2s_obj_t *) arg;
+    uint32_t status = i2s_hal_get_intr_status(&(p_i2s->hal));
+    if (status == 0) {
+        //Avoid spurious interrupt
+        return;
+    }
+
+    i2s_event_t i2s_event;
+    int dummy;
+    portBASE_TYPE need_awoke = 0;
+    portBASE_TYPE tmp = 0;
+    uint32_t  finish_desc = 0;
+    if ((status & I2S_INTR_OUT_DSCR_ERR) || (status & I2S_INTR_IN_DSCR_ERR)) {
+        ESP_EARLY_LOGE(TAG, "dma error, interrupt status: 0x%08x", status);
+        if (p_i2s->i2s_queue) {
+            i2s_event.type = I2S_EVENT_DMA_ERROR;
+            if (xQueueIsQueueFullFromISR(p_i2s->i2s_queue)) {
+                xQueueReceiveFromISR(p_i2s->i2s_queue, &dummy, &tmp);
+                need_awoke |= tmp;
+            }
+            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
+            need_awoke |= tmp;
+        }
+    }
+
+    if ((status & I2S_INTR_OUT_EOF) && p_i2s->tx) {
+        i2s_hal_get_out_eof_des_addr(&(p_i2s->hal), &finish_desc);
+        i2s_event.size = ((lldesc_t *)finish_desc)->size;
+        // All buffers are empty. This means we have an underflow on our hands.
+        if (xQueueIsQueueFullFromISR(p_i2s->tx->queue)) {
+            xQueueReceiveFromISR(p_i2s->tx->queue, &dummy, &tmp);
+            need_awoke |= tmp;
+            if (p_i2s->i2s_queue) {
+                i2s_event.type = I2S_EVENT_TX_Q_OVF;
+                xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
+                need_awoke |= tmp;
+            }
+        }
+        // See if tx descriptor needs to be auto cleared:
+        // This will avoid any kind of noise that may get introduced due to transmission
+        // of previous data from tx descriptor on I2S line.
+        if (p_i2s->tx_desc_auto_clear) {
+            memset((void *) (((lldesc_t *)finish_desc)->buf), 0, p_i2s->tx->buf_size);
+        }
+        xQueueSendFromISR(p_i2s->tx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
+        need_awoke |= tmp;
+        if (p_i2s->i2s_queue) {
+            i2s_event.type = I2S_EVENT_TX_DONE;
+            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
+            need_awoke |= tmp;
+        }
+    }
+
+    if ((status & I2S_INTR_IN_SUC_EOF) && p_i2s->rx) {
+        // All buffers are full. This means we have an overflow.
+        i2s_hal_get_in_eof_des_addr(&(p_i2s->hal), &finish_desc);
+        i2s_event.size = ((lldesc_t *)finish_desc)->size;
+        if (xQueueIsQueueFullFromISR(p_i2s->rx->queue)) {
+            xQueueReceiveFromISR(p_i2s->rx->queue, &dummy, &tmp);
+            need_awoke |= tmp;
+            if (p_i2s->i2s_queue) {
+                i2s_event.type = I2S_EVENT_RX_Q_OVF;
+                xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
+                need_awoke |= tmp;
+            }
+        }
+        xQueueSendFromISR(p_i2s->rx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
+        need_awoke |= tmp;
+        if (p_i2s->i2s_queue) {
+            i2s_event.type = I2S_EVENT_RX_DONE;
+            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
+            need_awoke |= tmp;
+        }
+    }
+    i2s_hal_clear_intr_status(&(p_i2s->hal), status);
+
+    if (need_awoke == pdTRUE) {
+        portYIELD_FROM_ISR();
+    }
+}
+#endif
+
+
+/**
+ * @brief   I2S DMA interrupt initialization
+ * @note    I2S will use GDMA if chip supports, and the interrupt is triggered by GDMA.
+ *
+ * @param   i2s_num     I2S device number
+ * @return
+ *      - ESP_OK                    I2S DMA interrupt initialize success
+ *      - ESP_ERR_NOT_FOUND         GDMA channel not found
+ *      - ESP_ERR_INVALID_ARG       Invalid arguments
+ *      - ESP_ERR_INVALID_STATE     GDMA state error
+ */
+static esp_err_t m_i2s_dma_intr_init(i2s_port_t i2s_num, int intr_flag)
+{
+#if SOC_GDMA_SUPPORTED
+    /* Set GDMA trigger module */
+    gdma_trigger_t trig = {.periph = GDMA_TRIG_PERIPH_I2S};
+
+    switch (i2s_num) {
+#if SOC_I2S_NUM > 1
+    case I2S_NUM_1:
+        trig.instance_id = SOC_GDMA_TRIG_PERIPH_I2S1;
+        break;
+#endif
+    default:
+        trig.instance_id = SOC_GDMA_TRIG_PERIPH_I2S0;
+        break;
+    }
+
+    /* Set GDMA config */
+    gdma_channel_alloc_config_t dma_cfg = {};
+    if ( p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+        dma_cfg.direction = GDMA_CHANNEL_DIRECTION_TX;
+        /* Register a new GDMA tx channel */
+        ESP_RETURN_ON_ERROR(gdma_new_channel(&dma_cfg, &p_i2s[i2s_num]->tx_dma_chan), TAG, "Register tx dma channel error");
+        ESP_RETURN_ON_ERROR(gdma_connect(p_i2s[i2s_num]->tx_dma_chan, trig), TAG, "Connect tx dma channel error");
+        gdma_tx_event_callbacks_t cb = {.on_trans_eof = m_i2s_dma_tx_callback};
+        /* Set callback function for GDMA, the interrupt is triggered by GDMA, then the GDMA ISR will call the  callback function */
+        gdma_register_tx_event_callbacks(p_i2s[i2s_num]->tx_dma_chan, &cb, p_i2s[i2s_num]);
+    }
+    if ( p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+        dma_cfg.direction = GDMA_CHANNEL_DIRECTION_RX;
+        /* Register a new GDMA rx channel */
+        ESP_RETURN_ON_ERROR(gdma_new_channel(&dma_cfg, &p_i2s[i2s_num]->rx_dma_chan), TAG, "Register rx dma channel error");
+        ESP_RETURN_ON_ERROR(gdma_connect(p_i2s[i2s_num]->rx_dma_chan, trig), TAG, "Connect rx dma channel error");
+        gdma_rx_event_callbacks_t cb = {.on_recv_eof = m_i2s_dma_rx_callback};
+        /* Set callback function for GDMA, the interrupt is triggered by GDMA, then the GDMA ISR will call the  callback function */
+        gdma_register_rx_event_callbacks(p_i2s[i2s_num]->rx_dma_chan, &cb, p_i2s[i2s_num]);
+    }
+#else
+    /* Initial I2S module interrupt */
+    ESP_RETURN_ON_ERROR(esp_intr_alloc(i2s_periph_signal[i2s_num].irq, intr_flag, m_i2s_intr_handler_default, p_i2s[i2s_num], &p_i2s[i2s_num]->i2s_isr_handle), TAG, "Register I2S Interrupt error");
+#endif // SOC_GDMA_SUPPORTED
+    return ESP_OK;
+}
+
+/**
+ * @brief   I2S tx reset
+ *
+ * @param   i2s_num     I2S device number
+ */
+static void m_i2s_tx_reset(i2s_port_t i2s_num)
+{
+    p_i2s[i2s_num]->tx->curr_ptr = NULL;
+    p_i2s[i2s_num]->tx->rw_pos = 0;
+    i2s_hal_reset_tx(&(p_i2s[i2s_num]->hal));
+#if SOC_GDMA_SUPPORTED
+    gdma_reset(p_i2s[i2s_num]->tx_dma_chan);
+#else
+    i2s_hal_reset_txdma(&(p_i2s[i2s_num]->hal));
+#endif
+    i2s_hal_reset_tx_fifo(&(p_i2s[i2s_num]->hal));
+}
+
+/**
+ * @brief   I2S rx reset
+ *
+ * @param   i2s_num     I2S device number
+ */
+static void m_i2s_rx_reset(i2s_port_t i2s_num)
+{
+    p_i2s[i2s_num]->rx->curr_ptr = NULL;
+    p_i2s[i2s_num]->rx->rw_pos = 0;
+    i2s_hal_reset_rx(&(p_i2s[i2s_num]->hal));
+#if SOC_GDMA_SUPPORTED
+    gdma_reset(p_i2s[i2s_num]->rx_dma_chan);
+#else
+    i2s_hal_reset_rxdma(&(p_i2s[i2s_num]->hal));
+#endif
+    i2s_hal_reset_rx_fifo(&(p_i2s[i2s_num]->hal));
+}
+
+/**
+ * @brief   I2S tx start
+ *
+ * @param   i2s_num     I2S device number
+ */
+static void m_i2s_tx_start(i2s_port_t i2s_num)
+{
+#if SOC_GDMA_SUPPORTED
+    gdma_start(p_i2s[i2s_num]->tx_dma_chan, (uint32_t) p_i2s[i2s_num]->tx->desc[0]);
+#else
+    i2s_hal_enable_tx_dma(&(p_i2s[i2s_num]->hal));
+    i2s_hal_enable_tx_intr(&(p_i2s[i2s_num]->hal));
+    i2s_hal_start_tx_link(&(p_i2s[i2s_num]->hal), (uint32_t) p_i2s[i2s_num]->tx->desc[0]);
+#endif
+    i2s_hal_start_tx(&(p_i2s[i2s_num]->hal));
+}
+
+/**
+ * @brief   I2S rx start
+ *
+ * @param   i2s_num     I2S device number
+ */
+static void i2s_rx_start(i2s_port_t i2s_num)
+{
+#if SOC_GDMA_SUPPORTED
+    gdma_start(p_i2s[i2s_num]->rx_dma_chan, (uint32_t) p_i2s[i2s_num]->rx->desc[0]);
+#else
+    i2s_hal_enable_rx_dma(&(p_i2s[i2s_num]->hal));
+    i2s_hal_enable_rx_intr(&(p_i2s[i2s_num]->hal));
+    i2s_hal_start_rx_link(&(p_i2s[i2s_num]->hal), (uint32_t) p_i2s[i2s_num]->rx->desc[0]);
+#endif
+    i2s_hal_start_rx(&(p_i2s[i2s_num]->hal));
+}
+
+/**
+ * @brief   I2S tx stop
+ *
+ * @param   i2s_num     I2S device number
+ */
+static void m_i2s_tx_stop(i2s_port_t i2s_num)
+{
+    i2s_hal_stop_tx(&(p_i2s[i2s_num]->hal));
+#if SOC_GDMA_SUPPORTED
+    gdma_stop(p_i2s[i2s_num]->tx_dma_chan);
+#else
+    i2s_hal_stop_tx_link(&(p_i2s[i2s_num]->hal));
+    i2s_hal_disable_tx_intr(&(p_i2s[i2s_num]->hal));
+    i2s_hal_disable_tx_dma(&(p_i2s[i2s_num]->hal));
+#endif
+}
+
+/**
+ * @brief   I2S rx stop
+ *
+ * @param   i2s_num     I2S device number
+ */
+static void m_i2s_rx_stop(i2s_port_t i2s_num)
+{
+    i2s_hal_stop_rx(&(p_i2s[i2s_num]->hal));
+#if SOC_GDMA_SUPPORTED
+    gdma_stop(p_i2s[i2s_num]->rx_dma_chan);
+#else
+    i2s_hal_stop_rx_link(&(p_i2s[i2s_num]->hal));
+    i2s_hal_disable_rx_intr(&(p_i2s[i2s_num]->hal));
+    i2s_hal_disable_rx_dma(&(p_i2s[i2s_num]->hal));
+#endif
+}
+
+/*-------------------------------------------------------------
+                   I2S buffer operation
+  -------------------------------------------------------------*/
+/**
+ * @brief I2S get DMA buffer size
+ *
+ * @param   i2s_num     I2S device number
+ * @return
+ *      - DMA buffer size
+ */
+static inline uint32_t m_i2s_get_buf_size(i2s_port_t i2s_num)
+{
+    /* Calculate bytes per sample, align to 16 bit */
+    uint32_t bytes_per_sample = ((p_i2s[i2s_num]->hal_cfg.sample_bits + 15) / 16) * 2;
+    /* The DMA buffer limitation is 4092 bytes */
+    uint32_t bytes_per_frame = bytes_per_sample * p_i2s[i2s_num]->hal_cfg.active_chan;
+    p_i2s[i2s_num]->dma_buf_len = (p_i2s[i2s_num]->dma_buf_len * bytes_per_frame > I2S_DMA_BUFFER_MAX_SIZE) ?
+                                  I2S_DMA_BUFFER_MAX_SIZE / bytes_per_frame : p_i2s[i2s_num]->dma_buf_len;
+    return p_i2s[i2s_num]->dma_buf_len * bytes_per_frame;
+}
+
+/**
+ * @brief   Delete DMA buffer and descriptor
+ *
+ * @param   i2s_num     I2S device number
+ * @param   dma_obj     DMA object
+ * @return
+ *      - ESP_OK                DMA buffer delete success
+ *      - ESP_ERR_INVALID_ARG   dma_obj is NULL
+ */
+static esp_err_t m_i2s_delete_dma_buffer(i2s_port_t i2s_num, i2s_dma_t *dma_obj)
+{
+    ESP_RETURN_ON_FALSE(dma_obj, ESP_ERR_INVALID_ARG, TAG, "I2S DMA object can't be NULL");
+    /* Loop to destroy every descriptor and buffer */
+    for (int cnt = 0; cnt < p_i2s[i2s_num]->dma_buf_count; cnt++) {
+        if (dma_obj->desc && dma_obj->desc[cnt]) {
+            free(dma_obj->desc[cnt]);
+            dma_obj->desc[cnt] = NULL;
+        }
+        if (dma_obj->buf && dma_obj->buf[cnt]) {
+            free(dma_obj->buf[cnt]);
+            dma_obj->buf[cnt] = NULL;
+        }
+    }
+    return ESP_OK;
+}
+
+/**
+ * @brief   Allocate memory for DMA buffer and descriptor
+ *
+ * @param   i2s_num     I2S device number
+ * @param   dma_obj     DMA object
+ * @return
+ *      - ESP_OK            Allocate success
+ *      - ESP_ERR_NO_MEM    No memory for DMA buffer
+ */
+static esp_err_t m_i2s_alloc_dma_buffer(i2s_port_t i2s_num, i2s_dma_t *dma_obj)
+{
+    esp_err_t ret = ESP_OK;
+    ESP_GOTO_ON_FALSE(dma_obj, ESP_ERR_INVALID_ARG, err, TAG, "I2S DMA object can't be NULL");
+
+    uint32_t buf_cnt = p_i2s[i2s_num]->dma_buf_count;
+    for (int cnt = 0; cnt < buf_cnt; cnt++) {
+        /* Allocate DMA buffer */
+        dma_obj->buf[cnt] = (char *) heap_caps_calloc(dma_obj->buf_size, sizeof(char), MALLOC_CAP_DMA);
+        ESP_GOTO_ON_FALSE(dma_obj->buf[cnt], ESP_ERR_NO_MEM, err, TAG, "Error malloc dma buffer");
+        /* Initialize DMA buffer to 0 */
+        memset(dma_obj->buf[cnt], 0, dma_obj->buf_size);
+        ESP_LOGD(TAG, "Addr[%d] = %d", cnt, (int)dma_obj->buf[cnt]);
+
+        /* Allocate DMA descpriptor */
+        dma_obj->desc[cnt] = (lldesc_t *) heap_caps_calloc(1, sizeof(lldesc_t), MALLOC_CAP_DMA);
+        ESP_GOTO_ON_FALSE(dma_obj->desc[cnt], ESP_ERR_NO_MEM, err, TAG,  "Error malloc dma description entry");
+    }
+    /* DMA descriptor must be initialize after all descriptor has been created, otherwise they can't be linked together as a chain */
+    for (int cnt = 0; cnt < buf_cnt; cnt++) {
+        /* Initialize DMA descriptor */
+        dma_obj->desc[cnt]->owner = 1;
+        dma_obj->desc[cnt]->eof = 1;
+        dma_obj->desc[cnt]->sosf = 0;
+        dma_obj->desc[cnt]->length = dma_obj->buf_size;
+        dma_obj->desc[cnt]->size = dma_obj->buf_size;
+        dma_obj->desc[cnt]->buf = (uint8_t *) dma_obj->buf[cnt];
+        dma_obj->desc[cnt]->offset = 0;
+        /* Link to the next descriptor */
+        dma_obj->desc[cnt]->empty = (uint32_t)((cnt < (buf_cnt - 1)) ? (dma_obj->desc[cnt + 1]) : dma_obj->desc[0]);
+    }
+    ESP_LOGI(TAG, "DMA Malloc info, datalen=blocksize=%d, dma_buf_count=%d", dma_obj->buf_size, buf_cnt);
+    return ESP_OK;
+err:
+    /* Delete DMA buffer if failed to allocate memory */
+    m_i2s_delete_dma_buffer(i2s_num, dma_obj);
+    return ret;
+}
+
+/**
+ * @brief   Realloc I2S dma buffer
+ *
+ * @param   i2s_num     I2S device number
+ * @param   dma_obj     DMA object
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_NO_MEM      No memory for I2S tx dma buffer
+ */
+static esp_err_t m_i2s_realloc_dma_buffer(i2s_port_t i2s_num, i2s_dma_t *dma_obj)
+{
+    ESP_RETURN_ON_FALSE(dma_obj, ESP_ERR_INVALID_ARG, TAG, "I2S DMA object can't be NULL");
+
+    /* Destroy old dma descriptor and buffer */
+    m_i2s_delete_dma_buffer(i2s_num, dma_obj);
+    /* Alloc new dma descriptor and buffer */
+    ESP_RETURN_ON_ERROR(m_i2s_alloc_dma_buffer(i2s_num, dma_obj), TAG, "Failed to allocate dma buffer");
+
+    return ESP_OK;
+}
+
+/**
+ * @brief   I2S destroy the whole DMA object
+ *
+ * @param   i2s_num     I2S device number
+ * @param   dma         Secondary pointer to the DMA object
+ * @return
+ *      - ESP_OK                I2S DMA buffer has been destroyed successfully
+ *      - ESP_ERR_INVALID_ARG   I2S driver has not installed yet
+ */
+static esp_err_t m_i2s_destroy_dma_object(i2s_port_t i2s_num, i2s_dma_t **dma)
+{
+    /* Check if DMA truely need destroy */
+    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_ERR_INVALID_ARG, TAG, "I2S not initialized yet");
+    if (!(*dma)) {
+        return ESP_OK;
+    }
+    /* Destroy every descriptor and buffer */
+    m_i2s_delete_dma_buffer(i2s_num, (*dma));
+    /* Destroy descriptor pointer */
+    if ((*dma)->desc) {
+        free((*dma)->desc);
+        (*dma)->desc = NULL;
+    }
+    /* Destroy buffer pointer */
+    if ((*dma)->buf) {
+        free((*dma)->buf);
+        (*dma)->buf = NULL;
+    }
+    /* Delete DMA mux */
+    vSemaphoreDelete((*dma)->mux);
+    /* Delete DMA queue */
+    vQueueDelete((*dma)->queue);
+    /* Free DMA structure */
+    free(*dma);
+    *dma = NULL;
+    ESP_LOGI(TAG, "DMA queue destroyed");
+    return ESP_OK;
+}
+
+/**
+ * @brief   Create I2S DMA object
+ * @note    This function only create I2S DMA object but will not allocate memory
+ *          for DMA descriptor and buffer, call 'i2s_alloc_dma_buffer' additionally to
+ *          allocate DMA buffer
+ *
+ * @param   i2s_num         I2S device number
+ * @param   dma             The secondary pointer of DMA object
+ * @return
+ *      - ESP_OK                The pointer of DMA object
+ *      - ESP_ERR_INVALID_ARG   NULL pointer error or DMA object has been created
+ *      - ESP_ERR_NO_MEM        No memory for new DMA object
+ */
+static esp_err_t m_i2s_create_dma_object(i2s_port_t i2s_num, i2s_dma_t **dma)
+{
+    ESP_RETURN_ON_FALSE(dma, ESP_ERR_INVALID_ARG, TAG, "DMA object secondary pointer is NULL");
+    ESP_RETURN_ON_FALSE((*dma == NULL), ESP_ERR_INVALID_ARG, TAG, "DMA object has been created");
+    uint32_t buf_cnt = p_i2s[i2s_num]->dma_buf_count;
+    /* Allocate new DMA structure */
+    *dma = (i2s_dma_t *) malloc(sizeof(i2s_dma_t));
+    ESP_RETURN_ON_FALSE(*dma, ESP_ERR_NO_MEM, TAG, "DMA object allocate failed");
+    /* Allocate DMA buffer poiter */
+    (*dma)->buf = (char **)heap_caps_calloc(buf_cnt, sizeof(char *), MALLOC_CAP_DMA);
+    if (!(*dma)->buf) {
+        goto err;
+    }
+    /* Allocate secondary pointer of DMA descriptor chain */
+    (*dma)->desc = (lldesc_t **)heap_caps_calloc(buf_cnt, sizeof(lldesc_t *), MALLOC_CAP_DMA);
+    if (!(*dma)->desc) {
+        goto err;
+    }
+    /* Create queue and mutex */
+    (*dma)->queue = xQueueCreate(buf_cnt - 1, sizeof(char *));
+    if (!(*dma)->queue) {
+        goto err;
+    }
+    (*dma)->mux = xSemaphoreCreateMutex();
+    if (!(*dma)->mux) {
+        goto err;
+    }
+
+    return ESP_OK;
+err:
+    ESP_LOGE(TAG, "I2S DMA object create failed, preparing to uninstall");
+    /* Destroy DMA queue if failed to allocate memory */
+    m_i2s_destroy_dma_object(i2s_num, dma);
+    return ESP_ERR_NO_MEM;
+}
+
+/**
+ * @brief   Zero the contents of the TX DMA buffer.
+ * @note    Pushes zero-byte samples into the TX DMA buffer, until it is full.
+ *
+ * @param   i2s_num         I2S device number
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_zero_dma_buffer(i2s_port_t i2s_num)
+{
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+
+    /* Clear I2S RX DMA buffer */
+    if (p_i2s[i2s_num]->rx && p_i2s[i2s_num]->rx->buf != NULL && p_i2s[i2s_num]->rx->buf_size != 0) {
+        for (int i = 0; i < p_i2s[i2s_num]->dma_buf_count; i++) {
+            memset(p_i2s[i2s_num]->rx->buf[i], 0, p_i2s[i2s_num]->rx->buf_size);
+        }
+    }
+
+    /* Clear I2S TX DMA buffer */
+    if (p_i2s[i2s_num]->tx && p_i2s[i2s_num]->tx->buf != NULL && p_i2s[i2s_num]->tx->buf_size != 0) {
+        /* Finish to write all tx data */
+        int bytes_left = (p_i2s[i2s_num]->tx->buf_size - p_i2s[i2s_num]->tx->rw_pos) % 4;
+        if (bytes_left) {
+            size_t zero_bytes = 0, bytes_written;
+            m_i2s_write(i2s_num, (void *)&zero_bytes, bytes_left, &bytes_written, portMAX_DELAY);
+        }
+        for (int i = 0; i < p_i2s[i2s_num]->dma_buf_count; i++) {
+            memset(p_i2s[i2s_num]->tx->buf[i], 0, p_i2s[i2s_num]->tx->buf_size);
+        }
+    }
+    return ESP_OK;
+}
+
+/*-------------------------------------------------------------
+                   I2S clock operation
+  -------------------------------------------------------------*/
+#if SOC_I2S_SUPPORTS_APLL
+static esp_err_t m_i2s_set_apll_freq(uint32_t expt_freq, uint32_t *real_freq)
+{
+    uint32_t rtc_xtal_freq = (uint32_t)rtc_clk_xtal_freq_get();
+    ESP_RETURN_ON_FALSE(rtc_xtal_freq, ESP_ERR_INVALID_STATE, TAG, "Get xtal clock frequency failed, it has not been set yet");
+
+    /* Reference formula: apll_freq = xtal_freq * (4 + sdm2 + sdm1/256 + sdm0/65536) / ((o_div + 2) * 2)
+     *                                ----------------------------------------------   -----------------
+     *                                     350 MHz <= Numerator <= 500 MHz                Denominator
+     */
+    int o_div = 0; // range: 0~31
+    int sdm0 = 0;  // range: 0~255
+    int sdm1 = 0;  // range: 0~255
+    int sdm2 = 0;  // range: 0~63
+    /* Firstly try to satisfy the condition that the operation frequency of numerator should be greater than 350 MHz,
+     * i.e. xtal_freq * (4 + sdm2 + sdm1/256 + sdm0/65536) >= 350 MHz, '+1' in the following code is to get the ceil value.
+     * With this condition, as we know the 'o_div' can't be greater than 31, then we can calculate the APLL minimum support frequency is
+     * 350 MHz / ((31 + 2) * 2) = 5303031 Hz (for ceil) */
+    o_div = (int)(SOC_APLL_MULTIPLIER_OUT_MIN_HZ / (float)(expt_freq * 2) + 1) - 2;
+    ESP_RETURN_ON_FALSE(o_div < 32, ESP_ERR_INVALID_ARG, TAG, "Expected frequency is too small");
+    if (o_div < 0) {
+        /* Try to satisfy the condition that the operation frequency of numerator should be smaller than 500 MHz,
+         * i.e. xtal_freq * (4 + sdm2 + sdm1/256 + sdm0/65536) <= 500 MHz, we need to get the floor value in the following code.
+         * With this condition, as we know the 'o_div' can't be smaller than 0, then we can calculate the APLL maximum support frequency is
+         * 500 MHz / ((0 + 2) * 2) = 125000000 Hz */
+        o_div = (int)(SOC_APLL_MULTIPLIER_OUT_MAX_HZ / (float)(expt_freq * 2)) - 2;
+        ESP_RETURN_ON_FALSE(o_div >= 0, ESP_ERR_INVALID_ARG, TAG, "Expected frequency is too small");
+    }
+    // sdm2 = (int)(((o_div + 2) * 2) * apll_freq / xtal_freq) - 4
+    sdm2 = (int)(((o_div + 2) * 2 * expt_freq) / (rtc_xtal_freq * 1000000)) - 4;
+    // numrator = (((o_div + 2) * 2) * apll_freq / xtal_freq) - 4 - sdm2
+    float numrator = (((o_div + 2) * 2 * expt_freq) / ((float)rtc_xtal_freq * 1000000)) - 4 - sdm2;
+    // If numrator is bigger than 255/256 + 255/65536 + (1/65536)/2 = 1 - (1 / 65536)/2, carry bit to sdm2
+    if (numrator > 1.0 - (1.0 / 65536.0) / 2.0) {
+        sdm2++;
+    }
+    // If numrator is smaller than (1/65536)/2, keep sdm0 = sdm1 = 0, otherwise calculate sdm0 and sdm1
+    else if (numrator > (1.0 / 65536.0) / 2.0) {
+        // Get the closest sdm1
+        sdm1 = (int)(numrator * 65536.0 + 0.5) / 256;
+        // Get the closest sdm0
+        sdm0 = (int)(numrator * 65536.0 + 0.5) % 256;
+    }
+    rtc_clk_apll_enable(true, sdm0, sdm1, sdm2, o_div);
+    *real_freq = (uint32_t)(rtc_xtal_freq * 1000000 * (4 + sdm2 + (float)sdm1/256.0 + (float)sdm0/65536.0) / (((float)o_div + 2) * 2));
+
+    return ESP_OK;
+}
+#endif
+/**
+ * @brief   Config I2S source clock and get its frequency
+ *
+ * @param   i2s_num         I2S device number
+ * @param   use_apll        Whether use apll, only take effect when chip supports
+ * @param   mclk            module clock
+ *
+ * @return
+ *      - 0                 use I2S_CLK_APLL as clock source, no I2S system clock to set
+ *      - I2S_LL_BASE_CLK   use I2S_CLK_D2CLK as clock source, return APB clock frequency
+ */
+static uint32_t m_i2s_config_source_clock(i2s_port_t i2s_num, bool use_apll, uint32_t mclk)
+{
+#if SOC_I2S_SUPPORTS_APLL
+    if (use_apll) {
+        /* Calculate the expected APLL  */
+        int div = (int)((SOC_APLL_MIN_HZ / mclk) + 1);
+        /* apll_freq = mclk * div
+         * when div = 1, hardware will still divide 2
+         * when div = 0, the final mclk will be unpredictable
+         * So the div here should be at least 2 */
+        div = div < 2 ? 2 : div;
+        uint32_t expt_freq = mclk * div;
+        /* Set APLL coefficients to the given frequency */
+        uint32_t real_freq = 0;
+        esp_err_t ret = m_i2s_set_apll_freq(expt_freq, &real_freq);
+        if (ret != ESP_OK) {
+            ESP_LOGE(TAG, "set APLL coefficients failed");
+            return 0;
+        }
+        ESP_LOGI(TAG, "APLL expected frequency is %d Hz, real frequency is %d Hz", expt_freq, real_freq);
+        /* Set I2S_APLL as I2S module clock source */
+        i2s_hal_set_clock_src(&(p_i2s[i2s_num]->hal), I2S_CLK_APLL);
+        /* In APLL mode, there is no sclk but only mclk, so return 0 here to indicate APLL mode */
+        return real_freq;
+    }
+    /* Set I2S_D2CLK (160M) as default I2S module clock source */
+    i2s_hal_set_clock_src(&(p_i2s[i2s_num]->hal), I2S_CLK_D2CLK);
+    return I2S_LL_BASE_CLK;
+#else
+    if (use_apll) {
+        ESP_LOGW(TAG, "APLL not supported on current chip, use I2S_CLK_D2CLK as default clock source");
+    }
+    /* Set I2S_D2CLK (160M) as I2S module clock source */
+    i2s_hal_set_clock_src(&(p_i2s[i2s_num]->hal), I2S_CLK_D2CLK);
+    return I2S_LL_BASE_CLK;
+#endif
+}
+
+#if _SOC_I2S_SUPPORTS_ADC || _SOC_I2S_SUPPORTS_DAC
+/**
+ * @brief   I2S calculate clock for built-in ADC/DAC mode
+ *
+ * @param   i2s_num         I2S device number
+ * @param   clk_cfg         Struct to restore clock confiuration
+ * @return
+ *      - ESP_OK                Get clock success
+ *      - ESP_ERR_INVALID_ARG   Invalid args
+ */
+static esp_err_t m_i2s_calculate_adc_dac_clock(int i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
+{
+    ESP_RETURN_ON_FALSE(clk_cfg, ESP_ERR_INVALID_ARG, TAG, "input clk_cfg is NULL");
+    ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->hal_cfg.mode & (I2S_MODE_DAC_BUILT_IN | I2S_MODE_ADC_BUILT_IN), ESP_ERR_INVALID_ARG, TAG, "current mode is not built-in ADC/DAC");
+
+    /* Set I2S bit clock */
+    clk_cfg->bclk = p_i2s[i2s_num]->hal_cfg.sample_rate * I2S_LL_AD_BCK_FACTOR;
+    /* Set I2S bit clock default division */
+    clk_cfg->bclk_div = p_i2s[i2s_num]->hal_cfg.chan_bits;
+    /* If fixed_mclk and use_apll are set, use fixed_mclk as mclk frequency, otherwise calculate by mclk = sample_rate * multiple */
+    clk_cfg->mclk = (p_i2s[i2s_num]->use_apll && p_i2s[i2s_num]->fixed_mclk) ?
+                    p_i2s[i2s_num]->fixed_mclk : clk_cfg->bclk * clk_cfg->bclk_div;
+    /* Calculate bclk_div = mclk / bclk */
+    clk_cfg->bclk_div = clk_cfg->mclk / clk_cfg->bclk;
+    /* Get I2S system clock by config source clock */
+    clk_cfg->sclk = m_i2s_config_source_clock(i2s_num, p_i2s[i2s_num]->use_apll, clk_cfg->mclk);
+    /* Get I2S master clock rough division, later will calculate the fine division parameters in HAL */
+    clk_cfg->mclk_div = clk_cfg->sclk / clk_cfg->mclk;
+
+    /* Check if the configuration is correct */
+    ESP_RETURN_ON_FALSE(clk_cfg->mclk <= clk_cfg->sclk, ESP_ERR_INVALID_ARG, TAG, "sample rate is too large");
+
+    return ESP_OK;
+}
+#endif // _SOC_I2S_SUPPORTS_ADC || _SOC_I2S_SUPPORTS_DAC
+
+#if SOC_I2S_SUPPORTS_PDM_TX
+/**
+ * @brief   I2S calculate clock for PDM tx mode
+ *
+ * @param   i2s_num         I2S device number
+ * @param   clk_cfg         Struct to restore clock confiuration
+ * @return
+ *      - ESP_OK                Get clock success
+ *      - ESP_ERR_INVALID_ARG   Invalid args
+ */
+static esp_err_t m_i2s_calculate_pdm_tx_clock(int i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
+{
+    ESP_RETURN_ON_FALSE(clk_cfg, ESP_ERR_INVALID_ARG, TAG, "input clk_cfg is NULL");
+    ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM, ESP_ERR_INVALID_ARG, TAG, "current mode is not PDM");
+
+    int fp = i2s_hal_get_tx_pdm_fp(&(p_i2s[i2s_num]->hal));
+    int fs = i2s_hal_get_tx_pdm_fs(&(p_i2s[i2s_num]->hal));
+    /* Set I2S bit clock */
+    clk_cfg->bclk = p_i2s[i2s_num]->hal_cfg.sample_rate * I2S_LL_PDM_BCK_FACTOR * fp / fs;
+    /* Set I2S bit clock default division */
+    clk_cfg->bclk_div = 8;
+    /* If fixed_mclk and use_apll are set, use fixed_mclk as mclk frequency, otherwise calculate by mclk = sample_rate * multiple */
+    clk_cfg->mclk = (p_i2s[i2s_num]->use_apll && p_i2s[i2s_num]->fixed_mclk) ?
+                    p_i2s[i2s_num]->fixed_mclk : clk_cfg->bclk * clk_cfg->bclk_div;
+    /* Calculate bclk_div = mclk / bclk */
+    clk_cfg->bclk_div = clk_cfg->mclk / clk_cfg->bclk;
+    /* Get I2S system clock by config source clock */
+    clk_cfg->sclk = m_i2s_config_source_clock(i2s_num, p_i2s[i2s_num]->use_apll, clk_cfg->mclk);
+    /* Get I2S master clock rough division, later will calculate the fine division parameters in HAL */
+    clk_cfg->mclk_div = clk_cfg->sclk / clk_cfg->mclk;
+
+    /* Check if the configuration is correct */
+    ESP_RETURN_ON_FALSE(clk_cfg->mclk <= clk_cfg->sclk, ESP_ERR_INVALID_ARG, TAG, "sample rate is too large");
+
+    return ESP_OK;
+}
+#endif  // SOC_I2S_SUPPORTS_PDM_TX
+
+#if SOC_I2S_SUPPORTS_PDM_RX
+/**
+ * @brief   I2S calculate clock for PDM rx mode
+ *
+ * @param   i2s_num         I2S device number
+ * @param   clk_cfg         Struct to restore clock confiuration
+ * @return
+ *      - ESP_OK                Get clock success
+ *      - ESP_ERR_INVALID_ARG   Invalid args
+ */
+static esp_err_t m_i2s_calculate_pdm_rx_clock(int i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
+{
+    ESP_RETURN_ON_FALSE(clk_cfg, ESP_ERR_INVALID_ARG, TAG, "input clk_cfg is NULL");
+    ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM, ESP_ERR_INVALID_ARG, TAG, "current mode is not PDM");
+
+    i2s_pdm_dsr_t dsr;
+    i2s_hal_get_rx_pdm_dsr(&(p_i2s[i2s_num]->hal), &dsr);
+    /* Set I2S bit clock */
+    clk_cfg->bclk = p_i2s[i2s_num]->hal_cfg.sample_rate * I2S_LL_PDM_BCK_FACTOR * (dsr == I2S_PDM_DSR_16S ? 2 : 1);
+    /* Set I2S bit clock default division */
+    clk_cfg->bclk_div = 8;
+    /* If fixed_mclk and use_apll are set, use fixed_mclk as mclk frequency, otherwise calculate by mclk = sample_rate * multiple */
+    clk_cfg->mclk = (p_i2s[i2s_num]->use_apll && p_i2s[i2s_num]->fixed_mclk) ?
+                    p_i2s[i2s_num]->fixed_mclk : clk_cfg->bclk * clk_cfg->bclk_div;
+    /* Calculate bclk_div = mclk / bclk */
+    clk_cfg->bclk_div = clk_cfg->mclk / clk_cfg->bclk;
+    /* Get I2S system clock by config source clock */
+    clk_cfg->sclk = m_i2s_config_source_clock(i2s_num, p_i2s[i2s_num]->use_apll, clk_cfg->mclk);
+    /* Get I2S master clock rough division, later will calculate the fine division parameters in HAL */
+    clk_cfg->mclk_div = clk_cfg->sclk / clk_cfg->mclk;
+
+    /* Check if the configuration is correct */
+    ESP_RETURN_ON_FALSE(clk_cfg->mclk <= clk_cfg->sclk, ESP_ERR_INVALID_ARG, TAG, "sample rate is too large");
+    ESP_LOGD(TAG, "[sclk] %d [mclk] %d [mclk_div] %d [bclk] %d [bclk_div] %d",
+             clk_cfg->sclk, clk_cfg->mclk, clk_cfg->mclk_div, clk_cfg->bclk, clk_cfg->bclk_div);
+
+    return ESP_OK;
+}
+#endif // SOC_I2S_SUPPORTS_PDM_RX
+
+/**
+ * @brief   I2S calculate clock for common mode (philip, MSB, PCM)
+ *
+ * @param   i2s_num         I2S device number
+ * @param   clk_cfg         Struct to restore clock confiuration
+ * @return
+ *      - ESP_OK                Get clock success
+ *      - ESP_ERR_INVALID_ARG   Invalid args
+ */
+static esp_err_t m_i2s_calculate_common_clock(int i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
+{
+    ESP_RETURN_ON_FALSE(clk_cfg, ESP_ERR_INVALID_ARG, TAG, "input clk_cfg is NULL");
+
+    uint32_t rate     = p_i2s[i2s_num]->hal_cfg.sample_rate;
+    uint32_t chan_num = p_i2s[i2s_num]->hal_cfg.total_chan < 2 ? 2 : p_i2s[i2s_num]->hal_cfg.total_chan;
+    uint32_t chan_bit = p_i2s[i2s_num]->hal_cfg.chan_bits;
+    uint32_t multi;
+    /* Calculate multiple */
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_MASTER || p_i2s[i2s_num]->use_apll) {
+        multi = p_i2s[i2s_num]->mclk_multiple ? p_i2s[i2s_num]->mclk_multiple : I2S_MCLK_MULTIPLE_256;
+    } else {
+        /* Only need to set the multiple of mclk to sample rate for MASTER mode,
+         * because BCK and WS clock are provided by the external codec in SLAVE mode.
+         * The multiple should be big enough to get a high module clock which could detect the edges of externel clock more accurately,
+         * otherwise the data we receive or send would get a large latency and go wrong due to the slow module clock.
+         * But on ESP32 and ESP32S2, due to the different clock work mode in hardware,
+         * their multiple should be set to an appropriate range according to the sample bits,
+         * and this particular multiple finally aims at guaranteeing the bclk_div not smaller than 8,
+         * if not, the I2S may can't send data or send wrong data.
+         * Here use 'SOC_I2S_SUPPORTS_TDM' to differentialize other chips with ESP32 and ESP32S2.
+         */
+#if SOC_I2S_SUPPORTS_TDM
+        multi = I2S_LL_BASE_CLK / rate;
+#else
+        multi =  64 * chan_bit;
+#endif
+    }
+    /* Set I2S bit clock */
+    clk_cfg->bclk = rate * chan_num * chan_bit;
+    /* If fixed_mclk and use_apll are set, use fixed_mclk as mclk frequency, otherwise calculate by mclk = sample_rate * multiple */
+    clk_cfg->mclk = (p_i2s[i2s_num]->use_apll && p_i2s[i2s_num]->fixed_mclk) ?
+                    p_i2s[i2s_num]->fixed_mclk : (rate * multi);
+    /* Calculate bclk_div = mclk / bclk */
+    clk_cfg->bclk_div = clk_cfg->mclk / clk_cfg->bclk;
+    /* Get I2S system clock by config source clock */
+    clk_cfg->sclk = m_i2s_config_source_clock(i2s_num, p_i2s[i2s_num]->use_apll, clk_cfg->mclk);
+    /* Get I2S master clock rough division, later will calculate the fine division parameters in HAL */
+    clk_cfg->mclk_div = clk_cfg->sclk / clk_cfg->mclk;
+
+    /* Check if the configuration is correct */
+    ESP_RETURN_ON_FALSE(clk_cfg->mclk <= clk_cfg->sclk, ESP_ERR_INVALID_ARG, TAG, "sample rate is too large");
+
+    return ESP_OK;
+}
+
+/**
+ * @brief   I2S calculate clocks according to the selected I2S mode
+ *
+ * @param   i2s_num     I2S device number
+ * @param   clk_cfg         Struct to restore clock confiuration
+ * @return
+ *      - ESP_OK                Claculate clock success
+ *      - ESP_ERR_INVALID_ARG   Invalid args
+ */
+static esp_err_t m_i2s_calculate_clock(i2s_port_t i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
+{
+    /* Calculate clock for ADC mode */
+#if _SOC_I2S_SUPPORTS_ADC
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_ADC_BUILT_IN) {
+        ESP_RETURN_ON_ERROR(m_i2s_calculate_adc_dac_clock(i2s_num, clk_cfg), TAG, "ADC clock calculate failed");
+        return ESP_OK;
+    }
+#endif // _SOC_I2S_SUPPORTS_ADC
+    /* Calculate clock for DAC mode */
+#if _SOC_I2S_SUPPORTS_DAC
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_DAC_BUILT_IN) {
+        ESP_RETURN_ON_ERROR(m_i2s_calculate_adc_dac_clock(i2s_num, clk_cfg), TAG, "DAC clock calculate failed");
+        return ESP_OK;
+    }
+#endif // _SOC_I2S_SUPPORTS_DAC
+
+    /* Calculate clock for PDM mode */
+#if SOC_I2S_SUPPORTS_PDM_TX || SOC_I2S_SUPPORTS_PDM_RX
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM) {
+#if SOC_I2S_SUPPORTS_PDM_TX
+        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+            ESP_RETURN_ON_ERROR(m_i2s_calculate_pdm_tx_clock(i2s_num, clk_cfg), TAG, "PDM TX clock calculate failed");
+        }
+#endif // SOC_I2S_SUPPORTS_PDM_TX
+#if SOC_I2S_SUPPORTS_PDM_RX
+        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+            ESP_RETURN_ON_ERROR(m_i2s_calculate_pdm_rx_clock(i2s_num, clk_cfg), TAG, "PDM RX clock calculate failed");
+        }
+#endif // SOC_I2S_SUPPORTS_PDM_RX
+        return ESP_OK;
+    }
+#endif // SOC_I2S_SUPPORTS_PDM_TX || SOC_I2S_SUPPORTS_PDM_RX
+
+    /* Calculate clock for common mode */
+    ESP_RETURN_ON_ERROR(m_i2s_calculate_common_clock(i2s_num, clk_cfg), TAG, "Common clock calculate failed");
+    return ESP_OK;
+}
+
+/*-------------------------------------------------------------
+                   I2S configuration
+  -------------------------------------------------------------*/
+#if SOC_I2S_SUPPORTS_TDM
+/**
+ * @brief Get max actived channel number
+ *
+ * @param chan_mask I2S channel mask that indicates which channels are actived
+ * @return
+ *      - Max actived channel number
+ */
+static uint32_t m_i2s_get_max_channel_num(i2s_channel_t chan_mask)
+{
+    uint32_t max_chan = 0;
+    uint32_t channel = chan_mask >> 16;
+    for (int i = 0; channel && i < 16; i++, channel >>= 1) {
+        if (channel & 0x01) {
+            max_chan = i + 1;
+        }
+    }
+    /* Can't be smaller than 2 */
+    return max_chan < 2 ? 2 : max_chan;
+}
+#endif
+
+/**
+ * @brief Get active channel number according to channel format
+ * @note  In 'I2S_CHANNEL_FMT_MULTIPLE' format, this function will check
+ *        'total_chan' and fix it if it is not correct.
+ *
+ * @param hal_cfg   [input/output] I2S hal configuration structer
+ * @return
+ *      - Active channel number
+ */
+static uint32_t m_i2s_get_active_channel_num(const i2s_hal_config_t *hal_cfg)
+{
+    switch (hal_cfg->chan_fmt) {
+    case I2S_CHANNEL_FMT_RIGHT_LEFT: //fall through
+    case I2S_CHANNEL_FMT_ALL_RIGHT:  //fall through
+    case I2S_CHANNEL_FMT_ALL_LEFT:
+        return 2;
+    case I2S_CHANNEL_FMT_ONLY_RIGHT: //fall through
+    case I2S_CHANNEL_FMT_ONLY_LEFT:
+        return 1;
+#if SOC_I2S_SUPPORTS_TDM
+    case I2S_CHANNEL_FMT_MULTIPLE: {
+        uint32_t num = 0;
+        uint32_t chan_mask = hal_cfg->chan_mask >> 16;
+        for (int i = 0; chan_mask && i < 16; i++, chan_mask >>= 1) {
+            if (chan_mask & 0x01) {
+                num++;
+            }
+        }
+        return num;
+    }
+#endif
+    default:
+        return 0;
+    }
+}
+
+#if _SOC_I2S_SUPPORTS_DAC
+/**
+ * @brief   I2S set built-in DAC mode
+ *
+ * @param   dac_mode    DAC mode
+ * @return
+ *      - ESP_OK                Set DAC success
+ *      - ESP_ERR_INVALID_ARG   Wrong DAC mode
+ */
+esp_err_t m_i2s_set_dac_mode(i2s_dac_mode_t dac_mode)
+{
+    ESP_RETURN_ON_FALSE((dac_mode < I2S_DAC_CHANNEL_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s dac mode error");
+    if (dac_mode == I2S_DAC_CHANNEL_DISABLE) {
+        dac_output_disable(DAC_CHANNEL_1);
+        dac_output_disable(DAC_CHANNEL_2);
+        dac_i2s_disable();
+    } else {
+        dac_i2s_enable();
+    }
+
+    if (dac_mode & I2S_DAC_CHANNEL_RIGHT_EN) {
+        //DAC1, right channel
+        dac_output_enable(DAC_CHANNEL_1);
+    }
+    if (dac_mode & I2S_DAC_CHANNEL_LEFT_EN) {
+        //DAC2, left channel
+        dac_output_enable(DAC_CHANNEL_2);
+    }
+    return ESP_OK;
+}
+#endif // _SOC_I2S_SUPPORTS_DAC
+
+#if _SOC_I2S_SUPPORTS_ADC
+/**
+ * @brief   ADC mode recover
+ *
+ * @return
+ *      - ESP_OK ADC            Recover success
+ *      - ESP_ERR_INVALID_ARG   ADC not initialized yet
+ */
+static esp_err_t m__i2s_adc_mode_recover(void)
+{
+    ESP_RETURN_ON_FALSE(((_i2s_adc_unit != -1) && (_i2s_adc_channel != -1)), ESP_ERR_INVALID_ARG, TAG, "i2s ADC recover error, not initialized...");
+    return adc_i2s_mode_init(_i2s_adc_unit, _i2s_adc_channel);
+}
+
+/**
+ * @brief   I2S set adc mode
+ *
+ * @param   adc_unit    ADC unit number
+ * @param   adc_channel ADC channel
+ * @return
+ *      - ESP_OK ADC            Recover success
+ *      - ESP_ERR_INVALID_ARG   ADC not initialized yet
+ */
+esp_err_t m_i2s_set_adc_mode(adc_unit_t adc_unit, adc1_channel_t adc_channel)
+{
+    ESP_RETURN_ON_FALSE((adc_unit < ADC_UNIT_2), ESP_ERR_INVALID_ARG, TAG, "i2s ADC unit error, only support ADC1 for now");
+    // For now, we only support SAR ADC1.
+    _i2s_adc_unit = adc_unit;
+    _i2s_adc_channel = adc_channel;
+    return adc_i2s_mode_init(adc_unit, adc_channel);
+}
+
+/**
+ * @brief   I2S enable ADC mode
+ *
+ * @param   i2s_num         I2S device number
+ * @return
+ *      - ESP_OK                Enable ADC success
+ *      - ESP_ERR_INVALID_ARG   Invalid argument
+ *      - ESP_ERR_INVALID_STATE Current I2S mode is not built-in ADC
+ */
+esp_err_t m_i2s_adc_enable(i2s_port_t i2s_num)
+{
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num] != NULL), ESP_ERR_INVALID_STATE, TAG, "Not initialized yet");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_ADC_BUILT_IN), ESP_ERR_INVALID_STATE, TAG, "i2s built-in adc not enabled");
+
+    adc1_dma_mode_acquire();
+    m__i2s_adc_mode_recover();
+    m_i2s_rx_reset(i2s_num);
+    return m_i2s_set_clk(i2s_num, p_i2s[i2s_num]->hal_cfg.sample_rate, p_i2s[i2s_num]->hal_cfg.sample_bits, p_i2s[i2s_num]->hal_cfg.active_chan);
+}
+
+/**
+ * @brief   I2S disable ADC
+ *
+ * @param   i2s_num         I2S device number
+ * @return
+ *      - ESP_OK        I2S ADC mode successfully disabled
+ *      - ESP_ERR_INVALID_ARG   Invalid argument
+ *      - ESP_ERR_INVALID_STATE Current I2S mode is not built-in ADC
+ */
+esp_err_t m_i2s_adc_disable(i2s_port_t i2s_num)
+{
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num] != NULL), ESP_ERR_INVALID_STATE, TAG, "Not initialized yet");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_ADC_BUILT_IN), ESP_ERR_INVALID_STATE, TAG, "i2s built-in adc not enabled");
+
+    i2s_hal_stop_rx(&(p_i2s[i2s_num]->hal));
+    adc1_lock_release();
+    return ESP_OK;
+}
+#endif
+
+/**
+ * @brief   Set sample rate used for I2S RX and TX.
+ * @note    The bit clock rate is determined by the sample rate and i2s_config_t configuration parameters (number of channels, bits_per_sample).
+ *          `bit_clock = rate * (number of channels) * bits_per_sample`
+ *
+ * @param   i2s_num  I2S device number
+ * @param   rate I2S sample rate (ex: 8000, 44100...)
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ */
+esp_err_t m_i2s_set_sample_rates(i2s_port_t i2s_num, uint32_t rate)
+{
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.sample_bits > 0), ESP_ERR_INVALID_ARG, TAG, "sample bits not set");
+    return m_i2s_set_clk(i2s_num, rate, p_i2s[i2s_num]->hal_cfg.sample_bits, p_i2s[i2s_num]->hal_cfg.active_chan);
+}
+
+#if SOC_I2S_SUPPORTS_PCM
+/**
+ * @brief   Configure I2S a/u-law decompress or compress
+ * @note    This function should be called after i2s driver installed
+ *          Only take effect when the i2s 'communication_format' is set to 'I2S_COMM_FORMAT_STAND_PCM_SHORT' or 'I2S_COMM_FORMAT_STAND_PCM_LONG'
+ *
+ * @param   i2s_num  I2S_NUM_0
+ * @param   pcm_cfg  Including mode selection and a/u-law decompress or compress configuration paramater
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_pcm_config(i2s_port_t i2s_num, const i2s_pcm_cfg_t *pcm_cfg)
+{
+    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_FAIL, TAG, "i2s has not installed yet");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.comm_fmt & I2S_COMM_FORMAT_STAND_PCM_SHORT),
+                        ESP_ERR_INVALID_ARG, TAG, "i2s communication mode is not PCM mode");
+
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+        xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
+    }
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+        xSemaphoreTake(p_i2s[i2s_num]->rx->mux, (portTickType)portMAX_DELAY);
+    }
+
+    i2s_stop(i2s_num);
+    I2S_ENTER_CRITICAL(i2s_num);
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+        i2s_hal_tx_pcm_cfg(&(p_i2s[i2s_num]->hal), pcm_cfg->pcm_type);
+    } else if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+        i2s_hal_rx_pcm_cfg(&(p_i2s[i2s_num]->hal), pcm_cfg->pcm_type);
+    }
+    I2S_EXIT_CRITICAL(i2s_num);
+    i2s_start(i2s_num);
+
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+        xSemaphoreGive(p_i2s[i2s_num]->tx->mux);
+    }
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+        xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
+    }
+
+    return ESP_OK;
+}
+#endif
+
+#if SOC_I2S_SUPPORTS_PDM_RX
+/**
+ * @brief   Set PDM mode down-sample rate
+ *          In PDM RX mode, there would be 2 rounds of downsample process in hardware.
+ *          In the first downsample process, the sampling number can be 16 or 8.
+ *          In the second downsample process, the sampling number is fixed as 8.
+ *          So the clock frequency in PDM RX mode would be (fpcm * 64) or (fpcm * 128) accordingly.
+ * @note    After calling this function, it would call i2s_set_clk inside to update the clock frequency.
+ *          Please call this function after I2S driver has been initialized.
+ *
+ * @param   i2s_num I2S device number
+ * @param   downsample i2s RX down sample rate for PDM mode.
+ * @return
+ *     - ESP_OK Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ */
+esp_err_t m_i2s_set_pdm_rx_down_sample(i2s_port_t i2s_num, i2s_pdm_dsr_t downsample)
+{
+    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_FAIL, TAG, "i2s has not installed yet");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM), ESP_ERR_INVALID_ARG, TAG, "i2s mode is not PDM mode");
+
+    xSemaphoreTake(p_i2s[i2s_num]->rx->mux, (portTickType)portMAX_DELAY);
+    m_i2s_stop(i2s_num);
+    i2s_hal_set_rx_pdm_dsr(&(p_i2s[i2s_num]->hal), downsample);
+    m_i2s_start(i2s_num);
+    xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
+    return m_i2s_set_clk(i2s_num, p_i2s[i2s_num]->hal_cfg.sample_rate, p_i2s[i2s_num]->hal_cfg.sample_bits, p_i2s[i2s_num]->hal_cfg.active_chan);
+}
+#endif
+
+#if SOC_I2S_SUPPORTS_PDM_TX
+/**
+ * @brief   Set TX PDM mode up-sample rate
+ * @note    If you have set PDM mode while calling 'i2s_driver_install',
+ *          default PDM TX upsample parameters have already been set,
+ *          no need to call this function again if you don't have to change the default configuration
+ *
+ * @param   i2s_num         I2S device number
+ * @param   upsample_cfg    Set I2S PDM up-sample rate configuration
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ */
+esp_err_t m_i2s_set_pdm_tx_up_sample(i2s_port_t i2s_num, const i2s_pdm_tx_upsample_cfg_t *upsample_cfg)
+{
+    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_FAIL, TAG, "i2s has not installed yet");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM), ESP_ERR_INVALID_ARG, TAG, "i2s mode is not PDM mode");
+
+    xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
+    m_i2s_stop(i2s_num);
+    i2s_hal_set_tx_pdm_fpfs(&(p_i2s[i2s_num]->hal), upsample_cfg->fp, upsample_cfg->fs);
+    m_i2s_start(i2s_num);
+    xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
+    return m_i2s_set_clk(i2s_num, upsample_cfg->sample_rate, p_i2s[i2s_num]->hal_cfg.sample_bits, p_i2s[i2s_num]->hal_cfg.active_chan);
+}
+#endif
+
+/**
+ * @brief   I2S check the validity of configuration
+ *
+ * @param   i2s_num     I2S device number
+ * @param   cfg         I2S HAL configuration
+ * @return
+ *      - ESP_OK                I2S configuration is valid
+ *      - ESP_ERR_INVALID_ARG   I2S configuration is invalid
+ */
+static esp_err_t m_i2s_check_cfg_validity(i2s_port_t i2s_num, i2s_hal_config_t *cfg)
+{
+#if SOC_I2S_SUPPORTS_PDM_TX || SOC_I2S_SUPPORTS_PDM_RX
+    /* Check PDM mode */
+    if (cfg->mode & I2S_MODE_PDM) {
+        ESP_RETURN_ON_FALSE(i2s_num == I2S_NUM_0, ESP_ERR_INVALID_ARG, TAG, "I2S PDM mode only support on I2S0");
+#if !SOC_I2S_SUPPORTS_PDM_TX
+        ESP_RETURN_ON_FALSE(!(cfg->mode & I2S_MODE_TX), ESP_ERR_INVALID_ARG, TAG, "PDM does not support TX on this chip");
+#endif // SOC_I2S_SUPPORTS_PDM_TX
+#if !SOC_I2S_SUPPORTS_PDM_RX
+        ESP_RETURN_ON_FALSE(!(cfg->mode & I2S_MODE_RX), ESP_ERR_INVALID_ARG, TAG, "PDM does not support RX on this chip");
+#endif // SOC_I2S_SUPPORTS_PDM_RX
+    }
+#else
+    ESP_RETURN_ON_FALSE(!(cfg->mode & I2S_MODE_PDM), ESP_ERR_INVALID_ARG, TAG, "I2S PDM mode not supported on current chip");
+#endif // SOC_I2S_SUPPORTS_PDM_TX || SOC_I2S_SUPPORTS_PDM_RX
+
+#if _SOC_I2S_SUPPORTS_ADC || _SOC_I2S_SUPPORTS_DAC
+    /* Check built-in ADC/DAC mode */
+    if (cfg->mode & (I2S_MODE_ADC_BUILT_IN | I2S_MODE_DAC_BUILT_IN)) {
+        ESP_RETURN_ON_FALSE(i2s_num == I2S_NUM_0, ESP_ERR_INVALID_ARG, TAG, "I2S built-in ADC/DAC only support on I2S0");
+    }
+#else
+    /* Check the transmit/receive mode */
+    ESP_RETURN_ON_FALSE((cfg->mode & I2S_MODE_TX) || (cfg->mode & I2S_MODE_RX), ESP_ERR_INVALID_ARG, TAG, "I2S no TX/RX mode selected");
+    /* Check communication format */
+    ESP_RETURN_ON_FALSE(cfg->comm_fmt && (cfg->comm_fmt < I2S_COMM_FORMAT_STAND_MAX), ESP_ERR_INVALID_ARG, TAG, "invalid communication formats");
+#endif // _SOC_I2S_SUPPORTS_ADC || _SOC_I2S_SUPPORTS_DAC
+
+    return ESP_OK;
+}
+
+static void m_i2s_tx_set_clk_and_channel(i2s_port_t i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
+{
+    i2s_hal_tx_clock_config(&(p_i2s[i2s_num]->hal), clk_cfg);
+    i2s_hal_set_tx_sample_bit(&(p_i2s[i2s_num]->hal), p_i2s[i2s_num]->hal_cfg.chan_bits, p_i2s[i2s_num]->hal_cfg.sample_bits);
+    i2s_hal_tx_set_channel_style(&(p_i2s[i2s_num]->hal), &(p_i2s[i2s_num]->hal_cfg));
+}
+
+static void m_i2s_rx_set_clk_and_channel(i2s_port_t i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
+{
+    i2s_hal_rx_clock_config(&(p_i2s[i2s_num]->hal), clk_cfg);
+    i2s_hal_set_rx_sample_bit(&(p_i2s[i2s_num]->hal), p_i2s[i2s_num]->hal_cfg.chan_bits, p_i2s[i2s_num]->hal_cfg.sample_bits);
+    i2s_hal_rx_set_channel_style(&(p_i2s[i2s_num]->hal), &(p_i2s[i2s_num]->hal_cfg));
+}
+
+/**
+ * @brief   Get clock set on particular port number.
+ *
+ * @param   i2s_num         I2S device number
+ * @return
+ *      - sample rate
+ */
+float m_i2s_get_clk(i2s_port_t i2s_num)
+{
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    return (float)p_i2s[i2s_num]->hal_cfg.sample_rate;
+}
+
+/**
+ * @brief   Set clock & bit width used for I2S RX and TX.
+ *          Similar to i2s_set_sample_rates(), but also sets bit width.
+ *
+ * 1. stop i2s
+ * 2. calculate mclk, bck, bck_factor
+ * 3. set clock configurations
+ * 4. realloc dma buffer if DMA buffer size changed
+ * 5. start i2s
+ *
+ * @param   i2s_num     I2S device number
+ * @param   rate        I2S sample rate (ex: 8000, 44100...)
+ * @param   bits_cfg    I2S bits configuration
+ *             the low 16 bits is for data bits per sample in one channel (see 'i2s_bits_per_sample_t')
+ *             the high 16 bits is for total bits in one channel (see 'i2s_bits_per_chan_t')
+ *             high 16bits =0 means same as the bits per sample.
+ * @param   ch          I2S channel, (I2S_CHANNEL_MONO, I2S_CHANNEL_STEREO or specific channel in TDM mode)
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ */
+esp_err_t m_i2s_set_clk(i2s_port_t i2s_num, uint32_t rate, uint32_t bits_cfg, i2s_channel_t ch)
+{
+    esp_err_t ret = ESP_OK;
+
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_ERR_INVALID_ARG, TAG, "I2S%d has not installed yet", i2s_num);
+
+    i2s_hal_config_t *cfg = &p_i2s[i2s_num]->hal_cfg;
+
+    /* Acquire the lock before stop i2s, otherwise reading/writing operation will stuck on receiving the message queue from interrupt */
+    if (cfg->mode & I2S_MODE_TX) {
+        xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
+    }
+    if (cfg->mode & I2S_MODE_RX) {
+        xSemaphoreTake(p_i2s[i2s_num]->rx->mux, (portTickType)portMAX_DELAY);
+    }
+
+    /* Stop I2S */
+    m_i2s_stop(i2s_num);
+
+    /* If not the first time, update configuration */
+    if (p_i2s[i2s_num]->last_buf_size) {
+        cfg->sample_rate = rate;
+        cfg->sample_bits = bits_cfg & 0xFFFF;
+        cfg->chan_bits = (bits_cfg >> 16) > cfg->sample_bits ? (bits_cfg >> 16) : cfg->sample_bits;
+#if SOC_I2S_SUPPORTS_TDM
+        if (ch & I2S_CHANNEL_MONO) {
+            if (ch >> 16) {
+                cfg->chan_fmt = I2S_CHANNEL_FMT_MULTIPLE;
+                cfg->chan_mask = 1 << __builtin_ctz(ch & 0xFFFF0000); // mono the minimun actived slot
+                cfg->total_chan = m_i2s_get_max_channel_num(ch);
+            } else {
+                if (p_i2s[i2s_num]->init_chan_fmt == I2S_CHANNEL_FMT_ONLY_LEFT) {
+                    cfg->chan_mask = I2S_TDM_ACTIVE_CH1; // left slot mono
+                    cfg->chan_fmt = I2S_CHANNEL_FMT_ONLY_LEFT;
+                } else {
+                    cfg->chan_mask = I2S_TDM_ACTIVE_CH0; // right slot mono
+                    cfg->chan_fmt = I2S_CHANNEL_FMT_ONLY_RIGHT;
+                }
+#if SOC_I2S_SUPPORTS_PDM_RX
+                cfg->total_chan = (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM) ? 1 : 2;
+#else
+                cfg->total_chan = 2;
+#endif
+            }
+        } else {
+            if (ch >> 16) {
+                cfg->chan_fmt = I2S_CHANNEL_FMT_MULTIPLE;
+                cfg->chan_mask = ch & 0xFFFF0000;
+                cfg->total_chan = m_i2s_get_max_channel_num(cfg->chan_mask);
+            } else {
+                /* If no TDM channels activated, use 2 channels as defualt */
+                cfg->chan_fmt = I2S_CHANNEL_FMT_RIGHT_LEFT;
+                cfg->chan_mask = I2S_TDM_ACTIVE_CH0 | I2S_TDM_ACTIVE_CH1;
+                cfg->total_chan = 2;
+            }
+        }
+#else
+        /* Default */
+        if (ch & I2S_CHANNEL_MONO) {
+            if (p_i2s[i2s_num]->init_chan_fmt == I2S_CHANNEL_FMT_ONLY_LEFT) {
+                cfg->chan_fmt = I2S_CHANNEL_FMT_ONLY_LEFT;
+            } else {
+                cfg->chan_fmt = I2S_CHANNEL_FMT_ONLY_RIGHT;
+            }
+        } else {
+            cfg->chan_fmt = I2S_CHANNEL_FMT_RIGHT_LEFT;
+        }
+        cfg->active_chan = m_i2s_get_active_channel_num(cfg);
+        cfg->total_chan = 2;
+#endif
+        if (cfg->mode & I2S_MODE_TX) {
+            i2s_hal_tx_set_channel_style(&(p_i2s[i2s_num]->hal), cfg);
+        }
+        if (cfg->mode & I2S_MODE_RX) {
+            i2s_hal_rx_set_channel_style(&(p_i2s[i2s_num]->hal), cfg);
+        }
+    }
+    uint32_t data_bits = cfg->sample_bits;
+
+    /* Check the validity of sample bits */
+    ESP_RETURN_ON_FALSE((data_bits % 8 == 0), ESP_ERR_INVALID_ARG, TAG, "Invalid bits per sample");
+    ESP_RETURN_ON_FALSE((data_bits <= I2S_BITS_PER_SAMPLE_32BIT), ESP_ERR_INVALID_ARG, TAG, "Invalid bits per sample");
+
+    i2s_hal_clock_cfg_t clk_cfg;
+    /* To get sclk, mclk, mclk_div bclk and bclk_div */
+    m_i2s_calculate_clock(i2s_num, &clk_cfg);
+
+    uint32_t buf_size = m_i2s_get_buf_size(i2s_num);
+    bool need_realloc = p_i2s[i2s_num]->last_buf_size != buf_size;
+
+    /* TX mode clock reset */
+    if (cfg->mode & I2S_MODE_TX) {
+        ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->tx, ESP_ERR_INVALID_ARG, TAG, "I2S TX DMA object has not initialized yet");
+        /* Waiting for transmit finish */
+        m_i2s_tx_set_clk_and_channel(i2s_num, &clk_cfg);
+        /* Workaround for ESP32-S3/C3, overwrite with speicial coefficients to lower down the noise */
+#if SOC_I2S_SUPPORTS_PDM_CODEC
+        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM) {
+            i2s_ll_tx_set_raw_clk_div(p_i2s[i2s_num]->hal.dev, 1, 1, 0, 0);
+        }
+#endif // SOC_I2S_SUPPORTS_PDM_TX
+
+        /* If buffer size changed, the DMA buffer need realloc */
+        if (need_realloc) {
+            p_i2s[i2s_num]->tx->buf_size = buf_size;
+            ret = m_i2s_realloc_dma_buffer(i2s_num, p_i2s[i2s_num]->tx);
+        }
+        /* If not the first time, update I2S tx channel style */
+        if (p_i2s[i2s_num]->last_buf_size) {
+            i2s_hal_tx_set_channel_style(&(p_i2s[i2s_num]->hal), &(p_i2s[i2s_num]->hal_cfg));
+        }
+        /* Reset the queue to avoid receive invalid data */
+        xQueueReset(p_i2s[i2s_num]->tx->queue);
+        ESP_RETURN_ON_ERROR(ret, TAG, "I2S%d tx DMA buffer malloc failed", i2s_num);
+    }
+    /* RX mode clock reset */
+    if (cfg->mode & I2S_MODE_RX) {
+        ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->rx, ESP_ERR_INVALID_ARG, TAG, "I2S TX DMA object has not initialized yet");
+        /* Waiting for receive finish */
+        m_i2s_rx_set_clk_and_channel(i2s_num, &clk_cfg);
+        /* If buffer size changed, the DMA buffer need realloc */
+        if (need_realloc) {
+            p_i2s[i2s_num]->rx->buf_size = buf_size;
+            ret = m_i2s_realloc_dma_buffer(i2s_num, p_i2s[i2s_num]->rx);
+            /* Reset the end-of-frame number */
+            i2s_hal_set_rx_eof_num(&(p_i2s[i2s_num]->hal), buf_size);
+        }
+        /* If not the first time, update I2S rx channel style */
+        if (p_i2s[i2s_num]->last_buf_size) {
+            i2s_hal_rx_set_channel_style(&(p_i2s[i2s_num]->hal), &(p_i2s[i2s_num]->hal_cfg));
+        }
+        /* Reset the queue to avoid receiving invalid data */
+        xQueueReset(p_i2s[i2s_num]->rx->queue);
+        ESP_RETURN_ON_ERROR(ret, TAG, "I2S%d rx DMA buffer malloc failed", i2s_num);
+    }
+    /* Update last buffer size */
+    p_i2s[i2s_num]->last_buf_size = buf_size;
+
+    /* I2S start */
+    m_i2s_start(i2s_num);
+
+    if (cfg->mode & I2S_MODE_TX) {
+        xSemaphoreGive(p_i2s[i2s_num]->tx->mux);
+    }
+    if (cfg->mode & I2S_MODE_RX) {
+        xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
+    }
+
+    return ESP_OK;
+}
+
+/*-------------------------------------------------------------
+                   I2S driver operation
+  -------------------------------------------------------------*/
+/**
+ * @brief   Start I2S driver
+ * @note    It is not necessary to call this function after i2s_driver_install() (it is started automatically), however it is necessary to call it after i2s_stop().
+ *
+ * @param   i2s_num  I2S device number
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_start(i2s_port_t i2s_num)
+{
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    //start DMA link
+    I2S_ENTER_CRITICAL(i2s_num);
+
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+        m_i2s_tx_reset(i2s_num);
+        m_i2s_tx_start(i2s_num);
+    }
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+        m_i2s_rx_reset(i2s_num);
+        i2s_rx_start(i2s_num);
+    }
+#if !SOC_GDMA_SUPPORTED
+    esp_intr_enable(p_i2s[i2s_num]->i2s_isr_handle);
+#endif
+    I2S_EXIT_CRITICAL(i2s_num);
+    return ESP_OK;
+}
+
+/**
+ * @brief   Stop I2S driver
+ * @note    There is no need to call i2s_stop() before calling i2s_driver_uninstall().
+ *          Disables I2S TX/RX, until i2s_start() is called.
+ *
+ * @param   i2s_num     I2S device number
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_stop(i2s_port_t i2s_num)
+{
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    I2S_ENTER_CRITICAL(i2s_num);
+#if !SOC_GDMA_SUPPORTED
+    esp_intr_disable(p_i2s[i2s_num]->i2s_isr_handle);
+#endif
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+        m_i2s_tx_stop(i2s_num);
+    }
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+        m_i2s_rx_stop(i2s_num);
+    }
+#if !SOC_GDMA_SUPPORTED
+    i2s_hal_clear_intr_status(&(p_i2s[i2s_num]->hal), I2S_INTR_MAX);
+#endif
+    I2S_EXIT_CRITICAL(i2s_num);
+    return ESP_OK;
+}
+
+/**
+ * @brief   Initialize I2S driver configurations
+ *
+ * @param   i2s_num     I2S device number
+ * @param   i2s_config  I2S configurations - see i2s_config_t struct
+ * @return
+ *      - ESP_OK        I2S initialize success
+ *      - ESP_ERR_INVALID_ARG   No channel enabled in multiple channel format
+ */
+static esp_err_t m_i2s_driver_init(i2s_port_t i2s_num, const i2s_config_t *i2s_config)
+{
+    ESP_RETURN_ON_FALSE(i2s_config, ESP_ERR_INVALID_ARG, TAG, "The pointer of I2S configuration structure is NULL");
+
+    /* I2S driver configuration assignment */
+    p_i2s[i2s_num]->i2s_num = i2s_num;
+    p_i2s[i2s_num]->dma_buf_count = i2s_config->dma_buf_count;
+    p_i2s[i2s_num]->dma_buf_len = i2s_config->dma_buf_len;
+    p_i2s[i2s_num]->last_buf_size = 0;
+    p_i2s[i2s_num]->use_apll = i2s_config->use_apll;
+    p_i2s[i2s_num]->fixed_mclk = i2s_config->fixed_mclk;
+    p_i2s[i2s_num]->mclk_multiple = i2s_config->mclk_multiple;
+    p_i2s[i2s_num]->tx_desc_auto_clear = i2s_config->tx_desc_auto_clear;
+    p_i2s[i2s_num]->init_chan_fmt = i2s_config->channel_format;
+
+    /* I2S HAL configuration assignment */
+    p_i2s[i2s_num]->hal_cfg.mode = i2s_config->mode;
+    p_i2s[i2s_num]->hal_cfg.sample_rate = i2s_config->sample_rate;
+    p_i2s[i2s_num]->hal_cfg.comm_fmt = i2s_config->communication_format;
+    p_i2s[i2s_num]->hal_cfg.chan_fmt = i2s_config->channel_format;
+    p_i2s[i2s_num]->hal_cfg.sample_bits = i2s_config->bits_per_sample;
+    p_i2s[i2s_num]->hal_cfg.chan_bits = (uint32_t)i2s_config->bits_per_chan < (uint32_t)i2s_config->bits_per_sample ?
+                                        (uint32_t)i2s_config->bits_per_sample : (uint32_t)i2s_config->bits_per_chan;
+
+#if SOC_I2S_SUPPORTS_TDM
+    /* I2S HAL TDM configuration assignment */
+    p_i2s[i2s_num]->hal_cfg.left_align    = i2s_config->left_align;
+    p_i2s[i2s_num]->hal_cfg.big_edin      = i2s_config->big_edin;
+    p_i2s[i2s_num]->hal_cfg.bit_order_msb = i2s_config->bit_order_msb;
+    p_i2s[i2s_num]->hal_cfg.skip_msk      = i2s_config->skip_msk;
+
+    /* Set chan_mask according to channel format */
+    switch (i2s_config->channel_format) {
+    case I2S_CHANNEL_FMT_RIGHT_LEFT:    // fall through
+    case I2S_CHANNEL_FMT_ALL_RIGHT:     // fall through
+    case I2S_CHANNEL_FMT_ALL_LEFT:
+        p_i2s[i2s_num]->hal_cfg.chan_mask = I2S_TDM_ACTIVE_CH0 | I2S_TDM_ACTIVE_CH1;
+        p_i2s[i2s_num]->hal_cfg.total_chan = 2;
+        break;
+    case I2S_CHANNEL_FMT_ONLY_RIGHT:
+        p_i2s[i2s_num]->hal_cfg.chan_mask = I2S_TDM_ACTIVE_CH1;
+        p_i2s[i2s_num]->hal_cfg.total_chan = 2;
+        break;
+    case I2S_CHANNEL_FMT_ONLY_LEFT:
+        p_i2s[i2s_num]->hal_cfg.chan_mask = I2S_TDM_ACTIVE_CH0;
+        p_i2s[i2s_num]->hal_cfg.total_chan = 2;
+        break;
+    case I2S_CHANNEL_FMT_MULTIPLE:
+        ESP_RETURN_ON_FALSE((i2s_config->chan_mask >> 16), ESP_ERR_INVALID_ARG, TAG, "i2s all channel are disabled");
+        p_i2s[i2s_num]->hal_cfg.chan_mask = i2s_config->chan_mask & 0xFFFF0000;
+        /* Get the max actived channel number */
+        uint32_t max_channel = m_i2s_get_max_channel_num(p_i2s[i2s_num]->hal_cfg.chan_mask);
+        /* If total channel is smaller than max actived channel number then set it to the max active channel number */
+        p_i2s[i2s_num]->hal_cfg.total_chan    = p_i2s[i2s_num]->hal_cfg.total_chan < max_channel ? max_channel :
+                                                p_i2s[i2s_num]->hal_cfg.total_chan;
+        break;
+    default:
+        ESP_RETURN_ON_FALSE(false, ESP_ERR_INVALID_ARG, TAG, "wrong i2s channel format, going to uninstall i2s");
+    }
+
+    /* Calculate actived channel number in channel mask */
+    p_i2s[i2s_num]->hal_cfg.active_chan   = i2s_get_active_channel_num(&p_i2s[i2s_num]->hal_cfg);
+
+#else
+    /* Calculate actived channel number in channel mask */
+    p_i2s[i2s_num]->hal_cfg.active_chan   = m_i2s_get_active_channel_num(&p_i2s[i2s_num]->hal_cfg);
+    /* Total channel number is equal to the actived channel number in non-TDM mode */
+    p_i2s[i2s_num]->hal_cfg.total_chan    = 2;
+#endif
+    return ESP_OK;
+}
+
+/**
+ * @brief   Initialize I2S DMA object
+ *
+ * @param   i2s_num     I2S device number
+ * @return
+ *      - ESP_OK            DMA object initialize success
+ *      - ESP_ERR_NO_MEM    No memory for DMA object
+ */
+static esp_err_t m_i2s_dma_object_init(i2s_port_t i2s_num)
+{
+    uint32_t buf_size = m_i2s_get_buf_size(i2s_num);
+    /* Create DMA object */
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+        ESP_RETURN_ON_ERROR(m_i2s_create_dma_object(i2s_num, &p_i2s[i2s_num]->tx), TAG, "I2S TX DMA object create failed");
+        p_i2s[i2s_num]->tx->buf_size = buf_size;
+    }
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+        ESP_RETURN_ON_ERROR(m_i2s_create_dma_object(i2s_num, &p_i2s[i2s_num]->rx), TAG, "I2S RX DMA object create failed");
+        p_i2s[i2s_num]->rx->buf_size = buf_size;
+    }
+    return ESP_OK;
+}
+
+/**
+ * @brief   Install and start I2S driver.
+ * @note    This function must be called before any I2S driver read/write operations.
+ *
+ *
+ * @param   i2s_num         I2S device number
+ * @param   i2s_config      I2S configurations - see i2s_config_t struct
+ * @param   queue_size      I2S event queue size/depth.
+ * @param   i2s_queue       I2S event queue handle, if set NULL, driver will not use an event queue.
+ *
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM      Out of memory
+ *     - ESP_ERR_INVALID_STATE  Current I2S port is in use
+ */
+esp_err_t m_i2s_driver_install(i2s_port_t i2s_num, const i2s_config_t *i2s_config, int queue_size, void *i2s_queue)
+{
+    esp_err_t ret = ESP_OK;
+
+    /* Step 1: Check the validity of input parameters */
+    /* Check the validity of i2s device number */
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    ESP_RETURN_ON_FALSE(i2s_config, ESP_ERR_INVALID_ARG, TAG, "I2S configuration must not be NULL");
+    /* Check the size of DMA buffer */
+    ESP_RETURN_ON_FALSE((i2s_config->dma_buf_count >= 2 && i2s_config->dma_buf_count <= 128), ESP_ERR_INVALID_ARG, TAG, "I2S buffer count less than 128 and more than 2");
+    ESP_RETURN_ON_FALSE((i2s_config->dma_buf_len >= 8 && i2s_config->dma_buf_len <= 1024), ESP_ERR_INVALID_ARG, TAG, "I2S buffer length at most 1024 and more than 8");
+
+    /* Step 2: Allocate driver object and register to platform */
+    i2s_obj_t *pre_alloc_i2s_obj = calloc(1, sizeof(i2s_obj_t));
+    ESP_RETURN_ON_FALSE(pre_alloc_i2s_obj, ESP_ERR_NO_MEM, TAG, "no mem for I2S driver");
+    ret = m_i2s_priv_register_object(pre_alloc_i2s_obj, i2s_num);
+    if (ret != ESP_OK) {
+        free(pre_alloc_i2s_obj);
+        ESP_LOGE(TAG, "register I2S object to platform failed");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    /* Step 3: Initialize I2S object, assign configarations */
+    ESP_GOTO_ON_ERROR(m_i2s_driver_init(i2s_num, i2s_config), err, TAG, "I2S init failed");
+    /* Check the validity of I2S configuration */
+    ESP_GOTO_ON_ERROR(m_i2s_check_cfg_validity(i2s_num, &(pre_alloc_i2s_obj->hal_cfg)), err, TAG, "I2S configuration is invalid");
+
+    /* Get device instance */
+    i2s_hal_init(&(pre_alloc_i2s_obj->hal), i2s_num);
+
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_type_t pm_lock = ESP_PM_APB_FREQ_MAX;
+#if SOC_I2S_SUPPORTS_APLL
+    if (i2s_config->use_apll) {
+        pm_lock = ESP_PM_NO_LIGHT_SLEEP;
+    }
+#endif // SOC_I2S_SUPPORTS_APLL
+    ESP_GOTO_ON_ERROR(esp_pm_lock_create(pm_lock, 0, "i2s_driver", &pre_alloc_i2s_obj->pm_lock), err, TAG, "I2S pm lock error");
+#endif //CONFIG_PM_ENABLE
+
+    /* Step 4: Initialize I2S DMA interrupt and DMA object */
+    ESP_GOTO_ON_ERROR(m_i2s_dma_intr_init(i2s_num, i2s_config->intr_alloc_flags), err, TAG, "I2S interrupt initailze failed");
+    /* Initialize I2S DMA object */
+    ESP_GOTO_ON_ERROR(m_i2s_dma_object_init(i2s_num), err, TAG,  "I2S dma object create failed");
+
+#if _SOC_I2S_SUPPORTS_ADC
+    /* If using built-in ADC, we need to enable ADC power manerge*/
+    if (pre_alloc_i2s_obj->hal_cfg.mode & I2S_MODE_ADC_BUILT_IN) {
+        sar_periph_ctrl_adc_continuous_power_acquire();
+    }
+#endif
+    /* Enable module clock */
+    i2s_hal_enable_module_clock(&p_i2s[i2s_num]->hal);
+#if SOC_I2S_SUPPORTS_TDM
+    if (i2s_config->mode & I2S_MODE_TX) {
+        i2s_ll_tx_enable_clock(p_i2s[i2s_num]->hal.dev);
+    }
+    if (i2s_config->mode & I2S_MODE_RX) {
+        i2s_ll_rx_enable_clock(p_i2s[i2s_num]->hal.dev);
+    }
+#endif
+
+    /* Step 5: Initialize I2S configuration and set the configurations to register */
+    i2s_hal_config_param(&(pre_alloc_i2s_obj->hal), &pre_alloc_i2s_obj->hal_cfg);
+
+    /* Step 6: Initialise i2s event queue if user needs */
+    if (i2s_queue) {
+        pre_alloc_i2s_obj->i2s_queue = xQueueCreate(queue_size, sizeof(i2s_event_t));
+        ESP_GOTO_ON_FALSE(pre_alloc_i2s_obj->i2s_queue, ESP_ERR_NO_MEM, err, TAG, "I2S queue create failed");
+        *((QueueHandle_t *) i2s_queue) = pre_alloc_i2s_obj->i2s_queue;
+        ESP_LOGI(TAG, "queue free spaces: %d", uxQueueSpacesAvailable(pre_alloc_i2s_obj->i2s_queue));
+    } else {
+        pre_alloc_i2s_obj->i2s_queue = NULL;
+    }
+
+    /* Step 7: Set I2S clocks and start. No need to give parameters since configurations has been set in 'i2s_driver_init' */
+    ESP_GOTO_ON_ERROR(m_i2s_set_clk(i2s_num, 0, 0, 0), err, TAG, "I2S set clock failed");
+
+    return ESP_OK;
+
+err:
+    /* I2S install failed, prepare to uninstall */
+    m_i2s_driver_uninstall(i2s_num);
+    return ret;
+}
+
+/**
+ * @brief Uninstall I2S driver.
+ *
+ * @param   i2s_num     I2S device number
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_driver_uninstall(i2s_port_t i2s_num)
+{
+    ESP_RETURN_ON_FALSE(i2s_num < I2S_NUM_MAX, ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_ERR_INVALID_STATE, TAG, "I2S port %d has not installed", i2s_num);
+    i2s_obj_t *obj = p_i2s[i2s_num];
+    m_i2s_stop(i2s_num);
+#if _SOC_I2S_SUPPORTS_DAC
+    m_i2s_set_dac_mode(I2S_DAC_CHANNEL_DISABLE);
+#endif
+#if SOC_GDMA_SUPPORTED
+    if (p_i2s[i2s_num]->tx_dma_chan) {
+        gdma_disconnect(p_i2s[i2s_num]->tx_dma_chan);
+        gdma_del_channel(p_i2s[i2s_num]->tx_dma_chan);
+    }
+    if (p_i2s[i2s_num]->rx_dma_chan) {
+        gdma_disconnect(p_i2s[i2s_num]->rx_dma_chan);
+        gdma_del_channel(p_i2s[i2s_num]->rx_dma_chan);
+    }
+#else
+    if (p_i2s[i2s_num]->i2s_isr_handle) {
+        esp_intr_free(p_i2s[i2s_num]->i2s_isr_handle);
+    }
+#endif
+    /* Destroy dma object if exist */
+    m_i2s_destroy_dma_object(i2s_num, &p_i2s[i2s_num]->tx);
+    m_i2s_destroy_dma_object(i2s_num, &p_i2s[i2s_num]->rx);
+
+    if (p_i2s[i2s_num]->i2s_queue) {
+        vQueueDelete(p_i2s[i2s_num]->i2s_queue);
+        p_i2s[i2s_num]->i2s_queue = NULL;
+    }
+
+#if SOC_I2S_SUPPORTS_APLL
+    if (p_i2s[i2s_num]->use_apll) {
+        // switch back to PLL clock source
+        i2s_hal_set_clock_src(&(p_i2s[i2s_num]->hal), I2S_CLK_D2CLK);
+        rtc_clk_apll_enable(0, 0, 0, 0, 0);
+    }
+#endif
+
+#ifdef CONFIG_PM_ENABLE
+    if (p_i2s[i2s_num]->pm_lock) {
+        esp_pm_lock_delete(p_i2s[i2s_num]->pm_lock);
+        p_i2s[i2s_num]->pm_lock = NULL;
+    }
+#endif
+#if SOC_I2S_SUPPORTS_TDM
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
+        i2s_ll_tx_disable_clock(p_i2s[i2s_num]->hal.dev);
+    }
+    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
+        i2s_ll_rx_disable_clock(p_i2s[i2s_num]->hal.dev);
+    }
+#endif
+    /* Disable module clock */
+    i2s_hal_disable_module_clock(&p_i2s[i2s_num]->hal);
+    m_i2s_priv_deregister_object(i2s_num);
+    free(obj);
+    return ESP_OK;
+}
+
+/**
+ * @brief   Write data to I2S DMA transmit buffer.
+ * @note    Many ticks pass without space becoming available in the DMA
+ *          transmit buffer, then the function will return (note that if the
+ *          data is written to the DMA buffer in pieces, the overall operation
+ *          may still take longer than this timeout.) Pass portMAX_DELAY for no
+ *          timeout.
+ *
+ * @param       i2s_num             I2S device number
+ * @param       src                 Source address to write from
+ * @param       size                Size of data in bytes
+ * @param[out]  bytes_written       Number of bytes written, if timeout, the result will be less than the size passed in.
+ * @param       ticks_to_wait       TX buffer wait timeout in RTOS ticks. If this
+ * @return
+ *     - ESP_OK               Success
+ *     - ESP_ERR_INVALID_ARG  Parameter error
+ */
+esp_err_t m_i2s_write(i2s_port_t i2s_num, const void *src, size_t size, size_t *bytes_written, TickType_t ticks_to_wait)
+{
+    char *data_ptr, *src_byte;
+    size_t bytes_can_write;
+    *bytes_written = 0;
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->tx), ESP_ERR_INVALID_ARG, TAG, "TX mode is not enabled");
+    xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_acquire(p_i2s[i2s_num]->pm_lock);
+#endif
+    src_byte = (char *)src;
+    while (size > 0) {
+        if (p_i2s[i2s_num]->tx->rw_pos == p_i2s[i2s_num]->tx->buf_size || p_i2s[i2s_num]->tx->curr_ptr == NULL) {
+            if (xQueueReceive(p_i2s[i2s_num]->tx->queue, &p_i2s[i2s_num]->tx->curr_ptr, ticks_to_wait) == pdFALSE) {
+                break;
+            }
+            p_i2s[i2s_num]->tx->rw_pos = 0;
+        }
+        ESP_LOGD(TAG, "size: %d, rw_pos: %d, buf_size: %d, curr_ptr: %d", size, p_i2s[i2s_num]->tx->rw_pos, p_i2s[i2s_num]->tx->buf_size, (int)p_i2s[i2s_num]->tx->curr_ptr);
+        data_ptr = (char *)p_i2s[i2s_num]->tx->curr_ptr;
+        data_ptr += p_i2s[i2s_num]->tx->rw_pos;
+        bytes_can_write = p_i2s[i2s_num]->tx->buf_size - p_i2s[i2s_num]->tx->rw_pos;
+        if (bytes_can_write > size) {
+            bytes_can_write = size;
+        }
+        memcpy(data_ptr, src_byte, bytes_can_write);
+        size -= bytes_can_write;
+        src_byte += bytes_can_write;
+        p_i2s[i2s_num]->tx->rw_pos += bytes_can_write;
+        (*bytes_written) += bytes_can_write;
+    }
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_release(p_i2s[i2s_num]->pm_lock);
+#endif
+    xSemaphoreGive(p_i2s[i2s_num]->tx->mux);
+    return ESP_OK;
+}
+
+/**
+ * @brief   Write data to I2S DMA transmit buffer while expanding the number of bits per sample. For example, expanding 16-bit PCM to 32-bit PCM.
+ * @note    Many ticks pass without space becoming available in the DMA
+ *          transmit buffer, then the function will return (note that if the
+ *          data is written to the DMA buffer in pieces, the overall operation
+ *          may still take longer than this timeout.) Pass portMAX_DELAY for no
+ *          timeout.
+ *          Format of the data in source buffer is determined by the I2S configuration (see i2s_config_t).
+ *
+ * @param       i2s_num             I2S device number
+ * @param       src                 Source address to write from
+ * @param       size                Size of data in bytes
+ * @param       src_bits            Source audio bit
+ * @param       aim_bits            Bit wanted, no more than 32, and must be greater than src_bits
+ * @param[out]  bytes_written       Number of bytes written, if timeout, the result will be less than the size passed in.
+ * @param       ticks_to_wait       TX buffer wait timeout in RTOS ticks. If this
+ * @return
+ *     - ESP_OK              Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t m_i2s_write_expand(i2s_port_t i2s_num, const void *src, size_t size, size_t src_bits, size_t aim_bits, size_t *bytes_written, TickType_t ticks_to_wait)
+{
+    char *data_ptr;
+    int bytes_can_write, tail;
+    int src_bytes, aim_bytes, zero_bytes;
+    *bytes_written = 0;
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    ESP_RETURN_ON_FALSE((size > 0), ESP_ERR_INVALID_ARG, TAG, "size must greater than zero");
+    ESP_RETURN_ON_FALSE((aim_bits >= src_bits), ESP_ERR_INVALID_ARG, TAG, "aim_bits mustn't be less than src_bits");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->tx), ESP_ERR_INVALID_ARG, TAG, "TX mode is not enabled");
+    if (src_bits < I2S_BITS_PER_SAMPLE_8BIT || aim_bits < I2S_BITS_PER_SAMPLE_8BIT) {
+        ESP_LOGE(TAG, "bits mustn't be less than 8, src_bits %d aim_bits %d", src_bits, aim_bits);
+        return ESP_ERR_INVALID_ARG;
+    }
+    if (src_bits > I2S_BITS_PER_SAMPLE_32BIT || aim_bits > I2S_BITS_PER_SAMPLE_32BIT) {
+        ESP_LOGE(TAG, "bits mustn't be greater than 32, src_bits %d aim_bits %d", src_bits, aim_bits);
+        return ESP_ERR_INVALID_ARG;
+    }
+    if ((src_bits == I2S_BITS_PER_SAMPLE_16BIT || src_bits == I2S_BITS_PER_SAMPLE_32BIT) && (size % 2 != 0)) {
+        ESP_LOGE(TAG, "size must be a even number while src_bits is even, src_bits %d size %d", src_bits, size);
+        return ESP_ERR_INVALID_ARG;
+    }
+    if (src_bits == I2S_BITS_PER_SAMPLE_24BIT && (size % 3 != 0)) {
+        ESP_LOGE(TAG, "size must be a multiple of 3 while src_bits is 24, size %d", size);
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    src_bytes = src_bits / 8;
+    aim_bytes = aim_bits / 8;
+    zero_bytes = aim_bytes - src_bytes;
+    xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
+    size = size * aim_bytes / src_bytes;
+    ESP_LOGD(TAG, "aim_bytes %d src_bytes %d size %d", aim_bytes, src_bytes, size);
+    while (size > 0) {
+        if (p_i2s[i2s_num]->tx->rw_pos == p_i2s[i2s_num]->tx->buf_size || p_i2s[i2s_num]->tx->curr_ptr == NULL) {
+            if (xQueueReceive(p_i2s[i2s_num]->tx->queue, &p_i2s[i2s_num]->tx->curr_ptr, ticks_to_wait) == pdFALSE) {
+                break;
+            }
+            p_i2s[i2s_num]->tx->rw_pos = 0;
+        }
+        data_ptr = (char *)p_i2s[i2s_num]->tx->curr_ptr;
+        data_ptr += p_i2s[i2s_num]->tx->rw_pos;
+        bytes_can_write = p_i2s[i2s_num]->tx->buf_size - p_i2s[i2s_num]->tx->rw_pos;
+        if (bytes_can_write > (int)size) {
+            bytes_can_write = size;
+        }
+        tail = bytes_can_write % aim_bytes;
+        bytes_can_write = bytes_can_write - tail;
+
+        memset(data_ptr, 0, bytes_can_write);
+        for (int j = 0; j < bytes_can_write; j += (aim_bytes - zero_bytes)) {
+            j += zero_bytes;
+            memcpy(&data_ptr[j], (const char *)(src + *bytes_written), aim_bytes - zero_bytes);
+            (*bytes_written) += (aim_bytes - zero_bytes);
+        }
+        size -= bytes_can_write;
+        p_i2s[i2s_num]->tx->rw_pos += bytes_can_write;
+    }
+    xSemaphoreGive(p_i2s[i2s_num]->tx->mux);
+    return ESP_OK;
+}
+
+/**
+ * @brief   Read data from I2S DMA receive buffer
+ * @note    If the built-in ADC mode is enabled, we should call i2s_adc_enable and i2s_adc_disable around the whole reading process,
+ *          to prevent the data getting corrupted.
+ *
+ * @param       i2s_num         I2S device number
+ * @param       dest            Destination address to read into
+ * @param       size            Size of data in bytes
+ * @param[out]  bytes_read      Number of bytes read, if timeout, bytes read will be less than the size passed in.
+ * @param       ticks_to_wait   RX buffer wait timeout in RTOS ticks. If this many ticks pass without bytes becoming available in the DMA receive buffer, then the function will return (note that if data is read from the DMA buffer in pieces, the overall operation may still take longer than this timeout.) Pass portMAX_DELAY for no timeout.
+ * @return
+ *     - ESP_OK               Success
+ *     - ESP_ERR_INVALID_ARG  Parameter error
+ */
+esp_err_t m_i2s_read(i2s_port_t i2s_num, void *dest, size_t size, size_t *bytes_read, TickType_t ticks_to_wait)
+{
+    char *data_ptr, *dest_byte;
+    int bytes_can_read;
+    *bytes_read = 0;
+    dest_byte = (char *)dest;
+    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
+    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->rx), ESP_ERR_INVALID_ARG, TAG, "RX mode is not enabled");
+    xSemaphoreTake(p_i2s[i2s_num]->rx->mux, (portTickType)portMAX_DELAY);
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_acquire(p_i2s[i2s_num]->pm_lock);
+#endif
+    while (size > 0) {
+        if (p_i2s[i2s_num]->rx->rw_pos == p_i2s[i2s_num]->rx->buf_size || p_i2s[i2s_num]->rx->curr_ptr == NULL) {
+            if (xQueueReceive(p_i2s[i2s_num]->rx->queue, &p_i2s[i2s_num]->rx->curr_ptr, ticks_to_wait) == pdFALSE) {
+                break;
+            }
+            p_i2s[i2s_num]->rx->rw_pos = 0;
+        }
+        data_ptr = (char *)p_i2s[i2s_num]->rx->curr_ptr;
+        data_ptr += p_i2s[i2s_num]->rx->rw_pos;
+        bytes_can_read = p_i2s[i2s_num]->rx->buf_size - p_i2s[i2s_num]->rx->rw_pos;
+        if (bytes_can_read > (int)size) {
+            bytes_can_read = size;
+        }
+        memcpy(dest_byte, data_ptr, bytes_can_read);
+        size -= bytes_can_read;
+        dest_byte += bytes_can_read;
+        p_i2s[i2s_num]->rx->rw_pos += bytes_can_read;
+        (*bytes_read) += bytes_can_read;
+    }
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_release(p_i2s[i2s_num]->pm_lock);
+#endif
+    xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
+    return ESP_OK;
+}
+
+esp_err_t m_i2s_priv_register_object(void *driver_obj, int port_id)
+{
+    esp_err_t ret = ESP_ERR_NOT_FOUND;
+    ESP_RETURN_ON_FALSE(driver_obj && (port_id < SOC_I2S_NUM), ESP_ERR_INVALID_ARG, TAG, "invalid arguments");
+    portENTER_CRITICAL(&i2s_platform_spinlock);
+    if (!p_i2s[port_id]) {
+        ret = ESP_OK;
+        p_i2s[port_id] = driver_obj;
+        periph_module_enable(i2s_periph_signal[port_id].module);
+    }
+    portEXIT_CRITICAL(&i2s_platform_spinlock);
+    return ret;
+}
+
+esp_err_t m_i2s_priv_deregister_object(int port_id)
+{
+    esp_err_t ret = ESP_ERR_INVALID_STATE;
+    ESP_RETURN_ON_FALSE(port_id < SOC_I2S_NUM, ESP_ERR_INVALID_ARG, TAG, "invalid arguments");
+    portENTER_CRITICAL(&i2s_platform_spinlock);
+    if (p_i2s[port_id]) {
+        ret = ESP_OK;
+        p_i2s[port_id] = NULL;
+        periph_module_disable(i2s_periph_signal[port_id].module);
+    }
+    portEXIT_CRITICAL(&i2s_platform_spinlock);
+    return ret;
+}

From b840f720dc6d4f0273070d99403217978359f6eb Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 10 Aug 2026 22:55:49 -0400
Subject: [PATCH 08/34] Fixed feature exclusion setting

---
 src/output/OutputMgr.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/output/OutputMgr.cpp b/src/output/OutputMgr.cpp
index bc2069737..fd56de710 100644
--- a/src/output/OutputMgr.cpp
+++ b/src/output/OutputMgr.cpp
@@ -614,10 +614,10 @@ void c_OutputMgr::GetStatus (JsonObject & jsonStatus)
 {
     // DEBUG_START;
 
-#if defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_I2S)
     OutputI2S.GetStatus(jsonStatus);
     // jsonStatus["PollCount"] = PollCount;
-#endif // defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_I2S)
 
     JsonArray OutputStatus = jsonStatus[(char*)CN_output].to<JsonArray> ();
     for (uint8_t index = 0; index < NumOutputPorts; ++index)

From 00c397344a0368cea136e2f19497c5513ff2c115 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 10 Aug 2026 22:56:17 -0400
Subject: [PATCH 09/34] fixed feature exclusion setting

---
 src/service/m_i2s.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/service/m_i2s.c b/src/service/m_i2s.c
index 20e0b6042..377b87d98 100644
--- a/src/service/m_i2s.c
+++ b/src/service/m_i2s.c
@@ -3,6 +3,7 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
+#ifdef SUPPORT_I2S
 
 #include <string.h>
 #include <stdbool.h>
@@ -2325,3 +2326,5 @@ esp_err_t m_i2s_priv_deregister_object(int port_id)
     portEXIT_CRITICAL(&i2s_platform_spinlock);
     return ret;
 }
+
+#endif // def SUPPORT_I2S

From 4e583a2d87643978db8244874ccb2b8d413058da Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 17 Aug 2026 22:55:47 -0400
Subject: [PATCH 10/34] Fine grained support for output HW type.

---
 .vscode/extensions.json                       |   4 +-
 include/output/OutputGECERmt.hpp              |   4 +-
 include/output/OutputGECEUart.hpp             |   7 +-
 include/output/OutputGS8208Rmt.hpp            |   4 +-
 include/output/OutputGS8208Uart.hpp           |   7 +-
 include/output/OutputI2S.hpp                  |  51 ++-
 include/output/OutputMgr.hpp                  |  12 +-
 include/output/OutputRmt.hpp                  |   4 +-
 include/output/OutputSerialRmt.hpp            |   4 +-
 include/output/OutputSerialUart.hpp           |   7 +-
 include/output/OutputTLS3001Rmt.hpp           |   4 +-
 include/output/OutputTLS3001RmtFsm.hpp        |   4 +-
 include/output/OutputTM1814Rmt.hpp            |   4 +-
 include/output/OutputTM1814Uart.hpp           |   7 +-
 include/output/OutputUCS1903Rmt.hpp           |   4 +-
 include/output/OutputUCS8903Rmt.hpp           |   4 +-
 include/output/OutputUCS8903Uart.hpp          |   7 +-
 include/output/OutputUart.hpp                 |   4 +-
 include/output/OutputWS2811.hpp               |   6 +-
 include/output/OutputWS2811I2S.hpp            |  94 ++++++
 include/output/OutputWS2811Rmt.hpp            |   4 +-
 include/output/OutputWS2811Uart.hpp           |   7 +-
 .../GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp      |  20 +-
 platformio.ini                                |  11 +
 src/output/OutputGECERmt.cpp                  |   4 +-
 src/output/OutputGECEUart.cpp                 |   4 +-
 src/output/OutputGS8208Rmt.cpp                |   4 +-
 src/output/OutputGS8208Uart.cpp               |   4 +-
 src/output/OutputI2S.cpp                      | 284 ++++++++++------
 src/output/OutputMgr.cpp                      |  53 ++-
 src/output/OutputRmtV4.cpp                    |   4 +-
 src/output/OutputRmtV5.cpp                    |   4 +-
 src/output/OutputSerialRmt.cpp                |   4 +-
 src/output/OutputSerialUart.cpp               |   4 +-
 src/output/OutputTLS3001Rmt.cpp               |   4 +-
 src/output/OutputTM1814Rmt.cpp                |   4 +-
 src/output/OutputTM1814Uart.cpp               |   4 +-
 src/output/OutputUCS1903Rmt.cpp               |   4 +-
 src/output/OutputUCS1903Uart.cpp              |   4 +-
 src/output/OutputUCS8903Rmt.cpp               |   4 +-
 src/output/OutputUCS8903Uart.cpp              |   4 +-
 src/output/OutputUart.cpp                     |   6 +-
 src/output/OutputWS2811I2S.cpp                | 309 ++++++++++++++++++
 src/output/OutputWS2811Rmt.cpp                |   4 +-
 src/output/OutputWS2811Uart.cpp               |   4 +-
 45 files changed, 744 insertions(+), 260 deletions(-)
 create mode 100644 include/output/OutputWS2811I2S.hpp
 create mode 100644 src/output/OutputWS2811I2S.cpp

diff --git a/.vscode/extensions.json b/.vscode/extensions.json
index 0678aa058..888520c01 100644
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,7 +1,7 @@
 {
-    // See http://go.microsoft.com/fwlink/?LinkId=827846
-    // for the documentation about the extensions.json format
     "recommendations": [
+        "Jason2866.esp-decoder",
+        "pioarduino.pioarduino-ide",
         "platformio.platformio-ide"
     ],
     "unwantedRecommendations": [
diff --git a/include/output/OutputGECERmt.hpp b/include/output/OutputGECERmt.hpp
index 9f08a38f5..927b6767b 100644
--- a/include/output/OutputGECERmt.hpp
+++ b/include/output/OutputGECERmt.hpp
@@ -22,7 +22,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_GECE) && defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_GECE) && defined(SUPPORT_RMT)
 
 #include "OutputGECE.hpp"
 #include "OutputRmt.hpp"
@@ -90,4 +90,4 @@ class c_OutputGECERmt : public c_OutputGECE
 
 }; // c_OutputGECERmt
 
-#endif // defined(SUPPORT_OutputProtocol_GECE) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_GECE) && defined(SUPPORT_RMT)
diff --git a/include/output/OutputGECEUart.hpp b/include/output/OutputGECEUart.hpp
index fec012f21..9e1276322 100644
--- a/include/output/OutputGECEUart.hpp
+++ b/include/output/OutputGECEUart.hpp
@@ -23,7 +23,7 @@
 */
 
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_GECE)
+#if defined(SUPPORT_OutputProtocol_GECE) && defined(SUPPORT_UART)
 
 #include "OutputGECE.hpp"
 #include "OutputUart.hpp"
@@ -39,9 +39,6 @@ class c_OutputGECEUart : public c_OutputGECE
     // functions to be provided by the derived class
     void    Begin ();                                         ///< set up the operating environment based on the current config (or defaults)
     uint32_t Poll ();                                        ///< Call from loop(),  renders output data
-#if defined(ARDUINO_ARCH_ESP32)
-    bool     RmtPoll () {return false;}
-#endif // defined(ARDUINO_ARCH_ESP32)
     void    PauseOutput (bool State);
     bool    SetConfig (ArduinoJson::JsonObject& jsonConfig);
     void    GetConfig (ArduinoJson::JsonObject& jsonConfig);
@@ -65,4 +62,4 @@ class c_OutputGECEUart : public c_OutputGECE
 
 }; // c_OutputGECEUart
 
-#endif // defined(SUPPORT_OutputProtocol_GECE)
+#endif // defined(SUPPORT_OutputProtocol_GECE) && defined(SUPPORT_UART)
diff --git a/include/output/OutputGS8208Rmt.hpp b/include/output/OutputGS8208Rmt.hpp
index 4129a207e..e897ef64b 100644
--- a/include/output/OutputGS8208Rmt.hpp
+++ b/include/output/OutputGS8208Rmt.hpp
@@ -23,7 +23,7 @@
 */
 #include "ESPixelStick.h"
 
-#if defined(SUPPORT_OutputProtocol_GS8208) && defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_GS8208) && defined(SUPPORT_RMT)
 
 #include "OutputGS8208.hpp"
 #include "OutputRmt.hpp"
@@ -87,4 +87,4 @@ class c_OutputGS8208Rmt : public c_OutputGS8208
 
 }; // c_OutputGS8208Rmt
 
-#endif // defined(SUPPORT_OutputProtocol_GS8208) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_GS8208) && defined(SUPPORT_RMT)
diff --git a/include/output/OutputGS8208Uart.hpp b/include/output/OutputGS8208Uart.hpp
index 5315bada9..757e304fe 100644
--- a/include/output/OutputGS8208Uart.hpp
+++ b/include/output/OutputGS8208Uart.hpp
@@ -24,7 +24,7 @@
 
 #include "OutputCommon.hpp"
 
-#if defined(SUPPORT_OutputProtocol_GS8208)
+#if defined(SUPPORT_OutputProtocol_GS8208) && defined(SUPPORT_UART)
 
 #include "OutputGS8208.hpp"
 #include "OutputUart.hpp"
@@ -40,9 +40,6 @@ class c_OutputGS8208Uart : public c_OutputGS8208
     // functions to be provided by the derived class
     void    Begin ();                                         ///< set up the operating environment based on the current config (or defaults)
     uint32_t Poll ();                                        ///< Call from loop(),  renders output data
-#if defined(ARDUINO_ARCH_ESP32)
-    bool     RmtPoll () {return false;}
-#endif // defined(ARDUINO_ARCH_ESP32)
     void    PauseOutput (bool State);
     bool    SetConfig (ArduinoJson::JsonObject& jsonConfig);
     void    GetConfig (ArduinoJson::JsonObject& jsonConfig);
@@ -55,4 +52,4 @@ class c_OutputGS8208Uart : public c_OutputGS8208
 
 }; // c_OutputGS8208Uart
 
-#endif // defined(SUPPORT_OutputProtocol_GS8208)
+#endif // defined(SUPPORT_OutputProtocol_GS8208) && defined(SUPPORT_UART)
diff --git a/include/output/OutputI2S.hpp b/include/output/OutputI2S.hpp
index bb6d715b2..e27eb2bd5 100644
--- a/include/output/OutputI2S.hpp
+++ b/include/output/OutputI2S.hpp
@@ -18,14 +18,14 @@
 *
 */
 
-#ifdef ARDUINO_ARCH_ESP32
+#ifdef SUPPORT_I2S
 #include "ESPixelStick.h"
-#include "OutputCommon.hpp"
 #include "m_i2s.h"
 #include "driver/gpio.h"
 
 // a slot is one bit in the output item
-#define I2S_NUM_SLOTA           i2s_bits_per_chan_t::I2S_BITS_PER_CHAN_16BIT
+#define I2S_NUM_SLOTA i2s_bits_per_chan_t::I2S_BITS_PER_CHAN_8BIT
+#define I2S_MAX_NUM_PORTS 8
 union I2S_item_t
 {
     struct
@@ -39,25 +39,22 @@ union I2S_item_t
 class c_OutputI2S
 {
 public:
-    struct OutputI2SSlotConfig_t
-    {
-        uint32_t            I2SChannelId                = uint32_t(-1);
-        gpio_num_t          DataPin                     = gpio_num_t(-1);
-        void                *arg                        = nullptr;
-        bool                (*ISR_GetNextIntensityBit)  (void*arg, I2S_item_t&data, uint32_t &numSlices) = nullptr;
-    };
+struct OutputI2SChannelConfig_t
+{
+    uint32_t    I2SChannelId;
+    gpio_num_t  DataPin;
+    void        *arg;
+    bool        (*GetNextIntensityBit) (void*arg, I2S_item_t * data, uint32_t numSlices) = nullptr;
+    bool        IsActive;
+};
 
 private:
 
-    // list of GPIOs for the I2S slots 24 is the 
-    // max # slots and must be present no matter how many 
-    // slots are actually used
-    gpio_num_t GpioDataPins[24];
-    const int clock_pin = I2S_PIN_NO_CHANGE; // Pixel Clock
-
-    OutputI2SSlotConfig_t   OutputI2SSlotConfigs[I2S_NUM_SLOTA];
+    const int   clock_pin = I2S_PIN_NO_CHANGE; // Pixel Clock
+    bool        OutputIsPaused = false;
+    double      I2S_TickTimeInNS;
 
-    bool                OutputIsPaused = false;
+    #define I2STargetBitSliceTimeNS 150
 
     uint32_t SetBitSliceLen (uint8_t ChanId, double BitSliceLenNs);
     void StartSendingData   ();
@@ -74,13 +71,15 @@ class c_OutputI2S
     c_OutputI2S ();
     virtual ~c_OutputI2S ();
 
-    void Begin              ();
-    void RegisterSlotDevice (OutputI2SSlotConfig_t config, c_OutputCommon * pParent);
-    void RemoveSlotDevice   (OutputI2SSlotConfig_t config);
-    void GetStatus          (ArduinoJson::JsonObject& jsonStatus);
-    void PauseOutput        (bool State);
-    void GetDriverName      (String &value)  { value = F("I2S"); }
-    void ISR_ProcessDma     ();
+    void        Begin               ();
+    uint8_t     RegisterSlotDevice  (OutputI2SChannelConfig_t config);
+    void        RemoveSlotDevice    (OutputI2SChannelConfig_t config);
+    void        GetStatus           (ArduinoJson::JsonObject& jsonStatus);
+    void        PauseOutput         (bool State);
+    void        GetDriverName       (String &value)  { value = F("I2S"); }
+    uint32_t    GetBitTimeSlices    (uint32_t BitTimeInNanoSec);
+    void        SetOutputState      (uint32_t I2SChannelId, bool NewState);
+    void        SetGpio             (uint32_t I2SChannelId, gpio_num_t NewGpio);
 
 // #define USE_I2S_DEBUG_COUNTERS
 #ifdef USE_I2S_DEBUG_COUNTERS
@@ -109,4 +108,4 @@ class c_OutputI2S
 #endif // def USE_I2S_DEBUG_COUNTERS
 
 };
-#endif // def #ifdef ARDUINO_ARCH_ESP32
\ No newline at end of file
+#endif // def #ifdef SUPPORT_I2S
\ No newline at end of file
diff --git a/include/output/OutputMgr.hpp b/include/output/OutputMgr.hpp
index d06ca20bb..737201bf9 100644
--- a/include/output/OutputMgr.hpp
+++ b/include/output/OutputMgr.hpp
@@ -28,6 +28,10 @@
 #include "FileMgr.hpp"
 #include <TimeLib.h>
 
+#ifdef SUPPORT_I2S
+    #include "output/OutputI2S.hpp"
+#endif // def SUPPORT_I2S
+
 class c_OutputCommon; ///< forward declaration to the pure virtual output class that will be defined later.
 
 #ifdef UART_LAST
@@ -44,6 +48,9 @@ class c_OutputMgr
     #else // ARDUINO_ARCH_ESP32
     #define OM_MAX_NUM_CHANNELS  (3000 * 3)
     #endif // !def ARDUINO_ARCH_ESP32
+#ifdef SUPPORT_I2S
+    c_OutputI2S OutputI2S;
+#endif // def SUPPORT_I2S
 
 public:
     c_OutputMgr ();
@@ -71,8 +78,11 @@ class c_OutputMgr
     void      RelayUpdate       (uint8_t RelayId, String & NewValue, String & Response);
     void      ClearStatistics   (void);
     uint8_t   GetNumPorts       () {return NumOutputPorts;}
+#ifdef SUPPORT_I2S
+    void *    GetI2sDriver      () {return &OutputI2S;}
+#endif // def SUPPORT_I2S
 
-    // do NOT insert into the middle of this list. Always add new types to the end of the list
+// do NOT insert into the middle of this list. Always add new types to the end of the list
     enum e_OutputProtocolType
     {
         OutputProtocol_Disabled = 0,
diff --git a/include/output/OutputRmt.hpp b/include/output/OutputRmt.hpp
index d55c686b7..4075ddca0 100644
--- a/include/output/OutputRmt.hpp
+++ b/include/output/OutputRmt.hpp
@@ -19,7 +19,7 @@
 */
 
 #include "ESPixelStick.h"
-#ifdef ARDUINO_ARCH_ESP32
+#ifdef SUPPORT_RMT
 #include "OutputPixel.hpp"
 #include "OutputSerial.hpp"
 
@@ -214,4 +214,4 @@ inline void WriteToBuffer(rmt_item32_t value)
 } // WriteToBuffer
 
 };
-#endif // def #ifdef ARDUINO_ARCH_ESP32
\ No newline at end of file
+#endif // def #ifdef SUPPORT_RMT
\ No newline at end of file
diff --git a/include/output/OutputSerialRmt.hpp b/include/output/OutputSerialRmt.hpp
index 954768a69..768a4684f 100644
--- a/include/output/OutputSerialRmt.hpp
+++ b/include/output/OutputSerialRmt.hpp
@@ -22,7 +22,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if (defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(ARDUINO_ARCH_ESP32)
+#if (defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(SUPPORT_RMT)
 
 #include "OutputSerial.hpp"
 #include "OutputRmt.hpp"
@@ -85,4 +85,4 @@ class c_OutputSerialRmt : public c_OutputSerial
 
 }; // c_OutputSerialRmt
 
-#endif // defined(SUPPORT_OutputProtocol_FireGod) || (defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_FireGod) || (defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(SUPPORT_RMT)
diff --git a/include/output/OutputSerialUart.hpp b/include/output/OutputSerialUart.hpp
index ac8bd9edc..62af1fcea 100644
--- a/include/output/OutputSerialUart.hpp
+++ b/include/output/OutputSerialUart.hpp
@@ -23,7 +23,7 @@ GNU General Public License for more details.
 */
 #include "ESPixelStick.h"
 
-#if defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)
+#if (defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(SUPPORT_UART)
 
 #include "OutputSerial.hpp"
 #include "OutputUart.hpp"
@@ -42,9 +42,6 @@ class c_OutputSerialUart : public c_OutputSerial
     virtual void    GetConfig(ArduinoJson::JsonObject &jsonConfig); ///< Set a new config in the driver
     virtual void    GetStatus(ArduinoJson::JsonObject &jsonStatus);
     uint32_t        Poll();
-#if defined(ARDUINO_ARCH_ESP32)
-    bool            RmtPoll () {return false;}
-#endif // defined(ARDUINO_ARCH_ESP32)
     void            PauseOutput (bool NewState);
 
 private:
@@ -52,4 +49,4 @@ class c_OutputSerialUart : public c_OutputSerial
 
 }; // c_OutputSerialUart
 
-#endif // defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)
+#endif // defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard) && defined(SUPPORT_UART)
diff --git a/include/output/OutputTLS3001Rmt.hpp b/include/output/OutputTLS3001Rmt.hpp
index c35987d76..75891c6e0 100644
--- a/include/output/OutputTLS3001Rmt.hpp
+++ b/include/output/OutputTLS3001Rmt.hpp
@@ -22,7 +22,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_TLS3001) && defined (ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_TLS3001) && defined (SUPPORT_RMT)
 
 #include "OutputTLS3001.hpp"
 #include "OutputRmt.hpp"
@@ -117,4 +117,4 @@ class c_OutputTLS3001Rmt : public c_OutputTLS3001
 
 }; // c_OutputTLS3001Rmt
 
-#endif // defined(SUPPORT_OutputProtocol_TLS3001) && defined (ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_TLS3001) && defined (SUPPORT_RMT)
diff --git a/include/output/OutputTLS3001RmtFsm.hpp b/include/output/OutputTLS3001RmtFsm.hpp
index d1dd4e54c..fc60af808 100644
--- a/include/output/OutputTLS3001RmtFsm.hpp
+++ b/include/output/OutputTLS3001RmtFsm.hpp
@@ -22,7 +22,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_TLS3001) && defined (ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_TLS3001) && defined (SUPPORT_RMT)
 
 // forward declaration
 class c_OutputTLS3001Rmt;
@@ -126,4 +126,4 @@ class fsm_RMT_state_SendDataIdle : public fsm_RMT_state
 private:
 }; // fsm_RMT_state_SendData
 
-#endif // defined(SUPPORT_OutputProtocol_TLS3001) && defined (ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_TLS3001) && defined (SUPPORT_RMT)
diff --git a/include/output/OutputTM1814Rmt.hpp b/include/output/OutputTM1814Rmt.hpp
index 06e8ec9f9..eeac6b5d7 100644
--- a/include/output/OutputTM1814Rmt.hpp
+++ b/include/output/OutputTM1814Rmt.hpp
@@ -22,7 +22,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined (SUPPORT_OutputProtocol_TM1814) && defined (ARDUINO_ARCH_ESP32)
+#if defined (SUPPORT_OutputProtocol_TM1814) && defined (SUPPORT_RMT)
 
 #include "OutputTM1814.hpp"
 #include "OutputRmt.hpp"
@@ -86,4 +86,4 @@ class c_OutputTM1814Rmt : public c_OutputTM1814
 
 }; // c_OutputTM1814Rmt
 
-#endif // defined (SUPPORT_OutputProtocol_TM1814) && defined (ARDUINO_ARCH_ESP32)
+#endif // defined (SUPPORT_OutputProtocol_TM1814) && defined (SUPPORT_RMT)
diff --git a/include/output/OutputTM1814Uart.hpp b/include/output/OutputTM1814Uart.hpp
index a1d8b2354..2dd7cecf1 100644
--- a/include/output/OutputTM1814Uart.hpp
+++ b/include/output/OutputTM1814Uart.hpp
@@ -23,7 +23,7 @@
 */
 
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_TM1814)
+#if defined(SUPPORT_OutputProtocol_TM1814) && defined(SUPPORT_UART)
 
 #include "OutputTM1814.hpp"
 #include "OutputUart.hpp"
@@ -40,9 +40,6 @@ class c_OutputTM1814Uart : public c_OutputTM1814
     // functions to be provided by the derived class
     void    Begin ();                                         ///< set up the operating environment based on the current config (or defaults)
     uint32_t Poll ();                                        ///< Call from loop(),  renders output data
-#if defined(ARDUINO_ARCH_ESP32)
-    bool     RmtPoll () {return false;}
-#endif // defined(ARDUINO_ARCH_ESP32)
     void    PauseOutput (bool State);
     bool    SetConfig (ArduinoJson::JsonObject& jsonConfig);
     void    GetConfig (ArduinoJson::JsonObject& jsonConfig);
@@ -59,4 +56,4 @@ class c_OutputTM1814Uart : public c_OutputTM1814
 
 }; // c_OutputTM1814Uart
 
-#endif // defined(SUPPORT_OutputProtocol_TM1814)
+#endif // defined(SUPPORT_OutputProtocol_TM1814) && defined(SUPPORT_UART)
diff --git a/include/output/OutputUCS1903Rmt.hpp b/include/output/OutputUCS1903Rmt.hpp
index d5e55cb98..a7bdcda76 100644
--- a/include/output/OutputUCS1903Rmt.hpp
+++ b/include/output/OutputUCS1903Rmt.hpp
@@ -23,7 +23,7 @@
 */
 #include "ESPixelStick.h"
 
-#if defined(SUPPORT_OutputProtocol_UCS1903) && defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_UCS1903) && defined(SUPPORT_RMT)
 
 #include "OutputUCS1903.hpp"
 #include "OutputRmt.hpp"
@@ -89,4 +89,4 @@ class c_OutputUCS1903Rmt : public c_OutputUCS1903
 
 }; // c_OutputUCS1903Rmt
 
-#endif // defined(SUPPORT_OutputProtocol_UCS1903) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_UCS1903) && defined(SUPPORT_RMT)
diff --git a/include/output/OutputUCS8903Rmt.hpp b/include/output/OutputUCS8903Rmt.hpp
index 484c53498..8cbededb3 100644
--- a/include/output/OutputUCS8903Rmt.hpp
+++ b/include/output/OutputUCS8903Rmt.hpp
@@ -23,7 +23,7 @@
 */
 #include "ESPixelStick.h"
 #ifdef SUPPORT_OutputProtocol_UCS8903
-#ifdef ARDUINO_ARCH_ESP32
+#ifdef SUPPORT_RMT
 
 #include "OutputUCS8903.hpp"
 #include "OutputRmt.hpp"
@@ -86,5 +86,5 @@ class c_OutputUCS8903Rmt : public c_OutputUCS8903
 
 }; // c_OutputUCS8903Rmt
 
-#endif // def ARDUINO_ARCH_ESP32
+#endif // def SUPPORT_RMT
 #endif // def SUPPORT_OutputProtocol_UCS8903
diff --git a/include/output/OutputUCS8903Uart.hpp b/include/output/OutputUCS8903Uart.hpp
index f945bab70..c1bbab8af 100644
--- a/include/output/OutputUCS8903Uart.hpp
+++ b/include/output/OutputUCS8903Uart.hpp
@@ -24,7 +24,7 @@
 
 #include "OutputCommon.hpp"
 
-#if defined(SUPPORT_OutputProtocol_UCS8903)
+#if defined(SUPPORT_OutputProtocol_UCS8903) && defined(SUPPORT_UART)
 
 #include "OutputUCS8903.hpp"
 #include "OutputUart.hpp"
@@ -40,9 +40,6 @@ class c_OutputUCS8903Uart : public c_OutputUCS8903
     // functions to be provided by the derived class
     void    Begin ();
     uint32_t Poll ();
-#if defined(ARDUINO_ARCH_ESP32)
-    bool     RmtPoll () {return false;}
-#endif // defined(ARDUINO_ARCH_ESP32)
     void    PauseOutput (bool State);
     bool    SetConfig (ArduinoJson::JsonObject& jsonConfig);
     void    GetConfig (ArduinoJson::JsonObject& jsonConfig);
@@ -58,4 +55,4 @@ class c_OutputUCS8903Uart : public c_OutputUCS8903
 
 }; // c_OutputUCS8903Uart
 
-#endif // defined(SUPPORT_OutputProtocol_UCS8903)
+#endif // defined(SUPPORT_OutputProtocol_UCS8903) && defined(SUPPORT_UART)
diff --git a/include/output/OutputUart.hpp b/include/output/OutputUart.hpp
index f2d69db4f..6a3142b53 100644
--- a/include/output/OutputUart.hpp
+++ b/include/output/OutputUart.hpp
@@ -19,8 +19,9 @@
  */
 
 #include "ESPixelStick.h"
+#if defined(SUPPORT_UART)
 
-#ifdef ARDUINO_ARCH_ESP32
+#if defined(ARDUINO_ARCH_ESP32)
 #   include <soc/uart_reg.h>
 #   include <driver/uart.h>
 #   include <driver/gpio.h>
@@ -223,3 +224,4 @@ class c_OutputUart
 
 #endif // defined(ARDUINO_ARCH_ESP8266)
 };
+#endif // defined(SUPPORT_UART)
diff --git a/include/output/OutputWS2811.hpp b/include/output/OutputWS2811.hpp
index 1abb46898..d067fecb3 100644
--- a/include/output/OutputWS2811.hpp
+++ b/include/output/OutputWS2811.hpp
@@ -55,9 +55,9 @@ class c_OutputWS2811 : public c_OutputPixel
 //    #define WS2811_PIXEL_NS_BIT_1_HIGH      975.0 // = 937 on logic analyzer 580ns - 1.6us per datasheet
 //    #define WS2811_PIXEL_NS_BIT_1_LOW       300.0 // = 312 on logic analyzer 220ns - 380ns per datasheet
     #define WS2811_PIXEL_NS_BIT_0_HIGH      300.0 // 220ns - 380ns per datasheet
-    #define WS2811_PIXEL_NS_BIT_0_LOW       (WS2811_PIXEL_NS_BIT_TOTAL - WS2811_PIXEL_NS_BIT_0_HIGH)
-    #define WS2811_PIXEL_NS_BIT_1_HIGH      WS2811_PIXEL_NS_BIT_0_LOW
-    #define WS2811_PIXEL_NS_BIT_1_LOW       WS2811_PIXEL_NS_BIT_0_HIGH
+    #define WS2811_PIXEL_NS_BIT_0_LOW       900.0
+    #define WS2811_PIXEL_NS_BIT_1_HIGH      700.0
+    #define WS2811_PIXEL_NS_BIT_1_LOW       600.0
 #else
     #define WS2811_PIXEL_NS_BIT_0_HIGH      312.0 // 220ns - 380ns per datasheet
     #define WS2811_PIXEL_NS_BIT_0_LOW       (WS2811_PIXEL_NS_BIT_TOTAL - WS2811_PIXEL_NS_BIT_0_HIGH)
diff --git a/include/output/OutputWS2811I2S.hpp b/include/output/OutputWS2811I2S.hpp
new file mode 100644
index 000000000..9813a5b07
--- /dev/null
+++ b/include/output/OutputWS2811I2S.hpp
@@ -0,0 +1,94 @@
+#pragma once
+/*
+* OutputWS2811I2S.h - WS2811 driver code for ESPixelStick I2S Channel
+*
+* Project: ESPixelStick - An ESP8266 / ESP32 and E1.31 based pixel driver
+* Copyright (c) 2015, 2025 Shelby Merrick
+* http://www.forkineye.com
+*
+*  This program is provided free for you to use in any way that you wish,
+*  subject to the laws and regulations where you are using it.  Due diligence
+*  is strongly suggested before using this code.  Please give credit where due.
+*
+*  The Author makes no warranty of any kind, express or implied, with regard
+*  to this program or the documentation contained in this document.  The
+*  Author shall not be liable in any event for incidental or consequential
+*  damages in connection with, or arising out of, the furnishing, performance
+*  or use of these programs.
+*
+*   This is a derived class that converts data in the output buffer into
+*   pixel intensities and then transmits them through the configured serial
+*   interface.
+*
+*/
+#include "ESPixelStick.h"
+#if defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_I2S)
+
+#include "OutputWS2811.hpp"
+#include "OutputI2S.hpp"
+
+class c_OutputWS2811I2S : public c_OutputWS2811
+{
+public:
+    // These functions are inherited from c_OutputCommon
+    c_OutputWS2811I2S (OM_OutputPortDefinition_t & OutputPortDefinition,
+                       c_OutputMgr::e_OutputProtocolType outputType);
+    virtual ~c_OutputWS2811I2S ();
+
+    // functions to be provided by the derived class
+    void    Begin ();                                        ///< set up the operating environment based on the current config (or defaults)
+    bool    SetConfig (ArduinoJson::JsonObject& jsonConfig); ///< Set a new config in the driver
+    uint32_t Poll ();                                        ///< Call from loop (),  renders output data
+    void    GetStatus (ArduinoJson::JsonObject& jsonStatus);
+    void    SetOutputBufferSize (uint32_t NumChannelsAvailable);
+    void    PauseOutput(bool State);
+    bool    GetNextBitToSend (I2S_item_t * DataToSend, uint32_t numSlices);
+    void    StartNewDataFrame();
+
+    // to be removed when the I2S driver is fully implemented
+    virtual bool RmtPoll() {return false;}
+
+private:
+
+    // The adjustments compensate for rounding errors in the calculations
+    c_OutputI2S     *I2Sdriver;
+
+    uint8_t         DataBitMask;
+    uint8_t         DataBit;
+
+    uint32_t        ZeroHighBitCount;
+    uint32_t        ZeroLowBitCount;
+
+    uint32_t        OneHighBitCount;
+    uint32_t        OneLowBitCount;
+
+    uint32_t        HighBitCurrentCount;
+    uint32_t        LowBitCurrentCount;
+
+    uint32_t        IfgBitCount;
+    uint32_t        IfgBitCurrentCount;
+
+    uint32_t        DataPattern;
+    uint32_t        DataPatternMask;
+
+    #define WS2811_I2S_DEBUG_COUNTERS
+    #ifdef WS2811_I2S_DEBUG_COUNTERS
+    #define INC_WS2811_I2S_DEBUG_COUNTERS(c) (++I2SDebugCounters.c)
+    struct
+    {
+        uint32_t GetNextBit;
+        uint32_t FrameStarts;
+        uint32_t FrameEnds;
+        uint32_t IfgBits;
+        uint32_t DataBits;
+        uint32_t DataBytes;
+        uint32_t BitHigh;
+        uint32_t BitLow;
+    } I2SDebugCounters;
+    #else
+    #define INC_WS2811_I2S_DEBUG_COUNTERS(c)
+    #endif // def WS2811_I2S_DEBUG_COUNTERS
+
+}; // c_OutputWS2811I2S
+
+#endif // defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_I2S)
diff --git a/include/output/OutputWS2811Rmt.hpp b/include/output/OutputWS2811Rmt.hpp
index ee73bb67a..ce85c2a95 100644
--- a/include/output/OutputWS2811Rmt.hpp
+++ b/include/output/OutputWS2811Rmt.hpp
@@ -22,7 +22,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_WS2811) && defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_RMT)
 
 #include "OutputWS2811.hpp"
 #include "OutputRmt.hpp"
@@ -88,4 +88,4 @@ class c_OutputWS2811Rmt : public c_OutputWS2811
 
 }; // c_OutputWS2811Rmt
 
-#endif // defined(SUPPORT_OutputProtocol_WS2811) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_RMT)
diff --git a/include/output/OutputWS2811Uart.hpp b/include/output/OutputWS2811Uart.hpp
index c87158a58..9c6562f41 100644
--- a/include/output/OutputWS2811Uart.hpp
+++ b/include/output/OutputWS2811Uart.hpp
@@ -23,7 +23,7 @@
 */
 
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_WS2811)
+#if defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_UART)
 
 #include "OutputWS2811.hpp"
 #include "OutputUart.hpp"
@@ -39,9 +39,6 @@ class c_OutputWS2811Uart : public c_OutputWS2811
     // functions to be provided by the derived class
     void    Begin ();                                         ///< set up the operating environment based on the current config (or defaults)
     uint32_t Poll ();
-#if defined(ARDUINO_ARCH_ESP32)
-    bool     RmtPoll () {return false;}
-#endif // defined(ARDUINO_ARCH_ESP32)
     void    PauseOutput (bool State);
     bool    SetConfig (ArduinoJson::JsonObject& jsonConfig);
     void    GetConfig (ArduinoJson::JsonObject& jsonConfig);
@@ -59,4 +56,4 @@ class c_OutputWS2811Uart : public c_OutputWS2811
 
 }; // c_OutputWS2811Uart
 
-#endif // defined(SUPPORT_OutputProtocol_WS2811)
+#endif // defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_UART)
diff --git a/include/platforms/GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp b/include/platforms/GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp
index d503abe7c..949095ec2 100644
--- a/include/platforms/GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp
+++ b/include/platforms/GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp
@@ -75,19 +75,19 @@ const OM_OutputPortDefinition_t OM_OutputPortDefinitions[] =
 #define DEFAULT_ETH_MDIO_PIN    gpio_num_t::GPIO_NUM_18
 
 // Output Types
-#define SUPPORT_OutputProtocol_TLS3001          // OM_SERIAL
-#define SUPPORT_OutputProtocol_APA102           // OM_SPI
+// #define SUPPORT_OutputProtocol_TLS3001          // OM_SERIAL
+// #define SUPPORT_OutputProtocol_APA102           // OM_SPI
 // #define SUPPORT_OutputProtocol_DMX              // OM_SERIAL
-#define SUPPORT_OutputProtocol_GECE             // OM_SERIAL
-#define SUPPORT_OutputProtocol_GS8208           // OM_SERIAL
+// #define SUPPORT_OutputProtocol_GECE             // OM_SERIAL
+// #define SUPPORT_OutputProtocol_GS8208           // OM_SERIAL
 // #define SUPPORT_OutputProtocol_Renard           // OM_SERIAL
 // #define SUPPORT_OutputProtocol_Serial           // OM_SERIAL
-#define SUPPORT_OutputProtocol_TM1814           // OM_SERIAL
-#define SUPPORT_OutputProtocol_UCS1903          // OM_SERIAL
-#define SUPPORT_OutputProtocol_UCS8903          // OM_SERIAL
-#define SUPPORT_OutputProtocol_WS2801           // OM_SPI
+// #define SUPPORT_OutputProtocol_TM1814           // OM_SERIAL
+// #define SUPPORT_OutputProtocol_UCS1903          // OM_SERIAL
+// #define SUPPORT_OutputProtocol_UCS8903          // OM_SERIAL
+// #define SUPPORT_OutputProtocol_WS2801           // OM_SPI
 #define SUPPORT_OutputProtocol_WS2811           // OM_SERIAL
-#define SUPPORT_OutputProtocol_Relay            // OM_RELAY
-#define SUPPORT_OutputProtocol_Servo_PCA9685    // OM_I2C
+// #define SUPPORT_OutputProtocol_Relay            // OM_RELAY
+// #define SUPPORT_OutputProtocol_Servo_PCA9685    // OM_I2C
 // #define SUPPORT_OutputProtocol_FireGod          // OM_SERIAL
 // #define SUPPORT_OutputProtocol_GRINCH           // OM_SPI
diff --git a/platformio.ini b/platformio.ini
index 62357ff64..3b646a3a0 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -102,6 +102,11 @@ build_flags =
     -D VTABLES_IN_FLASH
     -D DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP8266=2
     -D DEFAULT_STORAGE_TYPE_ESP8266=2
+    ;----------------------
+; Only one of these can be enabled at a time
+    -D SUPPORT_UART=1
+;    -D SUPPORT_I2S=1
+
 lib_ignore =
     Ethernet ; Remove once Art-Net is fixed / replaced to not depend on Ethernet in lib config
     ; ESPAsyncTCP
@@ -137,6 +142,12 @@ build_flags =
     -D CONFIG_RMT_ISR_IRAM_SAFE=yes
 ;    -D USE_RMT_DEBUG_COUNTERS=1
 ;    -D DEBUG_RMT_XLAT_ISSUES=1
+;----------------------
+; Only one of these can be enabled at a time
+;    -D SUPPORT_UART=1
+;    -D SUPPORT_I2S=1
+    -D SUPPORT_RMT=1
+    -I ./include/service
 
 build_unflags =
     ${env.build_unflags}
diff --git a/src/output/OutputGECERmt.cpp b/src/output/OutputGECERmt.cpp
index 1362afa9e..a0c6542da 100644
--- a/src/output/OutputGECERmt.cpp
+++ b/src/output/OutputGECERmt.cpp
@@ -17,7 +17,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_GECE) && defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_GECE) && defined(SUPPORT_RMT)
 
 #include "output/OutputGECERmt.hpp"
 
@@ -240,4 +240,4 @@ void c_OutputGECERmt::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_GECE) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_GECE) && defined(SUPPORT_RMT)
diff --git a/src/output/OutputGECEUart.cpp b/src/output/OutputGECEUart.cpp
index 9bf71eb24..29f76111a 100644
--- a/src/output/OutputGECEUart.cpp
+++ b/src/output/OutputGECEUart.cpp
@@ -18,7 +18,7 @@
 */
 
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_GECE)
+#if defined(SUPPORT_OutputProtocol_GECE) && defined(SUPPORT_UART)
 
 #include "output/OutputGECEUart.hpp"
 
@@ -185,4 +185,4 @@ void c_OutputGECEUart::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_GECE)
+#endif // defined(SUPPORT_OutputProtocol_GECE) && defined(SUPPORT_UART)
diff --git a/src/output/OutputGS8208Rmt.cpp b/src/output/OutputGS8208Rmt.cpp
index 67e48fb2b..e9b21d8d5 100644
--- a/src/output/OutputGS8208Rmt.cpp
+++ b/src/output/OutputGS8208Rmt.cpp
@@ -18,7 +18,7 @@
 */
 #include "ESPixelStick.h"
 
-#if defined(SUPPORT_OutputProtocol_GS8208) && defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_GS8208) && defined(SUPPORT_RMT)
 
 #include "output/OutputGS8208Rmt.hpp"
 
@@ -245,4 +245,4 @@ void c_OutputGS8208Rmt::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_GS8208) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_GS8208) && defined(SUPPORT_RMT)
diff --git a/src/output/OutputGS8208Uart.cpp b/src/output/OutputGS8208Uart.cpp
index e0557d79d..d0ad33e92 100644
--- a/src/output/OutputGS8208Uart.cpp
+++ b/src/output/OutputGS8208Uart.cpp
@@ -19,7 +19,7 @@
 
 #include "ESPixelStick.h"
 
-#if defined(SUPPORT_OutputProtocol_GS8208)
+#if defined(SUPPORT_OutputProtocol_GS8208) && defined(SUPPORT_UART)
 
 #include "output/OutputGS8208Uart.hpp"
 
@@ -186,4 +186,4 @@ void c_OutputGS8208Uart::PauseOutput(bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_GS8208)
+#endif // defined(SUPPORT_OutputProtocol_GS8208) && defined(SUPPORT_UART)
diff --git a/src/output/OutputI2S.cpp b/src/output/OutputI2S.cpp
index f4768d8cb..dc724ffa8 100644
--- a/src/output/OutputI2S.cpp
+++ b/src/output/OutputI2S.cpp
@@ -24,87 +24,68 @@
 #include "driver/gpio.h"
 #include "soc/io_mux_reg.h"
 #include "esp_rom_gpio.h"
+#include <numeric>
 
 #define I2S_DeviceID i2s_port_t::I2S_NUM_0
 #define I2S_Device I2S0
 #define I2S_DataStartSignal I2S0O_DATA_OUT8_IDX
 
-struct I2S_ListOfRegisteredChannels_t
-{
-    void * pThis;
-    void (*GetMoreDate)(void*, I2S_item_t*, uint32_t);
-    bool IsActive;
-};
-
-static I2S_ListOfRegisteredChannels_t I2S_ListOfRegisteredChannels[I2S_NUM_SLOTA];
-#define                               I2S_NumSendBufferItems 128
-static I2S_item_t                     I2S_SendBuffer[I2S_NumSendBufferItems];
+static c_OutputI2S::OutputI2SChannelConfig_t OutputI2SSlotConfigs[I2S_MAX_NUM_PORTS];
+#define                         I2S_NumSendBufferItems 512
+static I2S_item_t               I2S_SendBuffer[I2S_NumSendBufferItems];
 
-void FillBufferWithTestData(uint8_t testData)
-{
-    for (uint32_t i = 0; i < I2S_NumSendBufferItems; ++i)
-    {
-        I2S_SendBuffer[i].data = testData;
-    }
-}
 //----------------------------------------------------------------------------
 void I2S_Task(void*)
 {
     size_t bytes_written = 0;
     DEBUG_V(String("Current CPU ID: ") + String(xPortGetCoreID()));
 
-    int index = 0;
-    while(index < I2S_NumSendBufferItems)
-    {
-        I2S_SendBuffer[index++].data = 0xFE;
-        I2S_SendBuffer[index++].data = 0xFF;
-    }
     while(true)
     {
-        // test code to send data to the I2S driver
-        // DEBUG_V("Sending data to I2S driver");
-        FillBufferWithTestData(0xFF);
-        m_i2s_write(I2S_DeviceID, I2S_SendBuffer, sizeof(I2S_SendBuffer), &bytes_written, portMAX_DELAY);
-        FillBufferWithTestData(0xFE);
-        m_i2s_write(I2S_DeviceID, I2S_SendBuffer, sizeof(I2S_SendBuffer), &bytes_written, portMAX_DELAY);
-        // DEBUG_V(String("Bytes written: ") + String(bytes_written) + " bytes");
-
+        bool FoundActiveChannel = false;
         // DEBUG_V("Processing all possible channels");
-        for (I2S_ListOfRegisteredChannels_t & CurrentChannel : I2S_ListOfRegisteredChannels)
+        for (auto & CurrentChannel : OutputI2SSlotConfigs)
         {
             // DEBUG_V(String("Processing channel: 0x") + String(uint32_t(CurrentChannel.pThis), HEX));
             // do we have a driver on this channel?
             if(true == CurrentChannel.IsActive)
             {
-                DEBUG_V(String("Getting more data for channel: 0x") + String(uint32_t(CurrentChannel.pThis), HEX));
-                // digitalWrite(17, LOW);
+                FoundActiveChannel = true;
+
+                // DEBUG_V(String("Getting more data for channel: 0x") + String(uint32_t(CurrentChannel.arg), HEX));
 
                 // invoke the channel
-                CurrentChannel.GetMoreDate(CurrentChannel.pThis, I2S_SendBuffer, I2S_NumSendBufferItems);
-                // send the data to the I2S driver
-                size_t bytes_written = 0;
-                m_i2s_write(I2S_DeviceID, &I2S_SendBuffer, I2S_NumSendBufferItems, &bytes_written, portMAX_DELAY);
-                DEBUG_V(String("Bytes written: ") + String(bytes_written) + " bytes");
+                CurrentChannel.GetNextIntensityBit(CurrentChannel.arg, I2S_SendBuffer, I2S_NumSendBufferItems);
             }
         }
+
+        if(FoundActiveChannel)
+        {
+            // send the data to the I2S driver
+            size_t bytes_written = 0;
+            m_i2s_write(I2S_DeviceID, I2S_SendBuffer, sizeof(I2S_SendBuffer), &bytes_written, portMAX_DELAY);
+            // DEBUG_V(String("Bytes written: ") + String(bytes_written) + " bytes");
+        }
+        else
+        {
+            // DEBUG_V("No active channels, pausing task");
+            vTaskDelay(2000 / portTICK_PERIOD_MS);
+        }
     }
-}
+} // I2S_Task
 
 //----------------------------------------------------------------------------
 c_OutputI2S::c_OutputI2S()
 {
     // DEBUG_START;
 
-    for(auto &CurrGpio : GpioDataPins)
-    {
-        // DEBUG_V(String("Configuring GPIO: ") + String(CurrGpio));
-        CurrGpio = gpio_num_t(-1);
-    }
-
-    for (I2S_ListOfRegisteredChannels_t & CurrentChannel : I2S_ListOfRegisteredChannels)
+    int id = 0;
+    for (auto & CurrentChannel : OutputI2SSlotConfigs)
     {
-        CurrentChannel.pThis = nullptr;
-        CurrentChannel.GetMoreDate = nullptr;
+        CurrentChannel.I2SChannelId = id++;
+        CurrentChannel.DataPin = gpio_num_t(I2S_PIN_NO_CHANGE);
+        CurrentChannel.arg = nullptr;
+        CurrentChannel.GetNextIntensityBit = nullptr;
         CurrentChannel.IsActive = false;
     }
 
@@ -124,6 +105,18 @@ c_OutputI2S::~c_OutputI2S ()
     // DEBUG_END;
 } // ~c_OutputI2S
 
+//----------------------------------------------------------------------------
+static uint32_t gcd(uint32_t a, uint32_t b)
+{
+    while (b != 0)
+    {
+        uint32_t temp = b;
+        b = a % b;
+        a = temp;
+    }
+  return a;
+}
+
 //----------------------------------------------------------------------------
 void c_OutputI2S::InitI2Sdriver ()
 {
@@ -136,7 +129,7 @@ void c_OutputI2S::InitI2Sdriver ()
             i2s_config.channel_format = i2s_channel_fmt_t::I2S_CHANNEL_FMT_RIGHT_LEFT;
             i2s_config.communication_format = i2s_comm_format_t::I2S_COMM_FORMAT_STAND_I2S;
             i2s_config.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
-            i2s_config.dma_buf_count = 4;
+            i2s_config.dma_buf_count = 2;
             i2s_config.dma_buf_len = sizeof(I2S_SendBuffer);
             i2s_config.use_apll = false;
             i2s_config.fixed_mclk = 0;
@@ -166,64 +159,66 @@ void c_OutputI2S::InitI2Sdriver ()
         }
 
         // DEBUG_V("Set i2s mode to LCD mode");
-        // I2S_Device.conf2.val = 0;
         I2S_Device.conf2.lcd_en = true;
-//        I2S_Device.conf2.data_enable = false;
         I2S_Device.conf2.camera_en = false;
-//        I2S_Device.conf2.lcd_tx_sdx2_en = true;
-//        I2S_Device.conf2.lcd_tx_wrx2_en = true;
 
+        double ClockFrequency = 80000000.0;
+        double TargetTickNS = I2STargetBitSliceTimeNS;
+        double ClkNS = (1.0 / ClockFrequency) * 1000000000;
+        double ClkDiv = TargetTickNS / ClkNS;
+        double integralPart;
+        double fractionalPart = std::modf(ClkDiv, &integralPart);
+        fractionalPart = std::abs(fractionalPart);
+        double denominator = std::pow(10,9);
+        double numerator = std::round(fractionalPart * denominator);
+        double commonDivisor = gcd(numerator, denominator);
+        numerator = numerator / commonDivisor;
+        denominator = denominator / commonDivisor;
+        I2S_TickTimeInNS = TargetTickNS;
+
+        if(int(denominator) == 0 || int(numerator) == 0)
+        {
+            denominator = 0.0;
+            numerator = 0.0;
+        }
         // Setup i2s clock
-        // I2S_Device.sample_rate_conf.val = 0;
-        // I2S_Device.sample_rate_conf.rx_bits_mod = i2s_bits_per_chan_t::I2S_NUM_SLOTA;
-//        I2S_Device.sample_rate_conf.tx_bits_mod = i2s_bits_per_chan_t::I2S_NUM_SLOTA;
-        // I2S_Device.sample_rate_conf.rx_bck_div_num = 1;
-        I2S_Device.sample_rate_conf.tx_bck_div_num = 1;
-
-        // I2S_Device.clkm_conf.val = 0;
         I2S_Device.clkm_conf.clka_en = false;
         I2S_Device.clkm_conf.clk_en = false; // Use PLL_D2_CLK (160MHz)
-        I2S_Device.clkm_conf.clkm_div_num = 24; // 160MH / 800kh / 3 slots per bit
-        I2S_Device.clkm_conf.clkm_div_a = 8; // Adjust based on source
-        I2S_Device.clkm_conf.clkm_div_b = 7; // Adjust based on source
+        I2S_Device.clkm_conf.clkm_div_num = int(ClkDiv);
+        I2S_Device.clkm_conf.clkm_div_a = int(denominator);
+        I2S_Device.clkm_conf.clkm_div_b = int(numerator);
         I2S_Device.sample_rate_conf.tx_bck_div_num = 4;
+        I2S_Device.sample_rate_conf.tx_bits_mod = i2s_bits_per_chan_t::I2S_BITS_PER_CHAN_8BIT;
+
+        // DEBUG_V(String("  ClockFrequency: ") + String(ClockFrequency));
+        // DEBUG_V(String("           ClkNS: ") + String(ClkNS, 10));
+        // DEBUG_V(String("          ClkDiv: ") + String(ClkDiv, 10));
+        // DEBUG_V(String("    TargetTickNS: ") + String(TargetTickNS, 10));
+        // DEBUG_V(String("  fractionalPart: ") + String(fractionalPart, 10));
+        // DEBUG_V(String("     denominator: ") + String(denominator, 10));
+        // DEBUG_V(String("       numerator: ") + String(numerator, 10));
+        // DEBUG_V(String("   commonDivisor: ") + String(commonDivisor, 10));
+        // DEBUG_V(String("    clkm_div_num: ") + String(I2S_Device.clkm_conf.clkm_div_num));
+        // DEBUG_V(String("      clkm_div_b: ") + String(I2S_Device.clkm_conf.clkm_div_b));
+        // DEBUG_V(String("      clkm_div_a: ") + String(I2S_Device.clkm_conf.clkm_div_a));
 
-        // I2S_Device.fifo_conf.val = 0;
         // Dictated by datasheet
         I2S_Device.fifo_conf.tx_fifo_mod_force_en = true;
         I2S_Device.fifo_conf.tx_fifo_mod = 2; // I2S_TX_CHAN_MODE_MONO;
-//        I2S_Device.fifo_conf.tx_fifo_mod = 1; // twice
-        // I2S_Device.fifo_conf.tx_data_num = 32; 
-        // I2S_Device.fifo_conf.rx_data_num = 32; //Thresholds. 
-        // I2S_Device.fifo_conf.rx_fifo_mod_force_en = 1;
 
-        // I2S_Device.conf1.val = 0;
         I2S_Device.conf1.tx_stop_en = false;
         I2S_Device.conf1.tx_zeros_rm_en = false;
-//        I2S_Device.conf1.tx_pcm_conf = 0;
+        I2S_Device.conf1.tx_pcm_conf = 0;
         I2S_Device.conf1.tx_pcm_bypass = true;
 
-        // I2S_Device.conf_chan.val = 0;
-        // Tx in mono mode, read 32 bit per sample from fifo
-//        I2S_Device.conf_chan.tx_chan_mod = 1; // Both slots transmit the left channel data.
-        // I2S_Device.conf_chan.rx_chan_mod = 1;
-
         // DEBUG_V("3. Enable LCD mode specific register flags");
         I2S_Device.conf.val = 0;
-//        I2S_Device.conf.tx_right_first = true;
-//        I2S_Device.conf.tx_msb_right = false;
         I2S_Device.conf.tx_slave_mod = false;
 
-        // 4. Clear standard serial pin allocations 
-
-        // DEBUG_V("5. Route parallel data lines manually via GPIO matrix");
-        // I2S0 data output signals start at I2S_DataStartSignal 
-        int GpioTableIndex = 0;
-        for (auto gpioValue : GpioDataPins)
+        // DEBUG_V("4. disconnect all of the I2S connections from the matrix");
+        for (auto currentConfig : OutputI2SSlotConfigs)
         {
-            // DEBUG_V(String("Configuring GPIO pin: ") + String(GpioDataPins[i]));
-            m_gpio_matrix_out_check_and_set(gpioValue, I2S_DataStartSignal + GpioTableIndex, false, false);
-            GpioTableIndex++;
+            m_gpio_matrix_out_check_and_set(currentConfig.DataPin, I2S_DataStartSignal + currentConfig.I2SChannelId, false, false);
         }
 
         // set the reserved bits to 1 to avoid sending garbage data
@@ -234,6 +229,7 @@ void c_OutputI2S::InitI2Sdriver ()
         {
             logcon(F("Failed to start I2S peripheral"));
         }
+
 } // InitI2Sdriver
 
 //----------------------------------------------------------------------------
@@ -243,15 +239,6 @@ void c_OutputI2S::Begin ()
 
     do // once
     {
-        GpioDataPins[0] = gpio_num_t(0);
-        GpioDataPins[1] = gpio_num_t(1);
-        GpioDataPins[2] = gpio_num_t(2);
-        GpioDataPins[3] = gpio_num_t(3);
-        GpioDataPins[4] = gpio_num_t(4);
-        GpioDataPins[5] = gpio_num_t(5);
-        GpioDataPins[6] = gpio_num_t(12);
-        GpioDataPins[7] = gpio_num_t(13);
-
         InitI2Sdriver();
 
         // DEBUG_V();
@@ -347,9 +334,110 @@ void c_OutputI2S::StartSendingData ()
 } // StartSendingData
 
 //----------------------------------------------------------------------------
-void IRAM_ATTR c_OutputI2S::ISR_ProcessDma ()
+uint8_t c_OutputI2S::RegisterSlotDevice  (OutputI2SChannelConfig_t config)
 {
+    // DEBUG_START;
+
+    uint8_t DataBit = 0;
+
+    do // once
+    {
+        if (config.I2SChannelId >= I2S_MAX_NUM_PORTS)
+        {
+            logcon(F("Invalid I2S channel ID"));
+            break;
+        }
+        if (nullptr == config.GetNextIntensityBit)
+        {
+            logcon(F("Invalid GetNextIntensityBit function pointer"));
+            break;
+        }
+
+        auto & currentConfig = OutputI2SSlotConfigs[config.I2SChannelId];
+        currentConfig.arg = config.arg;
+        currentConfig.GetNextIntensityBit = config.GetNextIntensityBit;
+        currentConfig.IsActive = config.IsActive;
+        
+        DataBit = 1 << config.I2SChannelId;
+
+        SetGpio(config.I2SChannelId, config.DataPin);
 
-} // ISR_ProcessDma
+    } while(false);
+
+    // DEBUG_END;
+    return DataBit;
+} // RegisterSlotDevice
+
+//----------------------------------------------------------------------------
+void c_OutputI2S::SetGpio (uint32_t I2SChannelId, gpio_num_t NewGpio)
+{
+    // DEBUG_START;
+
+    do // once
+    {
+        if (I2SChannelId >= I2S_MAX_NUM_PORTS)
+        {
+            logcon(F("ERROR: Invalid I2S channel ID"));
+            break;
+        }
+
+        // DEBUG_V(String("I2SChannelId: ") + String(I2SChannelId));
+        // DEBUG_V(String("     NewGpio: ") + String(NewGpio));
+        // DEBUG_V(String("     DataPin: ") + String(OutputI2SSlotConfigs[I2SChannelId].DataPin));
+
+        if(NewGpio == OutputI2SSlotConfigs[I2SChannelId].DataPin)
+        {
+            // DEBUG_V("GPIO did not change. Ignore the request");
+            break;
+        }
+
+        if(I2S_PIN_NO_CHANGE != OutputI2SSlotConfigs[I2SChannelId].DataPin)
+        {
+            // DEBUG_V("release the old GPIO from the matrix");
+            ResetGpio(OutputI2SSlotConfigs[I2SChannelId].DataPin);
+        }
+
+        // DEBUG_V("attach the new GPIO");
+        OutputI2SSlotConfigs[I2SChannelId].DataPin = NewGpio;
+        m_gpio_matrix_out_check_and_set(NewGpio, I2S_DataStartSignal + I2SChannelId, false, false);
+
+    } while(false);
+
+    // DEBUG_END;
+} // SetGpio
+
+//----------------------------------------------------------------------------
+void c_OutputI2S::SetOutputState (uint32_t I2SChannelId, bool NewState)
+{
+    DEBUG_START;
+
+    OutputI2SSlotConfigs[I2SChannelId].IsActive = NewState;
+
+    DEBUG_END;
+} // SetOutputState
+
+//----------------------------------------------------------------------------
+uint32_t c_OutputI2S::GetBitTimeSlices    (uint32_t BitTimeInNanoSec)
+{
+    // DEBUG_START;
+
+    uint32_t Result = 0;
+
+    do // once
+    {
+        if (BitTimeInNanoSec < 200)
+        {
+            logcon(F("Invalid bit time"));
+            break;
+        }
+
+        // round up
+        Result = ((BitTimeInNanoSec + int(I2S_TickTimeInNS)) - 1) / int(I2S_TickTimeInNS);
+
+    } while(false);
+
+    // DEBUG_END;
+    return Result;
+}
 
 #endif // defined(SUPPORT_I2S)
diff --git a/src/output/OutputMgr.cpp b/src/output/OutputMgr.cpp
index fd56de710..0af1f704a 100644
--- a/src/output/OutputMgr.cpp
+++ b/src/output/OutputMgr.cpp
@@ -41,6 +41,7 @@
 #include "output/OutputUCS1903Rmt.hpp"
 #include "output/OutputUCS1903Uart.hpp"
 #include "output/OutputWS2801Spi.hpp"
+#include "output/OutputWS2811I2S.hpp"
 #include "output/OutputWS2811Rmt.hpp"
 #include "output/OutputWS2811Uart.hpp"
 #include "output/OutputGS8208Uart.hpp"
@@ -54,14 +55,20 @@
 #include "input/InputMgr.hpp"
 
 #ifdef SUPPORT_I2S
-    #include "output/OutputI2S.hpp"
-#endif // def SUPPORT_I2S
-
-#ifdef ARDUINO_ARCH_ESP32
+    #define CLASS_TYPE_NAME(n)      n ## I2S
+    #define AddToProtocolClassList(name) \
+            c_ ## name ## I2S ClassList_ ## name;
+#elif defined(SUPPORT_RMT)
     #define CLASS_TYPE_NAME(n)      n ## Rmt
-#else
+    #define AddToProtocolClassList(name) \
+            c_ ## name ## Rmt ClassList_ ## name;
+#elif defined(SUPPORT_UART)
     #define CLASS_TYPE_NAME(n)      n ## Uart
-#endif // def ARDUINO_ARCH_ESP32
+    #define AddToProtocolClassList(name) \
+            c_ ## name ## Uart ClassList_ ## name;
+#else
+    #error "No Output Driver has been selected. Update Platform IO to select an output driver"
+#endif
     #define CLASS_TYPE_NO_NAME(n)   n
 
 #define AllocatePort(ClassType, Output, OutputType) \
@@ -149,34 +156,23 @@ static const SupportedOutputProtocol_t SupportedOutputProtocolList[] =
     #endif // def SUPPORT_OutputProtocol_FireGod
 };
 
-
-
-#ifdef ARDUINO_ARCH_ESP8266
-#define AddUartRmtToProtocolClassList(name) \
-    c_ ## name ## Uart name ## Uart;
-#else
-#define AddUartRmtToProtocolClassList(name) \
-    c_ ## name ## Uart name ## Uart; \
-    c_ ## name ## Uart name ## Rmt;
-#endif // def ARDUINO_ARCH_ESP32
-
 union alignas(32) OutputProtocolClasses_t
 {
     c_OutputDisabled OutputDisabled;
 
     #ifdef SUPPORT_OutputProtocol_WS2811
-    AddUartRmtToProtocolClassList(OutputWS2811);
+    AddToProtocolClassList(OutputWS2811);
     #endif // def SUPPORT_OutputProtocol_WS2811
 
     #ifdef SUPPORT_OutputProtocol_GECE
-    AddUartRmtToProtocolClassList(OutputGECE);
+    AddToProtocolClassList(OutputGECE);
     #endif // def SUPPORT_OutputProtocol_GECE
 
     #if defined(SUPPORT_OutputProtocol_DMX) || \
         defined(SUPPORT_OutputProtocol_Renard) || \
         defined(SUPPORT_OutputProtocol_Serial) || \
         defined(SUPPORT_OutputProtocol_FireGod)
-    AddUartRmtToProtocolClassList(OutputSerial);
+    AddToProtocolClassList(OutputSerial);
     #endif
 
     #ifdef SUPPORT_OutputProtocol_Relay
@@ -188,11 +184,11 @@ union alignas(32) OutputProtocolClasses_t
     #endif // def SUPPORT_OutputProtocol_Servo_PCA9685
 
     #ifdef SUPPORT_OutputProtocol_UCS1903
-    AddUartRmtToProtocolClassList(OutputUCS1903);
+    AddToProtocolClassList(OutputUCS1903);
     #endif // def SUPPORT_OutputProtocol_UCS1903
 
     #ifdef SUPPORT_OutputProtocol_TM1814
-    AddUartRmtToProtocolClassList(OutputTM1814);
+    AddToProtocolClassList(OutputTM1814);
     #endif // def SUPPORT_OutputProtocol_TM1814
 
     #ifdef SUPPORT_OutputProtocol_WS2801
@@ -204,11 +200,11 @@ union alignas(32) OutputProtocolClasses_t
     #endif // def SUPPORT_OutputProtocol_APA102
 
     #ifdef SUPPORT_OutputProtocol_GS8208
-    AddUartRmtToProtocolClassList(OutputGS8208);
+    AddToProtocolClassList(OutputGS8208);
     #endif // def SUPPORT_OutputProtocol_GS8208
 
     #ifdef SUPPORT_OutputProtocol_UCS8903
-    AddUartRmtToProtocolClassList(OutputUCS8903);
+    AddToProtocolClassList(OutputUCS8903);
     #endif // def SUPPORT_OutputProtocol_UCS8903
 
     #ifdef SUPPORT_OutputProtocol_TLS3001
@@ -245,10 +241,6 @@ static DriverInfo_t * pOutputChannelDrivers  = nullptr;;
 
 static uint8_t OutputBuffer[OM_MAX_NUM_CHANNELS];
 
-#ifdef SUPPORT_I2S
-static c_OutputI2S OutputI2S;
-#endif // def SUPPORT_I2S
-
 //-----------------------------------------------------------------------------
 // Methods
 //-----------------------------------------------------------------------------
@@ -616,7 +608,6 @@ void c_OutputMgr::GetStatus (JsonObject & jsonStatus)
 
 #if defined(SUPPORT_I2S)
     OutputI2S.GetStatus(jsonStatus);
-    // jsonStatus["PollCount"] = PollCount;
 #endif // defined(SUPPORT_I2S)
 
     JsonArray OutputStatus = jsonStatus[(char*)CN_output].to<JsonArray> ();
@@ -637,10 +628,6 @@ void c_OutputMgr::ClearStatistics ()
 {
     // DEBUG_START;
 
-#if defined(ARDUINO_ARCH_ESP32)
-    // PollCount = 0;
-#endif // defined(ARDUINO_ARCH_ESP32)
-
     for (uint8_t index = 0; index < NumOutputPorts; ++index)
     {
         DriverInfo_t & CurrentOutput = pOutputChannelDrivers[index];
diff --git a/src/output/OutputRmtV4.cpp b/src/output/OutputRmtV4.cpp
index 1392a74bb..92476fc82 100644
--- a/src/output/OutputRmtV4.cpp
+++ b/src/output/OutputRmtV4.cpp
@@ -17,7 +17,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_RMT)
 #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
 
 #include "output/OutputRmt.hpp"
@@ -604,4 +604,4 @@ bool c_OutputRmt::StartNewFrame ()
 } // StartNewFrame
 
 #endif // ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
-#endif // defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_RMT)
diff --git a/src/output/OutputRmtV5.cpp b/src/output/OutputRmtV5.cpp
index fb2ca5683..2e3ccac61 100644
--- a/src/output/OutputRmtV5.cpp
+++ b/src/output/OutputRmtV5.cpp
@@ -17,7 +17,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_RMT)
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
 
 #include "output/OutputRmt.hpp"
@@ -514,4 +514,4 @@ bool c_OutputRmt::StartNewFrame ()
 } // StartNewFrame
 
 #endif // ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-#endif // defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_RMT)
diff --git a/src/output/OutputSerialRmt.cpp b/src/output/OutputSerialRmt.cpp
index 754661b56..9044feab2 100644
--- a/src/output/OutputSerialRmt.cpp
+++ b/src/output/OutputSerialRmt.cpp
@@ -17,7 +17,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if (defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(ARDUINO_ARCH_ESP32)
+#if (defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(SUPPORT_RMT)
 
 #include "output/OutputSerialRmt.hpp"
 
@@ -322,4 +322,4 @@ void c_OutputSerialRmt::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // (defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(ARDUINO_ARCH_ESP32)
+#endif // (defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(SUPPORT_RMT)
diff --git a/src/output/OutputSerialUart.cpp b/src/output/OutputSerialUart.cpp
index 81fb27920..99acfd18a 100644
--- a/src/output/OutputSerialUart.cpp
+++ b/src/output/OutputSerialUart.cpp
@@ -16,7 +16,7 @@ GNU General Public License for more details.
 ******************************************************************/
 
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)
+#if (defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)) && defined(SUPPORT_UART)
 
 #include "output/OutputSerialUart.hpp"
 
@@ -140,4 +140,4 @@ void c_OutputSerialUart::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)
+#endif // defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard) && defined(SUPPORT_UART)
diff --git a/src/output/OutputTLS3001Rmt.cpp b/src/output/OutputTLS3001Rmt.cpp
index 7036c0449..a67389b52 100644
--- a/src/output/OutputTLS3001Rmt.cpp
+++ b/src/output/OutputTLS3001Rmt.cpp
@@ -17,7 +17,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_TLS3001) && defined (ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_TLS3001) && defined (SUPPORT_RMT)
 
 #include "output/OutputTLS3001Rmt.hpp"
 
@@ -583,4 +583,4 @@ bool IRAM_ATTR fsm_RMT_state_SendDataIdle::ISR_GetNextBitToSend (rmt_item32_t &D
     return false;
 } // fsm_RMT_state_SendDataIdle
 
-#endif // defined(SUPPORT_OutputProtocol_TLS3001) && defined (ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_TLS3001) && defined (SUPPORT_RMT)
diff --git a/src/output/OutputTM1814Rmt.cpp b/src/output/OutputTM1814Rmt.cpp
index f1ea0f2fc..e27719fec 100644
--- a/src/output/OutputTM1814Rmt.cpp
+++ b/src/output/OutputTM1814Rmt.cpp
@@ -18,7 +18,7 @@
 */
 
 #include "ESPixelStick.h"
-#if defined (SUPPORT_OutputProtocol_TM1814) && defined (ARDUINO_ARCH_ESP32)
+#if defined (SUPPORT_OutputProtocol_TM1814) && defined (SUPPORT_RMT)
 
 #include "output/OutputTM1814Rmt.hpp"
 
@@ -248,4 +248,4 @@ void c_OutputTM1814Rmt::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined (SUPPORT_OutputProtocol_TM1814) && defined (ARDUINO_ARCH_ESP32)
+#endif // defined (SUPPORT_OutputProtocol_TM1814) && defined (SUPPORT_RMT)
diff --git a/src/output/OutputTM1814Uart.cpp b/src/output/OutputTM1814Uart.cpp
index caabec3da..bec599785 100644
--- a/src/output/OutputTM1814Uart.cpp
+++ b/src/output/OutputTM1814Uart.cpp
@@ -18,7 +18,7 @@
 */
 
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_TM1814)
+#if defined(SUPPORT_OutputProtocol_TM1814) && defined(SUPPORT_UART)
 
 #include "output/OutputTM1814Uart.hpp"
 
@@ -167,4 +167,4 @@ void c_OutputTM1814Uart::PauseOutput(bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_TM1814)
+#endif // defined(SUPPORT_OutputProtocol_TM1814) && defined(SUPPORT_UART)
diff --git a/src/output/OutputUCS1903Rmt.cpp b/src/output/OutputUCS1903Rmt.cpp
index 79d91cf9f..a780a52df 100644
--- a/src/output/OutputUCS1903Rmt.cpp
+++ b/src/output/OutputUCS1903Rmt.cpp
@@ -18,7 +18,7 @@
 */
 #include "ESPixelStick.h"
 
-#if defined(SUPPORT_OutputProtocol_UCS1903) && defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_UCS1903) && defined(SUPPORT_RMT)
 
 #include "output/OutputUCS1903Rmt.hpp"
 
@@ -243,4 +243,4 @@ void c_OutputUCS1903Rmt::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_UCS1903) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_UCS1903) && defined(SUPPORT_RMT)
diff --git a/src/output/OutputUCS1903Uart.cpp b/src/output/OutputUCS1903Uart.cpp
index 9eaef3534..c2d9a0e7d 100644
--- a/src/output/OutputUCS1903Uart.cpp
+++ b/src/output/OutputUCS1903Uart.cpp
@@ -18,7 +18,7 @@
 */
 
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_UCS1903)
+#if defined(SUPPORT_OutputProtocol_UCS1903) && defined(SUPPORT_UART)
 
 #include "output/OutputUCS1903Uart.hpp"
 
@@ -153,4 +153,4 @@ void c_OutputUCS1903Uart::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_UCS1903)
+#endif // defined(SUPPORT_OutputProtocol_UCS1903) && defined(SUPPORT_UART)
diff --git a/src/output/OutputUCS8903Rmt.cpp b/src/output/OutputUCS8903Rmt.cpp
index 4b8900abf..c0c3b0ed6 100644
--- a/src/output/OutputUCS8903Rmt.cpp
+++ b/src/output/OutputUCS8903Rmt.cpp
@@ -18,7 +18,7 @@
 */
 #include "ESPixelStick.h"
 
-#if defined(SUPPORT_OutputProtocol_UCS8903) && defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_UCS8903) && defined(SUPPORT_RMT)
 
 #include "output/OutputUCS8903Rmt.hpp"
 
@@ -244,4 +244,4 @@ void c_OutputUCS8903Rmt::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_UCS8903) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_UCS8903) && defined(SUPPORT_RMT)
diff --git a/src/output/OutputUCS8903Uart.cpp b/src/output/OutputUCS8903Uart.cpp
index 23dcf6e61..032baa2e0 100644
--- a/src/output/OutputUCS8903Uart.cpp
+++ b/src/output/OutputUCS8903Uart.cpp
@@ -19,7 +19,7 @@
 
 #include "ESPixelStick.h"
 
-#if defined(SUPPORT_OutputProtocol_UCS8903)
+#if defined(SUPPORT_OutputProtocol_UCS8903) && defined(SUPPORT_UART)
 
 #include "output/OutputUCS8903Uart.hpp"
 
@@ -191,4 +191,4 @@ void c_OutputUCS8903Uart::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_UCS8903)
+#endif // defined(SUPPORT_OutputProtocol_UCS8903) && defined(SUPPORT_UART)
diff --git a/src/output/OutputUart.cpp b/src/output/OutputUart.cpp
index 0d2c63537..0814f124b 100644
--- a/src/output/OutputUart.cpp
+++ b/src/output/OutputUart.cpp
@@ -17,7 +17,7 @@
 *
 */
 #include "ESPixelStick.h"
-
+#if defined(SUPPORT_UART)
 #include "output/OutputUart.hpp"
 
 extern "C"
@@ -1255,4 +1255,6 @@ void c_OutputUart::RestoreSerialPortOperation()
 
     // DEBUG_END;
 
-} // RestoreSerialPortOperation
\ No newline at end of file
+} // RestoreSerialPortOperation
+
+#endif // defined(SUPPORT_UART)
\ No newline at end of file
diff --git a/src/output/OutputWS2811I2S.cpp b/src/output/OutputWS2811I2S.cpp
new file mode 100644
index 000000000..fbf1a8ec6
--- /dev/null
+++ b/src/output/OutputWS2811I2S.cpp
@@ -0,0 +1,309 @@
+/*
+* OutputWS2811I2S.cpp - WS2811 driver code for ESPixelStick I2S Channel
+*
+* Project: ESPixelStick - An ESP8266 / ESP32 and E1.31 based pixel driver
+* Copyright (c) 2015, 2026 Shelby Merrick
+* http://www.forkineye.com
+*
+*  This program is provided free for you to use in any way that you wish,
+*  subject to the laws and regulations where you are using it.  Due diligence
+*  is strongly suggested before using this code.  Please give credit where due.
+*
+*  The Author makes no warranty of any kind, express or implied, with regard
+*  to this program or the documentation contained in this document.  The
+*  Author shall not be liable in any event for incidental or consequential
+*  damages in connection with, or arising out of, the furnishing, performance
+*  or use of these programs.
+*
+*/
+#include "ESPixelStick.h"
+#if defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_I2S)
+
+#include "output/OutputWS2811I2S.hpp"
+#include "output/OutputMgr.hpp"
+
+//----------------------------------------------------------------------------
+static bool GetNextBitToSendBase (void * arg, I2S_item_t * DataToSend, uint32_t numSlices)
+{
+    return reinterpret_cast<c_OutputWS2811I2S*>(arg)->GetNextBitToSend(DataToSend, numSlices);
+} // ISR_GetNextBitToSend
+
+//----------------------------------------------------------------------------
+c_OutputWS2811I2S::c_OutputWS2811I2S (OM_OutputPortDefinition_t & OutputPortDefinition,
+                                      c_OutputMgr::e_OutputProtocolType outputType) :
+    c_OutputWS2811 (OutputPortDefinition, outputType)
+{
+    // DEBUG_START;
+
+    // DEBUG_V (String ("WS2811_PIXEL_I2S_TICKS_BIT_0_H: 0x") + String (WS2811_PIXEL_I2S_TICKS_BIT_0_HIGH, HEX));
+    // DEBUG_V (String ("WS2811_PIXEL_I2S_TICKS_BIT_0_L: 0x") + String (WS2811_PIXEL_I2S_TICKS_BIT_0_LOW,  HEX));
+    // DEBUG_V (String ("WS2811_PIXEL_I2S_TICKS_BIT_1_H: 0x") + String (WS2811_PIXEL_I2S_TICKS_BIT_1_HIGH, HEX));
+    // DEBUG_V (String ("WS2811_PIXEL_I2S_TICKS_BIT_1_L: 0x") + String (WS2811_PIXEL_I2S_TICKS_BIT_1_LOW,  HEX));
+
+    // DEBUG_END;
+
+} // c_OutputWS2811I2S
+
+//----------------------------------------------------------------------------
+c_OutputWS2811I2S::~c_OutputWS2811I2S ()
+{
+    // DEBUG_START;
+
+    // DEBUG_END;
+} // ~c_OutputWS2811I2S
+
+//----------------------------------------------------------------------------
+void c_OutputWS2811I2S::Begin ()
+{
+    // DEBUG_START;
+
+    I2Sdriver = static_cast<c_OutputI2S*>(OutputMgr.GetI2sDriver());
+
+    c_OutputWS2811::Begin ();
+
+    // DEBUG_V (String ("DataPin: ") + String (DataPin));
+
+    ZeroHighBitCount = I2Sdriver->GetBitTimeSlices(WS2811_PIXEL_NS_BIT_0_HIGH);
+    ZeroLowBitCount  = I2Sdriver->GetBitTimeSlices(WS2811_PIXEL_NS_BIT_0_LOW);
+    OneHighBitCount  = I2Sdriver->GetBitTimeSlices(WS2811_PIXEL_NS_BIT_1_HIGH);
+    OneLowBitCount   = I2Sdriver->GetBitTimeSlices(WS2811_PIXEL_NS_BIT_1_LOW);
+
+    DEBUG_V(String("ZeroHighBitCount: ") + String(ZeroHighBitCount));
+    DEBUG_V(String(" ZeroLowBitCount: ") + String(ZeroLowBitCount));
+    DEBUG_V(String(" OneHighBitCount: ") + String(OneHighBitCount));
+    DEBUG_V(String("  OneLowBitCount: ") + String(OneLowBitCount));
+
+    IfgBitCount         = 0;
+    IfgBitCurrentCount  = 0;
+    HighBitCurrentCount = 0;
+    LowBitCurrentCount  = 0;
+
+    DataBit = 0; // no data bit assigned yet
+    DataBitMask = ~DataBit;
+
+    c_OutputI2S::OutputI2SChannelConfig_t OutputI2SConfig;
+    OutputI2SConfig.I2SChannelId            = uint32_t(OutputPortDefinition.PortId);
+    OutputI2SConfig.DataPin                 = gpio_num_t(OutputPortDefinition.gpios.data);
+    OutputI2SConfig.arg                     = this;
+    OutputI2SConfig.GetNextIntensityBit     = GetNextBitToSendBase;
+    OutputI2SConfig.IsActive                = false; // do not output data
+
+    DataBit = I2Sdriver->RegisterSlotDevice(OutputI2SConfig);
+    DataBitMask = ~ DataBit;
+
+    // DEBUG_V(String("    DataBit: 0x") + String(DataBit, HEX));
+    // DEBUG_V(String("DataBitMask: 0x") + String(DataBitMask, HEX));
+
+    HasBeenInitialized = true;
+
+    // DEBUG_END;
+
+} // Begin
+
+//----------------------------------------------------------------------------
+bool c_OutputWS2811I2S::SetConfig (ArduinoJson::JsonObject& jsonConfig)
+{
+    // DEBUG_START;
+
+    bool response = c_OutputWS2811::SetConfig (jsonConfig);
+
+    uint32_t SavedIfgBitCount = IfgBitCount;
+    IfgBitCount = I2Sdriver->GetBitTimeSlices(InterFrameGapInMicroSec * NanoSecondsInAMicroSecond);
+    // DEBUG_V(String("     IfgBitCount: ") + String(IfgBitCount));
+
+    // update the output GPIO
+    I2Sdriver->SetGpio(OutputPortDefinition.PortId, OutputPortDefinition.gpios.data);
+
+    if(!SavedIfgBitCount)
+    {
+        // get all of the slice counters set up for the first frame
+        StartNewDataFrame();
+
+        // start the transmiter
+        I2Sdriver->SetOutputState(OutputPortDefinition.PortId, true);
+    }
+
+    // DEBUG_V();
+
+    // DEBUG_END;
+    return response;
+
+} // SetConfig
+
+//----------------------------------------------------------------------------
+void c_OutputWS2811I2S::SetOutputBufferSize (uint32_t NumChannelsAvailable)
+{
+    // DEBUG_START;
+
+    c_OutputWS2811::SetOutputBufferSize (NumChannelsAvailable);
+
+    // DEBUG_END;
+
+} // SetBufferSize
+
+//----------------------------------------------------------------------------
+void c_OutputWS2811I2S::GetStatus (ArduinoJson::JsonObject& jsonStatus)
+{
+    // // DEBUG_START;
+    c_OutputWS2811::GetStatus (jsonStatus);
+    I2Sdriver->GetStatus (jsonStatus);
+
+    #ifdef USE_I2S_DEBUG_COUNTERS
+    jsonStatus[F("FrameDurationInMicroSec")] = FrameDurationInMicroSec;
+    jsonStatus[F("FrameStartTimeInMicroSec")] = GetFrameStartTimeInMicroSec();
+    uint32_t now = micros();
+    jsonStatus[F("Now")] = now;
+    jsonStatus[F("FrameStartDelta")] = now - GetFrameStartTimeInMicroSec();
+    #endif // def USE_I2S_DEBUG_COUNTERS
+
+    #ifdef WS2811_I2S_DEBUG_COUNTERS
+    JsonObject JsonCounters = jsonStatus["JsonCounters"].to<JsonObject>();
+    JsonWrite(JsonCounters, "GetNextBit",  I2SDebugCounters.GetNextBit);
+    JsonWrite(JsonCounters, "FrameStarts", I2SDebugCounters.FrameStarts);
+    JsonWrite(JsonCounters, "FrameEnds",   I2SDebugCounters.FrameEnds);
+    JsonWrite(JsonCounters, "IfgBits",     I2SDebugCounters.IfgBits);
+    JsonWrite(JsonCounters, "DataBits",    I2SDebugCounters.DataBits);
+    JsonWrite(JsonCounters, "DataBytes",   I2SDebugCounters.DataBytes);
+    JsonWrite(JsonCounters, "BitHigh",     I2SDebugCounters.BitHigh);
+    JsonWrite(JsonCounters, "BitLow",      I2SDebugCounters.BitLow);
+    #endif // def WS2811_I2S_DEBUG_COUNTERS
+
+    // // DEBUG_END;
+} // GetStatus
+
+//----------------------------------------------------------------------------
+uint32_t c_OutputWS2811I2S::Poll ()
+{
+    // DEBUG_START;
+
+    // DEBUG_END;
+    return ActualFrameDurationMicroSec;
+
+} // Poll
+
+//----------------------------------------------------------------------------
+void c_OutputWS2811I2S::StartNewDataFrame()
+{
+    // DEBUG_START;
+
+    StartNewFrame();
+
+    // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
+    INC_WS2811_I2S_DEBUG_COUNTERS(FrameStarts);
+    IfgBitCurrentCount = IfgBitCount;
+
+    // set up for the next data byte
+    INC_WS2811_I2S_DEBUG_COUNTERS(DataBytes);
+    c_OutputPixel::ISR_GetNextIntensityToSend(DataPattern);
+    DataPatternMask = 0x80;
+
+    if(DataPattern & DataPatternMask)
+    {
+        // send a one bit
+        HighBitCurrentCount = OneHighBitCount;
+        LowBitCurrentCount  = OneLowBitCount;
+    }
+    else // send a zero bit
+    {
+        HighBitCurrentCount = ZeroHighBitCount;
+        LowBitCurrentCount  = ZeroLowBitCount;
+    }
+
+    // DEBUG_END;
+} // StartNewDataFrame
+
+//----------------------------------------------------------------------------
+bool c_OutputWS2811I2S::GetNextBitToSend (I2S_item_t * pDataToSend, uint32_t numSlices)
+{
+    INC_WS2811_I2S_DEBUG_COUNTERS(GetNextBit);
+    bool Response = true;
+
+    for(int CurrentSliceId = 0; CurrentSliceId < numSlices; ++CurrentSliceId, ++pDataToSend)
+    {
+        if (IfgBitCurrentCount)
+        {
+            INC_WS2811_I2S_DEBUG_COUNTERS(IfgBits);
+            pDataToSend->data &= DataBitMask; // output low
+            --IfgBitCurrentCount;
+            continue;
+        }
+
+        INC_WS2811_I2S_DEBUG_COUNTERS(DataBits);
+        if(HighBitCurrentCount)
+        {
+            INC_WS2811_I2S_DEBUG_COUNTERS(BitHigh);
+
+            --HighBitCurrentCount;
+            pDataToSend->data |= DataBit; // output high
+            continue;
+        }
+
+        if(LowBitCurrentCount)
+        {
+            INC_WS2811_I2S_DEBUG_COUNTERS(BitLow);
+            pDataToSend->data &= DataBitMask; // output low
+            --LowBitCurrentCount;
+            if(LowBitCurrentCount)
+            {
+                // more low bits to send
+                continue;
+            }
+        }
+
+        // bit data has completed
+        DataPatternMask = DataPatternMask >> 1;
+        // do we need to set up the next data byte to send?
+        if(0 == DataPatternMask)
+        {
+            if(c_OutputPixel::ISR_MoreDataToSend())
+            {
+                INC_WS2811_I2S_DEBUG_COUNTERS(DataBytes);
+                c_OutputPixel::ISR_GetNextIntensityToSend(DataPattern);
+                DataPatternMask = 0x80;
+                if(DataPattern & DataPatternMask)
+                {
+                    HighBitCurrentCount = OneHighBitCount;
+                    LowBitCurrentCount  = OneLowBitCount;
+                }
+                else
+                {
+                    HighBitCurrentCount = ZeroHighBitCount;
+                    LowBitCurrentCount  = ZeroLowBitCount;
+                }
+            }
+            else
+            {
+                INC_WS2811_I2S_DEBUG_COUNTERS(FrameEnds);
+                StartNewDataFrame();
+            }
+            continue;
+        }
+        // more bits to send in the current data byte
+        INC_WS2811_I2S_DEBUG_COUNTERS(DataBits);
+        if(DataPattern & DataPatternMask)
+        {
+            // send a one bit
+            HighBitCurrentCount = OneHighBitCount;
+            LowBitCurrentCount  = OneLowBitCount;
+        }
+        else // send a zero bit
+        {
+            HighBitCurrentCount = ZeroHighBitCount;
+            LowBitCurrentCount  = ZeroLowBitCount;
+        }
+    };
+
+    return Response;
+} // ISR_GetNextBitToSend
+
+//----------------------------------------------------------------------------
+void c_OutputWS2811I2S::PauseOutput (bool State)
+{
+    // DEBUG_START;
+
+    c_OutputWS2811::PauseOutput(State);
+
+    // DEBUG_END;
+} // PauseOutput
+
+#endif // defined(SUPPORT_OutputProtocol_WS2811) && defined(ARDUINO_ARCH_ESP32)
diff --git a/src/output/OutputWS2811Rmt.cpp b/src/output/OutputWS2811Rmt.cpp
index 528937ddc..3bd64a69d 100644
--- a/src/output/OutputWS2811Rmt.cpp
+++ b/src/output/OutputWS2811Rmt.cpp
@@ -17,7 +17,7 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_WS2811) && defined(ARDUINO_ARCH_ESP32)
+#if defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_RMT)
 
 #include "output/OutputWS2811Rmt.hpp"
 
@@ -262,4 +262,4 @@ void c_OutputWS2811Rmt::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_WS2811) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_RMT)
diff --git a/src/output/OutputWS2811Uart.cpp b/src/output/OutputWS2811Uart.cpp
index 43f32f359..612075dca 100644
--- a/src/output/OutputWS2811Uart.cpp
+++ b/src/output/OutputWS2811Uart.cpp
@@ -18,7 +18,7 @@
 */
 
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_WS2811)
+#if defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_UART)
 
 #include "output/OutputWS2811Uart.hpp"
 
@@ -179,4 +179,4 @@ void c_OutputWS2811Uart::PauseOutput (bool State)
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_WS2811)
+#endif // defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_UART)

From 5124ded352a67f0cc79f1bacc6c7aa9b63dbad93 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 17 Aug 2026 23:05:03 -0400
Subject: [PATCH 11/34] Made new settings pretty

---
 platformio.ini | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/platformio.ini b/platformio.ini
index 3b646a3a0..56bad432b 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -103,9 +103,9 @@ build_flags =
     -D DEFAULT_FTP_SERVER_NETWORK_TYPE_ESP8266=2
     -D DEFAULT_STORAGE_TYPE_ESP8266=2
     ;----------------------
-; Only one of these can be enabled at a time
+    ; Only one of these can be enabled at a time
     -D SUPPORT_UART=1
-;    -D SUPPORT_I2S=1
+    ;-D SUPPORT_I2S=1
 
 lib_ignore =
     Ethernet ; Remove once Art-Net is fixed / replaced to not depend on Ethernet in lib config
@@ -142,11 +142,12 @@ build_flags =
     -D CONFIG_RMT_ISR_IRAM_SAFE=yes
 ;    -D USE_RMT_DEBUG_COUNTERS=1
 ;    -D DEBUG_RMT_XLAT_ISSUES=1
-;----------------------
-; Only one of these can be enabled at a time
-;    -D SUPPORT_UART=1
-;    -D SUPPORT_I2S=1
+    ;----------------------
+    ; Only one of these can be enabled at a time
+    ; -D SUPPORT_UART=1
+    ; -D SUPPORT_I2S=1
     -D SUPPORT_RMT=1
+    ;----------------------
     -I ./include/service
 
 build_unflags =
@@ -196,6 +197,12 @@ build_flags =
     -D CONFIG_RMT_ENCODER_FUNC_IN_IRAM=1
 ;    -D USE_RMT_DEBUG_COUNTERS=1
 ;    -D DEBUG_RMT_XLAT_ISSUES=1
+    ;----------------------
+    ; Only one of these can be enabled at a time
+    ; -D SUPPORT_UART=1
+    ; -D SUPPORT_I2S=1
+    -D SUPPORT_RMT=1
+    ;----------------------
 
 build_unflags =
     ${env.build_unflags}

From cc197a7d0d840635fb8b33780806db96b843dda6 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 17 Aug 2026 23:05:25 -0400
Subject: [PATCH 12/34] Added fine grained HW support.

---
 include/output/OutputUCS1903Uart.hpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/include/output/OutputUCS1903Uart.hpp b/include/output/OutputUCS1903Uart.hpp
index 610cca321..948210c0d 100644
--- a/include/output/OutputUCS1903Uart.hpp
+++ b/include/output/OutputUCS1903Uart.hpp
@@ -22,8 +22,8 @@
 *
 */
 
+#if defined(SUPPORT_OutputProtocol_UCS1903) && defined(SUPPORT_UART)
 #include "OutputCommon.hpp"
-#if defined(SUPPORT_OutputProtocol_UCS1903)
 
 #include "OutputUCS1903.hpp"
 #include "OutputUart.hpp"
@@ -39,9 +39,6 @@ class c_OutputUCS1903Uart : public c_OutputUCS1903
     // functions to be provided by the derived class
     void    Begin ();                                         ///< set up the operating environment based on the current config (or defaults)
     uint32_t Poll ();                                        ///< Call from loop(),  renders output data
-#if defined(ARDUINO_ARCH_ESP32)
-    bool     RmtPoll () {return false;}
-#endif // defined(ARDUINO_ARCH_ESP32)
     void    PauseOutput (bool State);
     bool    SetConfig (ArduinoJson::JsonObject& jsonConfig);
     void    GetConfig (ArduinoJson::JsonObject& jsonConfig);
@@ -55,4 +52,4 @@ class c_OutputUCS1903Uart : public c_OutputUCS1903
 
 }; // c_OutputUCS1903Uart
 
-#endif // defined(SUPPORT_OutputProtocol_UCS1903)
+#endif // defined(SUPPORT_OutputProtocol_UCS1903) && defined(SUPPORT_UART)

From c85be0fe24e636ab9e4c9a33b1e858ab4498fc0e Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 28 Aug 2026 11:39:41 -0400
Subject: [PATCH 13/34] Renamed startNewFrame method.

---
 src/output/OutputSpi.cpp |    2 +-
 src/service/m_i2s.c      | 2330 --------------------------------------
 2 files changed, 1 insertion(+), 2331 deletions(-)
 delete mode 100644 src/service/m_i2s.c

diff --git a/src/output/OutputSpi.cpp b/src/output/OutputSpi.cpp
index f727f36b6..d807e8e4d 100644
--- a/src/output/OutputSpi.cpp
+++ b/src/output/OutputSpi.cpp
@@ -292,7 +292,7 @@ void c_OutputSpi::StartNewFrame()
 
     if(OutputPixel)
     {
-        OutputPixel->StartNewFrame ();
+        OutputPixel->ISR_StartNewFrame ();
     }
 #if defined(SUPPORT_OutputProtocol_GRINCH)
     else if(OutputGrinch)
diff --git a/src/service/m_i2s.c b/src/service/m_i2s.c
deleted file mode 100644
index 377b87d98..000000000
--- a/src/service/m_i2s.c
+++ /dev/null
@@ -1,2330 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-#ifdef SUPPORT_I2S
-
-#include <string.h>
-#include <stdbool.h>
-#include <math.h>
-#include <esp_types.h>
-#include "freertos/FreeRTOS.h"
-#include "freertos/queue.h"
-#include "freertos/semphr.h"
-
-#include "soc/lldesc.h"
-#include "driver/gpio.h"
-#include "m_i2s.h"
-#include "hal/gpio_hal.h"
-#include "hal/i2s_hal.h"
-#if _SOC_I2S_SUPPORTS_DAC
-#include "driver/dac.h"
-#endif // _SOC_I2S_SUPPORTS_DAC
-
-#if _SOC_I2S_SUPPORTS_ADC
-#include "adc1_private.h"
-#endif // _SOC_I2S_SUPPORTS_ADC
-
-#if SOC_GDMA_SUPPORTED
-#include "esp_private/gdma.h"
-#endif
-
-#include "soc/clk_ctrl_os.h"
-#include "esp_intr_alloc.h"
-#include "esp_err.h"
-#include "esp_check.h"
-#include "esp_attr.h"
-#include "esp_log.h"
-#include "esp_pm.h"
-#include "esp_efuse.h"
-#include "esp_rom_gpio.h"
-#include "esp_private/i2s_platform.h"
-#include "esp_private/sar_periph_ctrl.h"
-
-#include "sdkconfig.h"
-
-static const char *TAG = "I2S";
-
-#define I2S_ENTER_CRITICAL_ISR(i2s_num)          portENTER_CRITICAL_ISR(&i2s_spinlock[i2s_num])
-#define I2S_EXIT_CRITICAL_ISR(i2s_num)           portEXIT_CRITICAL_ISR(&i2s_spinlock[i2s_num])
-#define I2S_ENTER_CRITICAL(i2s_num)              portENTER_CRITICAL(&i2s_spinlock[i2s_num])
-#define I2S_EXIT_CRITICAL(i2s_num)               portEXIT_CRITICAL(&i2s_spinlock[i2s_num])
-
-#define I2S_DMA_BUFFER_MAX_SIZE     4092
-
-#if !SOC_GDMA_SUPPORTED
-#define I2S_INTR_IN_SUC_EOF   BIT(9)
-#define I2S_INTR_OUT_EOF      BIT(12)
-#define I2S_INTR_IN_DSCR_ERR  BIT(13)
-#define I2S_INTR_OUT_DSCR_ERR BIT(14)
-#define I2S_INTR_MAX          (~0)
-#endif
-
-/**
- * @brief DMA buffer object
- *
- */
-typedef struct {
-    char **buf;
-    int buf_size;
-    volatile int rw_pos;
-    volatile void *curr_ptr;
-    SemaphoreHandle_t mux;
-    xQueueHandle queue;
-    lldesc_t **desc;
-} i2s_dma_t;
-
-/**
- * @brief I2S object instance
- *
- */
-typedef struct {
-    i2s_port_t i2s_num;         /*!< I2S port number*/
-    int queue_size;             /*!< I2S event queue size*/
-    QueueHandle_t i2s_queue;    /*!< I2S queue handler*/
-    int dma_buf_count;          /*!< DMA buffer count, number of buffer*/
-    int dma_buf_len;            /*!< DMA buffer length, length of each buffer*/
-    uint32_t last_buf_size;     /*!< DMA last buffer size */
-    i2s_dma_t *tx;              /*!< DMA Tx buffer*/
-    i2s_dma_t *rx;              /*!< DMA Rx buffer*/
-#if SOC_GDMA_SUPPORTED
-    gdma_channel_handle_t rx_dma_chan;  /*!< I2S rx gDMA channel handle*/
-    gdma_channel_handle_t tx_dma_chan;  /*!< I2S tx gDMA channel handle*/
-#else
-    i2s_isr_handle_t i2s_isr_handle; /*!< I2S Interrupt handle*/
-#endif
-    bool tx_desc_auto_clear;    /*!< I2S auto clear tx descriptor on underflow */
-    bool use_apll;              /*!< I2S use APLL clock */
-    int fixed_mclk;             /*!< I2S fixed MLCK clock */
-    i2s_mclk_multiple_t mclk_multiple; /*!< The multiple of I2S master clock(MCLK) to sample rate */
-
-#ifdef CONFIG_PM_ENABLE
-    esp_pm_lock_handle_t pm_lock;
-#endif
-    i2s_hal_context_t hal;      /*!< I2S hal context*/
-    i2s_channel_fmt_t   init_chan_fmt;  /*!< The initial channel format while installing, used for keep left or right mono when switch between mono and stereo */
-    i2s_hal_config_t hal_cfg;   /*!< I2S hal configurations*/
-} i2s_obj_t;
-
-static i2s_obj_t *p_i2s[SOC_I2S_NUM];
-static portMUX_TYPE i2s_platform_spinlock = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED;
-static portMUX_TYPE i2s_spinlock[SOC_I2S_NUM] = {
-    [0 ... SOC_I2S_NUM - 1] = (portMUX_TYPE)portMUX_INITIALIZER_UNLOCKED,
-};
-
-#if _SOC_I2S_SUPPORTS_ADC
-static int _i2s_adc_unit = -1;
-static int _i2s_adc_channel = -1;
-#endif
-
-/*
- * This block is an overview of APIs in i2s.c
- * Functions with [main] tag are summary functions that provide main i2s service
- * Functions with [helper] tag are helper functions that served for summary functions
- * Functions with [intr] tag are interrupt handling functions or interrupt callback functions
-  -------------------------------------------------------------
-                    I2S GPIO operation
-  -------------------------------------------------------------
-   - [helper]   gpio_matrix_out_check_and_set
-   - [helper]   gpio_matrix_in_check_and_set
-   - [helper]   i2s_check_set_mclk
-   - [main]     i2s_set_pin
-  -------------------------------------------------------------
-                    I2S DMA operation
-  -------------------------------------------------------------
-   - [intr]     i2s_dma_rx_callback
-   - [intr]     i2s_dma_tx_callback
-   - [intr]     i2s_intr_handler_default
-   - [helper]   i2s_dma_intr_init
-   - [helper]   i2s_tx_reset
-   - [helper]   i2s_rx_reset
-   - [helper]   i2s_tx_start
-   - [helper]   i2s_rx_start
-   - [helper]   i2s_tx_stop
-   - [helper]   i2s_rx_stop
-  -------------------------------------------------------------
-                   I2S buffer operation
-  -------------------------------------------------------------
-   - [helper]   i2s_get_buf_size
-   - [helper]   i2s_delete_dma_buffer
-   - [helper]   i2s_alloc_dma_buffer
-   - [main]     i2s_realloc_dma_buffer
-   - [main]     i2s_destroy_dma_object
-   - [main]     i2s_create_dma_object
-   - [main]     i2s_zero_dma_buffer
-  -------------------------------------------------------------
-                   I2S clock operation
-  -------------------------------------------------------------
-   - [helper]   i2s_config_source_clock
-   - [helper]   i2s_calculate_adc_dac_clock
-   - [helper]   i2s_calculate_pdm_tx_clock
-   - [helper]   i2s_calculate_pdm_rx_clock
-   - [helper]   i2s_calculate_common_clock
-   - [main]     i2s_calculate_clock
-  -------------------------------------------------------------
-                   I2S configuration
-  -------------------------------------------------------------
-   - [helper]   i2s_get_max_channel_num
-   - [helper]   i2s_get_active_channel_num
-   - [helper]   i2s_set_dac_mode
-   - [helper]   _i2s_adc_mode_recover
-   - [main]     i2s_set_adc_mode
-   - [main]     i2s_adc_enable
-   - [main]     i2s_adc_disable
-   - [helper]   i2s_set_sample_rates
-   - [main]     i2s_pcm_config
-   - [helper]   i2s_set_pdm_rx_down_sample
-   - [helper]   i2s_set_pdm_tx_up_sample
-   - [helper]   i2s_check_cfg_validity
-   - [helper]   i2s_tx_set_clk_and_channel
-   - [helper]   i2s_rx_set_clk_and_channel
-   - [main]     i2s_get_clk
-   - [main]     i2s_set_clk
-  -------------------------------------------------------------
-                   I2S driver operation
-  -------------------------------------------------------------
-   - [main]     i2s_start
-   - [main]     i2s_stop
-   - [helper]   i2s_driver_init
-   - [helper]   i2s_dma_object_init
-   - [main]     i2s_driver_install
-   - [main]     i2s_driver_uninstall
-   - [main]     i2s_write
-   - [main]     i2s_write_expand
-   - [main]     i2s_read
-  -------------------------------------------------------------*/
-
-/*-------------------------------------------------------------
-                    I2S GPIO operation
-  -------------------------------------------------------------*/
-/**
- * @brief   I2S GPIO matrix set ouput
- *
- * @param   gpio          GPIO number
- * @param   singal_idx    GPIO singnal ID, refer to 'gpio_sig_map.h'
- * @param   out_inv       Output invert enable
- * @param   oen_inv       Output eanble control invert enable
- */
-void m_gpio_matrix_out_check_and_set(gpio_num_t gpio, uint32_t signal_idx, bool out_inv, bool oen_inv)
-{
-    //if pin = -1, disconnect the signal from GPIO matrix, and connect the signal to SIG_GPIO_OUT_IDX, which is a dummy output signal.
-    if (gpio == -1) 
-    {
-        esp_rom_gpio_connect_out_signal(signal_idx, SIG_GPIO_OUT_IDX, false, false);
-    }
-    else
-    {
-        gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
-        gpio_set_direction(gpio, GPIO_MODE_OUTPUT);
-        esp_rom_gpio_connect_out_signal(gpio, signal_idx, out_inv, oen_inv);
-    }
-}
-
-/**
- * @brief   I2S GPIO matrix set input
- *
- * @param   gpio          GPIO number
- * @param   singal_idx    GPIO singnal ID, refer to 'gpio_sig_map.h'
- * @param   out_inv       Output invert enable
- * @param   oen_inv       Output eanble control invert enable
- */
-static void m_gpio_matrix_in_check_and_set(gpio_num_t gpio, uint32_t signal_idx, bool inv)
-{
-    if (gpio != -1) {
-        gpio_hal_iomux_func_sel(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
-        /* Set direction, for some GPIOs, the input function are not enabled as default */
-        gpio_set_direction(gpio, GPIO_MODE_INPUT);
-        esp_rom_gpio_connect_in_signal(gpio, signal_idx, inv);
-    }
-}
-
-/**
- * @brief   I2S set GPIO for mclk
- *
- * @param   i2s_num     I2S device number
- * @param   gpio_num    GPIO number for mclk
- * @return
- *      - ESP_OK                Check or set success
- *      - ESP_ERR_INVALID_ARG   GPIO is not available
- */
-static esp_err_t m_i2s_check_set_mclk(i2s_port_t i2s_num, gpio_num_t gpio_num)
-{
-    if (gpio_num == -1) {
-        return ESP_OK;
-    }
-#if CONFIG_IDF_TARGET_ESP32
-    ESP_RETURN_ON_FALSE((gpio_num == GPIO_NUM_0 || gpio_num == GPIO_NUM_1 || gpio_num == GPIO_NUM_3),
-                        ESP_ERR_INVALID_ARG, TAG,
-                        "ESP32 only support to set GPIO0/GPIO1/GPIO3 as mclk signal, error GPIO number:%d", gpio_num);
-    bool is_i2s0 = i2s_num == I2S_NUM_0;
-    if (gpio_num == GPIO_NUM_0) {
-        PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0_CLK_OUT1);
-        WRITE_PERI_REG(PIN_CTRL, is_i2s0 ? 0xFFF0 : 0xFFFF);
-    } else if (gpio_num == GPIO_NUM_1) {
-        PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_U0TXD_CLK_OUT3);
-        WRITE_PERI_REG(PIN_CTRL, is_i2s0 ? 0xF0F0 : 0xF0FF);
-    } else {
-        PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0RXD_U, FUNC_U0RXD_CLK_OUT2);
-        WRITE_PERI_REG(PIN_CTRL, is_i2s0 ? 0xFF00 : 0xFF0F);
-    }
-#else
-    ESP_RETURN_ON_FALSE(GPIO_IS_VALID_GPIO(gpio_num), ESP_ERR_INVALID_ARG, TAG, "mck_io_num invalid");
-    gpio_matrix_out_check_and_set(gpio_num, i2s_periph_signal[i2s_num].mck_out_sig, 0, 0);
-#endif
-    ESP_LOGI(TAG, "I2S%d, MCLK output by GPIO%d", i2s_num, gpio_num);
-    return ESP_OK;
-}
-
-/**
- * @brief   Set gpio pins for I2S
- *
- * @param   i2s_num     I2S device number
- * @param   pin         Pin configuration
- * @return
- *      - ESP_OK                Set pin success
- *      - ESP_ERR_INVALID_ARG   GPIO is not available
- */
-esp_err_t m_i2s_set_pin(i2s_port_t i2s_num, const i2s_pin_config_t *pin)
-{
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    if (pin == NULL) {
-#if _SOC_I2S_SUPPORTS_DAC
-        return m_i2s_set_dac_mode(I2S_DAC_CHANNEL_BOTH_EN);
-#else
-        return ESP_ERR_INVALID_ARG;
-#endif
-    }
-    /* Check validity of selected pins */
-    ESP_RETURN_ON_FALSE((pin->bck_io_num == -1 || GPIO_IS_VALID_GPIO(pin->bck_io_num)),
-                        ESP_ERR_INVALID_ARG, TAG, "bck_io_num invalid");
-    ESP_RETURN_ON_FALSE((pin->ws_io_num == -1 || GPIO_IS_VALID_GPIO(pin->ws_io_num)),
-                        ESP_ERR_INVALID_ARG, TAG, "ws_io_num invalid");
-    ESP_RETURN_ON_FALSE((pin->data_out_num == -1 || GPIO_IS_VALID_GPIO(pin->data_out_num)),
-                        ESP_ERR_INVALID_ARG, TAG, "data_out_num invalid");
-    ESP_RETURN_ON_FALSE((pin->data_in_num == -1 || GPIO_IS_VALID_GPIO(pin->data_in_num)),
-                        ESP_ERR_INVALID_ARG, TAG, "data_in_num invalid");
-
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_SLAVE) {
-        /* For "tx + rx + slave" or "rx + slave" mode, we should select RX signal index for ws and bck */
-        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-            m_gpio_matrix_in_check_and_set(pin->ws_io_num, i2s_periph_signal[i2s_num].s_rx_ws_sig, 0);
-            m_gpio_matrix_in_check_and_set(pin->bck_io_num, i2s_periph_signal[i2s_num].s_rx_bck_sig, 0);
-            /* For "tx + slave" mode, we should select TX signal index for ws and bck */
-        } else {
-            m_gpio_matrix_in_check_and_set(pin->ws_io_num, i2s_periph_signal[i2s_num].s_tx_ws_sig, 0);
-            m_gpio_matrix_in_check_and_set(pin->bck_io_num, i2s_periph_signal[i2s_num].s_tx_bck_sig, 0);
-        }
-    } else {
-        /* mclk only available in master mode */
-        ESP_RETURN_ON_ERROR(m_i2s_check_set_mclk(i2s_num, pin->mck_io_num), TAG, "mclk config failed");
-        /* For "tx + rx + master" or "tx + master" mode, we should select TX signal index for ws and bck */
-        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-            m_gpio_matrix_out_check_and_set(pin->ws_io_num, i2s_periph_signal[i2s_num].m_tx_ws_sig, 0, 0);
-            m_gpio_matrix_out_check_and_set(pin->bck_io_num, i2s_periph_signal[i2s_num].m_tx_bck_sig, 0, 0);
-            /* For "rx + master" mode, we should select RX signal index for ws and bck */
-        } else {
-            m_gpio_matrix_out_check_and_set(pin->ws_io_num, i2s_periph_signal[i2s_num].m_rx_ws_sig, 0, 0);
-            m_gpio_matrix_out_check_and_set(pin->bck_io_num, i2s_periph_signal[i2s_num].m_rx_bck_sig, 0, 0);
-        }
-    }
-
-    /* Set data input/ouput GPIO */
-    m_gpio_matrix_out_check_and_set(pin->data_out_num, i2s_periph_signal[i2s_num].data_out_sig, 0, 0);
-    m_gpio_matrix_in_check_and_set(pin->data_in_num, i2s_periph_signal[i2s_num].data_in_sig, 0);
-    return ESP_OK;
-}
-
-/*-------------------------------------------------------------
-                    I2S DMA operation
-  -------------------------------------------------------------*/
-#if SOC_GDMA_SUPPORTED
-/**
- * @brief   GDMA rx callback function
- * @note    This function is called by GDMA default ISR handler
- *
- * @param   dma_chan    GDMA channel handler
- * @param   event_data  GDMA rx event data
- * @param   user_data   GDMA user data
- * @return
- *      - true  need yield
- *      - false no need
- */
-static bool IRAM_ATTR m_i2s_dma_rx_callback(gdma_channel_handle_t dma_chan, gdma_event_data_t *event_data, void *user_data)
-{
-    i2s_obj_t *p_i2s = (i2s_obj_t *) user_data;
-    portBASE_TYPE need_awoke = 0;
-    portBASE_TYPE tmp = 0;
-    int dummy;
-    i2s_event_t i2s_event;
-    uint32_t finish_desc;
-
-    if (p_i2s->rx) {
-        finish_desc = event_data->rx_eof_desc_addr;
-        i2s_event.size = ((lldesc_t *)finish_desc)->size;
-        if (xQueueIsQueueFullFromISR(p_i2s->rx->queue)) {
-            xQueueReceiveFromISR(p_i2s->rx->queue, &dummy, &tmp);
-            need_awoke |= tmp;
-            if (p_i2s->i2s_queue) {
-                i2s_event.type = I2S_EVENT_RX_Q_OVF;
-                xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
-                need_awoke |= tmp;
-            }
-        }
-        xQueueSendFromISR(p_i2s->rx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
-        need_awoke |= tmp;
-        if (p_i2s->i2s_queue) {
-            i2s_event.type = I2S_EVENT_RX_DONE;
-            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
-            need_awoke |= tmp;
-        }
-    }
-    return need_awoke;
-}
-
-/**
- * @brief   GDMA tx callback function
- * @note    This function is called by GDMA default ISR handler
- *
- * @param   dma_chan    GDMA channel handler
- * @param   event_data  GDMA tx event data
- * @param   user_data   GDMA user data
- * @return
- *      - whether need yield
- */
-static bool IRAM_ATTR m_i2s_dma_tx_callback(gdma_channel_handle_t dma_chan, gdma_event_data_t *event_data, void *user_data)
-{
-    i2s_obj_t *p_i2s = (i2s_obj_t *) user_data;
-    portBASE_TYPE need_awoke = 0;
-    portBASE_TYPE tmp = 0;
-    int dummy;
-    i2s_event_t i2s_event;
-    uint32_t finish_desc;
-    if (p_i2s->tx) {
-        finish_desc = event_data->tx_eof_desc_addr;
-        i2s_event.size = ((lldesc_t *)finish_desc)->size;
-        if (xQueueIsQueueFullFromISR(p_i2s->tx->queue)) {
-            xQueueReceiveFromISR(p_i2s->tx->queue, &dummy, &tmp);
-            need_awoke |= tmp;
-            if (p_i2s->i2s_queue) {
-                i2s_event.type = I2S_EVENT_TX_Q_OVF;
-                i2s_event.size = p_i2s->tx->buf_size;
-                xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
-                need_awoke |= tmp;
-            }
-        }
-        if (p_i2s->tx_desc_auto_clear) {
-            memset((void *) (((lldesc_t *)finish_desc)->buf), 0, p_i2s->tx->buf_size);
-        }
-        xQueueSendFromISR(p_i2s->tx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
-        need_awoke |= tmp;
-        if (p_i2s->i2s_queue) {
-            i2s_event.type = I2S_EVENT_TX_DONE;
-            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
-            need_awoke |= tmp;
-        }
-    }
-    return need_awoke;
-}
-
-#else
-
-/**
- * @brief   I2S defalut interrupt handler
- * @note    This function is triggered by I2S dedicated DMA interrupt
- *
- * @param   arg      Argument transport to ISR, here is the pointer to I2S object
- */
-static void IRAM_ATTR m_i2s_intr_handler_default(void *arg)
-{
-    i2s_obj_t *p_i2s = (i2s_obj_t *) arg;
-    uint32_t status = i2s_hal_get_intr_status(&(p_i2s->hal));
-    if (status == 0) {
-        //Avoid spurious interrupt
-        return;
-    }
-
-    i2s_event_t i2s_event;
-    int dummy;
-    portBASE_TYPE need_awoke = 0;
-    portBASE_TYPE tmp = 0;
-    uint32_t  finish_desc = 0;
-    if ((status & I2S_INTR_OUT_DSCR_ERR) || (status & I2S_INTR_IN_DSCR_ERR)) {
-        ESP_EARLY_LOGE(TAG, "dma error, interrupt status: 0x%08x", status);
-        if (p_i2s->i2s_queue) {
-            i2s_event.type = I2S_EVENT_DMA_ERROR;
-            if (xQueueIsQueueFullFromISR(p_i2s->i2s_queue)) {
-                xQueueReceiveFromISR(p_i2s->i2s_queue, &dummy, &tmp);
-                need_awoke |= tmp;
-            }
-            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
-            need_awoke |= tmp;
-        }
-    }
-
-    if ((status & I2S_INTR_OUT_EOF) && p_i2s->tx) {
-        i2s_hal_get_out_eof_des_addr(&(p_i2s->hal), &finish_desc);
-        i2s_event.size = ((lldesc_t *)finish_desc)->size;
-        // All buffers are empty. This means we have an underflow on our hands.
-        if (xQueueIsQueueFullFromISR(p_i2s->tx->queue)) {
-            xQueueReceiveFromISR(p_i2s->tx->queue, &dummy, &tmp);
-            need_awoke |= tmp;
-            if (p_i2s->i2s_queue) {
-                i2s_event.type = I2S_EVENT_TX_Q_OVF;
-                xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
-                need_awoke |= tmp;
-            }
-        }
-        // See if tx descriptor needs to be auto cleared:
-        // This will avoid any kind of noise that may get introduced due to transmission
-        // of previous data from tx descriptor on I2S line.
-        if (p_i2s->tx_desc_auto_clear) {
-            memset((void *) (((lldesc_t *)finish_desc)->buf), 0, p_i2s->tx->buf_size);
-        }
-        xQueueSendFromISR(p_i2s->tx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
-        need_awoke |= tmp;
-        if (p_i2s->i2s_queue) {
-            i2s_event.type = I2S_EVENT_TX_DONE;
-            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
-            need_awoke |= tmp;
-        }
-    }
-
-    if ((status & I2S_INTR_IN_SUC_EOF) && p_i2s->rx) {
-        // All buffers are full. This means we have an overflow.
-        i2s_hal_get_in_eof_des_addr(&(p_i2s->hal), &finish_desc);
-        i2s_event.size = ((lldesc_t *)finish_desc)->size;
-        if (xQueueIsQueueFullFromISR(p_i2s->rx->queue)) {
-            xQueueReceiveFromISR(p_i2s->rx->queue, &dummy, &tmp);
-            need_awoke |= tmp;
-            if (p_i2s->i2s_queue) {
-                i2s_event.type = I2S_EVENT_RX_Q_OVF;
-                xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
-                need_awoke |= tmp;
-            }
-        }
-        xQueueSendFromISR(p_i2s->rx->queue, &(((lldesc_t *)finish_desc)->buf), &tmp);
-        need_awoke |= tmp;
-        if (p_i2s->i2s_queue) {
-            i2s_event.type = I2S_EVENT_RX_DONE;
-            xQueueSendFromISR(p_i2s->i2s_queue, (void * )&i2s_event, &tmp);
-            need_awoke |= tmp;
-        }
-    }
-    i2s_hal_clear_intr_status(&(p_i2s->hal), status);
-
-    if (need_awoke == pdTRUE) {
-        portYIELD_FROM_ISR();
-    }
-}
-#endif
-
-
-/**
- * @brief   I2S DMA interrupt initialization
- * @note    I2S will use GDMA if chip supports, and the interrupt is triggered by GDMA.
- *
- * @param   i2s_num     I2S device number
- * @return
- *      - ESP_OK                    I2S DMA interrupt initialize success
- *      - ESP_ERR_NOT_FOUND         GDMA channel not found
- *      - ESP_ERR_INVALID_ARG       Invalid arguments
- *      - ESP_ERR_INVALID_STATE     GDMA state error
- */
-static esp_err_t m_i2s_dma_intr_init(i2s_port_t i2s_num, int intr_flag)
-{
-#if SOC_GDMA_SUPPORTED
-    /* Set GDMA trigger module */
-    gdma_trigger_t trig = {.periph = GDMA_TRIG_PERIPH_I2S};
-
-    switch (i2s_num) {
-#if SOC_I2S_NUM > 1
-    case I2S_NUM_1:
-        trig.instance_id = SOC_GDMA_TRIG_PERIPH_I2S1;
-        break;
-#endif
-    default:
-        trig.instance_id = SOC_GDMA_TRIG_PERIPH_I2S0;
-        break;
-    }
-
-    /* Set GDMA config */
-    gdma_channel_alloc_config_t dma_cfg = {};
-    if ( p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-        dma_cfg.direction = GDMA_CHANNEL_DIRECTION_TX;
-        /* Register a new GDMA tx channel */
-        ESP_RETURN_ON_ERROR(gdma_new_channel(&dma_cfg, &p_i2s[i2s_num]->tx_dma_chan), TAG, "Register tx dma channel error");
-        ESP_RETURN_ON_ERROR(gdma_connect(p_i2s[i2s_num]->tx_dma_chan, trig), TAG, "Connect tx dma channel error");
-        gdma_tx_event_callbacks_t cb = {.on_trans_eof = m_i2s_dma_tx_callback};
-        /* Set callback function for GDMA, the interrupt is triggered by GDMA, then the GDMA ISR will call the  callback function */
-        gdma_register_tx_event_callbacks(p_i2s[i2s_num]->tx_dma_chan, &cb, p_i2s[i2s_num]);
-    }
-    if ( p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-        dma_cfg.direction = GDMA_CHANNEL_DIRECTION_RX;
-        /* Register a new GDMA rx channel */
-        ESP_RETURN_ON_ERROR(gdma_new_channel(&dma_cfg, &p_i2s[i2s_num]->rx_dma_chan), TAG, "Register rx dma channel error");
-        ESP_RETURN_ON_ERROR(gdma_connect(p_i2s[i2s_num]->rx_dma_chan, trig), TAG, "Connect rx dma channel error");
-        gdma_rx_event_callbacks_t cb = {.on_recv_eof = m_i2s_dma_rx_callback};
-        /* Set callback function for GDMA, the interrupt is triggered by GDMA, then the GDMA ISR will call the  callback function */
-        gdma_register_rx_event_callbacks(p_i2s[i2s_num]->rx_dma_chan, &cb, p_i2s[i2s_num]);
-    }
-#else
-    /* Initial I2S module interrupt */
-    ESP_RETURN_ON_ERROR(esp_intr_alloc(i2s_periph_signal[i2s_num].irq, intr_flag, m_i2s_intr_handler_default, p_i2s[i2s_num], &p_i2s[i2s_num]->i2s_isr_handle), TAG, "Register I2S Interrupt error");
-#endif // SOC_GDMA_SUPPORTED
-    return ESP_OK;
-}
-
-/**
- * @brief   I2S tx reset
- *
- * @param   i2s_num     I2S device number
- */
-static void m_i2s_tx_reset(i2s_port_t i2s_num)
-{
-    p_i2s[i2s_num]->tx->curr_ptr = NULL;
-    p_i2s[i2s_num]->tx->rw_pos = 0;
-    i2s_hal_reset_tx(&(p_i2s[i2s_num]->hal));
-#if SOC_GDMA_SUPPORTED
-    gdma_reset(p_i2s[i2s_num]->tx_dma_chan);
-#else
-    i2s_hal_reset_txdma(&(p_i2s[i2s_num]->hal));
-#endif
-    i2s_hal_reset_tx_fifo(&(p_i2s[i2s_num]->hal));
-}
-
-/**
- * @brief   I2S rx reset
- *
- * @param   i2s_num     I2S device number
- */
-static void m_i2s_rx_reset(i2s_port_t i2s_num)
-{
-    p_i2s[i2s_num]->rx->curr_ptr = NULL;
-    p_i2s[i2s_num]->rx->rw_pos = 0;
-    i2s_hal_reset_rx(&(p_i2s[i2s_num]->hal));
-#if SOC_GDMA_SUPPORTED
-    gdma_reset(p_i2s[i2s_num]->rx_dma_chan);
-#else
-    i2s_hal_reset_rxdma(&(p_i2s[i2s_num]->hal));
-#endif
-    i2s_hal_reset_rx_fifo(&(p_i2s[i2s_num]->hal));
-}
-
-/**
- * @brief   I2S tx start
- *
- * @param   i2s_num     I2S device number
- */
-static void m_i2s_tx_start(i2s_port_t i2s_num)
-{
-#if SOC_GDMA_SUPPORTED
-    gdma_start(p_i2s[i2s_num]->tx_dma_chan, (uint32_t) p_i2s[i2s_num]->tx->desc[0]);
-#else
-    i2s_hal_enable_tx_dma(&(p_i2s[i2s_num]->hal));
-    i2s_hal_enable_tx_intr(&(p_i2s[i2s_num]->hal));
-    i2s_hal_start_tx_link(&(p_i2s[i2s_num]->hal), (uint32_t) p_i2s[i2s_num]->tx->desc[0]);
-#endif
-    i2s_hal_start_tx(&(p_i2s[i2s_num]->hal));
-}
-
-/**
- * @brief   I2S rx start
- *
- * @param   i2s_num     I2S device number
- */
-static void i2s_rx_start(i2s_port_t i2s_num)
-{
-#if SOC_GDMA_SUPPORTED
-    gdma_start(p_i2s[i2s_num]->rx_dma_chan, (uint32_t) p_i2s[i2s_num]->rx->desc[0]);
-#else
-    i2s_hal_enable_rx_dma(&(p_i2s[i2s_num]->hal));
-    i2s_hal_enable_rx_intr(&(p_i2s[i2s_num]->hal));
-    i2s_hal_start_rx_link(&(p_i2s[i2s_num]->hal), (uint32_t) p_i2s[i2s_num]->rx->desc[0]);
-#endif
-    i2s_hal_start_rx(&(p_i2s[i2s_num]->hal));
-}
-
-/**
- * @brief   I2S tx stop
- *
- * @param   i2s_num     I2S device number
- */
-static void m_i2s_tx_stop(i2s_port_t i2s_num)
-{
-    i2s_hal_stop_tx(&(p_i2s[i2s_num]->hal));
-#if SOC_GDMA_SUPPORTED
-    gdma_stop(p_i2s[i2s_num]->tx_dma_chan);
-#else
-    i2s_hal_stop_tx_link(&(p_i2s[i2s_num]->hal));
-    i2s_hal_disable_tx_intr(&(p_i2s[i2s_num]->hal));
-    i2s_hal_disable_tx_dma(&(p_i2s[i2s_num]->hal));
-#endif
-}
-
-/**
- * @brief   I2S rx stop
- *
- * @param   i2s_num     I2S device number
- */
-static void m_i2s_rx_stop(i2s_port_t i2s_num)
-{
-    i2s_hal_stop_rx(&(p_i2s[i2s_num]->hal));
-#if SOC_GDMA_SUPPORTED
-    gdma_stop(p_i2s[i2s_num]->rx_dma_chan);
-#else
-    i2s_hal_stop_rx_link(&(p_i2s[i2s_num]->hal));
-    i2s_hal_disable_rx_intr(&(p_i2s[i2s_num]->hal));
-    i2s_hal_disable_rx_dma(&(p_i2s[i2s_num]->hal));
-#endif
-}
-
-/*-------------------------------------------------------------
-                   I2S buffer operation
-  -------------------------------------------------------------*/
-/**
- * @brief I2S get DMA buffer size
- *
- * @param   i2s_num     I2S device number
- * @return
- *      - DMA buffer size
- */
-static inline uint32_t m_i2s_get_buf_size(i2s_port_t i2s_num)
-{
-    /* Calculate bytes per sample, align to 16 bit */
-    uint32_t bytes_per_sample = ((p_i2s[i2s_num]->hal_cfg.sample_bits + 15) / 16) * 2;
-    /* The DMA buffer limitation is 4092 bytes */
-    uint32_t bytes_per_frame = bytes_per_sample * p_i2s[i2s_num]->hal_cfg.active_chan;
-    p_i2s[i2s_num]->dma_buf_len = (p_i2s[i2s_num]->dma_buf_len * bytes_per_frame > I2S_DMA_BUFFER_MAX_SIZE) ?
-                                  I2S_DMA_BUFFER_MAX_SIZE / bytes_per_frame : p_i2s[i2s_num]->dma_buf_len;
-    return p_i2s[i2s_num]->dma_buf_len * bytes_per_frame;
-}
-
-/**
- * @brief   Delete DMA buffer and descriptor
- *
- * @param   i2s_num     I2S device number
- * @param   dma_obj     DMA object
- * @return
- *      - ESP_OK                DMA buffer delete success
- *      - ESP_ERR_INVALID_ARG   dma_obj is NULL
- */
-static esp_err_t m_i2s_delete_dma_buffer(i2s_port_t i2s_num, i2s_dma_t *dma_obj)
-{
-    ESP_RETURN_ON_FALSE(dma_obj, ESP_ERR_INVALID_ARG, TAG, "I2S DMA object can't be NULL");
-    /* Loop to destroy every descriptor and buffer */
-    for (int cnt = 0; cnt < p_i2s[i2s_num]->dma_buf_count; cnt++) {
-        if (dma_obj->desc && dma_obj->desc[cnt]) {
-            free(dma_obj->desc[cnt]);
-            dma_obj->desc[cnt] = NULL;
-        }
-        if (dma_obj->buf && dma_obj->buf[cnt]) {
-            free(dma_obj->buf[cnt]);
-            dma_obj->buf[cnt] = NULL;
-        }
-    }
-    return ESP_OK;
-}
-
-/**
- * @brief   Allocate memory for DMA buffer and descriptor
- *
- * @param   i2s_num     I2S device number
- * @param   dma_obj     DMA object
- * @return
- *      - ESP_OK            Allocate success
- *      - ESP_ERR_NO_MEM    No memory for DMA buffer
- */
-static esp_err_t m_i2s_alloc_dma_buffer(i2s_port_t i2s_num, i2s_dma_t *dma_obj)
-{
-    esp_err_t ret = ESP_OK;
-    ESP_GOTO_ON_FALSE(dma_obj, ESP_ERR_INVALID_ARG, err, TAG, "I2S DMA object can't be NULL");
-
-    uint32_t buf_cnt = p_i2s[i2s_num]->dma_buf_count;
-    for (int cnt = 0; cnt < buf_cnt; cnt++) {
-        /* Allocate DMA buffer */
-        dma_obj->buf[cnt] = (char *) heap_caps_calloc(dma_obj->buf_size, sizeof(char), MALLOC_CAP_DMA);
-        ESP_GOTO_ON_FALSE(dma_obj->buf[cnt], ESP_ERR_NO_MEM, err, TAG, "Error malloc dma buffer");
-        /* Initialize DMA buffer to 0 */
-        memset(dma_obj->buf[cnt], 0, dma_obj->buf_size);
-        ESP_LOGD(TAG, "Addr[%d] = %d", cnt, (int)dma_obj->buf[cnt]);
-
-        /* Allocate DMA descpriptor */
-        dma_obj->desc[cnt] = (lldesc_t *) heap_caps_calloc(1, sizeof(lldesc_t), MALLOC_CAP_DMA);
-        ESP_GOTO_ON_FALSE(dma_obj->desc[cnt], ESP_ERR_NO_MEM, err, TAG,  "Error malloc dma description entry");
-    }
-    /* DMA descriptor must be initialize after all descriptor has been created, otherwise they can't be linked together as a chain */
-    for (int cnt = 0; cnt < buf_cnt; cnt++) {
-        /* Initialize DMA descriptor */
-        dma_obj->desc[cnt]->owner = 1;
-        dma_obj->desc[cnt]->eof = 1;
-        dma_obj->desc[cnt]->sosf = 0;
-        dma_obj->desc[cnt]->length = dma_obj->buf_size;
-        dma_obj->desc[cnt]->size = dma_obj->buf_size;
-        dma_obj->desc[cnt]->buf = (uint8_t *) dma_obj->buf[cnt];
-        dma_obj->desc[cnt]->offset = 0;
-        /* Link to the next descriptor */
-        dma_obj->desc[cnt]->empty = (uint32_t)((cnt < (buf_cnt - 1)) ? (dma_obj->desc[cnt + 1]) : dma_obj->desc[0]);
-    }
-    ESP_LOGI(TAG, "DMA Malloc info, datalen=blocksize=%d, dma_buf_count=%d", dma_obj->buf_size, buf_cnt);
-    return ESP_OK;
-err:
-    /* Delete DMA buffer if failed to allocate memory */
-    m_i2s_delete_dma_buffer(i2s_num, dma_obj);
-    return ret;
-}
-
-/**
- * @brief   Realloc I2S dma buffer
- *
- * @param   i2s_num     I2S device number
- * @param   dma_obj     DMA object
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_NO_MEM      No memory for I2S tx dma buffer
- */
-static esp_err_t m_i2s_realloc_dma_buffer(i2s_port_t i2s_num, i2s_dma_t *dma_obj)
-{
-    ESP_RETURN_ON_FALSE(dma_obj, ESP_ERR_INVALID_ARG, TAG, "I2S DMA object can't be NULL");
-
-    /* Destroy old dma descriptor and buffer */
-    m_i2s_delete_dma_buffer(i2s_num, dma_obj);
-    /* Alloc new dma descriptor and buffer */
-    ESP_RETURN_ON_ERROR(m_i2s_alloc_dma_buffer(i2s_num, dma_obj), TAG, "Failed to allocate dma buffer");
-
-    return ESP_OK;
-}
-
-/**
- * @brief   I2S destroy the whole DMA object
- *
- * @param   i2s_num     I2S device number
- * @param   dma         Secondary pointer to the DMA object
- * @return
- *      - ESP_OK                I2S DMA buffer has been destroyed successfully
- *      - ESP_ERR_INVALID_ARG   I2S driver has not installed yet
- */
-static esp_err_t m_i2s_destroy_dma_object(i2s_port_t i2s_num, i2s_dma_t **dma)
-{
-    /* Check if DMA truely need destroy */
-    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_ERR_INVALID_ARG, TAG, "I2S not initialized yet");
-    if (!(*dma)) {
-        return ESP_OK;
-    }
-    /* Destroy every descriptor and buffer */
-    m_i2s_delete_dma_buffer(i2s_num, (*dma));
-    /* Destroy descriptor pointer */
-    if ((*dma)->desc) {
-        free((*dma)->desc);
-        (*dma)->desc = NULL;
-    }
-    /* Destroy buffer pointer */
-    if ((*dma)->buf) {
-        free((*dma)->buf);
-        (*dma)->buf = NULL;
-    }
-    /* Delete DMA mux */
-    vSemaphoreDelete((*dma)->mux);
-    /* Delete DMA queue */
-    vQueueDelete((*dma)->queue);
-    /* Free DMA structure */
-    free(*dma);
-    *dma = NULL;
-    ESP_LOGI(TAG, "DMA queue destroyed");
-    return ESP_OK;
-}
-
-/**
- * @brief   Create I2S DMA object
- * @note    This function only create I2S DMA object but will not allocate memory
- *          for DMA descriptor and buffer, call 'i2s_alloc_dma_buffer' additionally to
- *          allocate DMA buffer
- *
- * @param   i2s_num         I2S device number
- * @param   dma             The secondary pointer of DMA object
- * @return
- *      - ESP_OK                The pointer of DMA object
- *      - ESP_ERR_INVALID_ARG   NULL pointer error or DMA object has been created
- *      - ESP_ERR_NO_MEM        No memory for new DMA object
- */
-static esp_err_t m_i2s_create_dma_object(i2s_port_t i2s_num, i2s_dma_t **dma)
-{
-    ESP_RETURN_ON_FALSE(dma, ESP_ERR_INVALID_ARG, TAG, "DMA object secondary pointer is NULL");
-    ESP_RETURN_ON_FALSE((*dma == NULL), ESP_ERR_INVALID_ARG, TAG, "DMA object has been created");
-    uint32_t buf_cnt = p_i2s[i2s_num]->dma_buf_count;
-    /* Allocate new DMA structure */
-    *dma = (i2s_dma_t *) malloc(sizeof(i2s_dma_t));
-    ESP_RETURN_ON_FALSE(*dma, ESP_ERR_NO_MEM, TAG, "DMA object allocate failed");
-    /* Allocate DMA buffer poiter */
-    (*dma)->buf = (char **)heap_caps_calloc(buf_cnt, sizeof(char *), MALLOC_CAP_DMA);
-    if (!(*dma)->buf) {
-        goto err;
-    }
-    /* Allocate secondary pointer of DMA descriptor chain */
-    (*dma)->desc = (lldesc_t **)heap_caps_calloc(buf_cnt, sizeof(lldesc_t *), MALLOC_CAP_DMA);
-    if (!(*dma)->desc) {
-        goto err;
-    }
-    /* Create queue and mutex */
-    (*dma)->queue = xQueueCreate(buf_cnt - 1, sizeof(char *));
-    if (!(*dma)->queue) {
-        goto err;
-    }
-    (*dma)->mux = xSemaphoreCreateMutex();
-    if (!(*dma)->mux) {
-        goto err;
-    }
-
-    return ESP_OK;
-err:
-    ESP_LOGE(TAG, "I2S DMA object create failed, preparing to uninstall");
-    /* Destroy DMA queue if failed to allocate memory */
-    m_i2s_destroy_dma_object(i2s_num, dma);
-    return ESP_ERR_NO_MEM;
-}
-
-/**
- * @brief   Zero the contents of the TX DMA buffer.
- * @note    Pushes zero-byte samples into the TX DMA buffer, until it is full.
- *
- * @param   i2s_num         I2S device number
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_zero_dma_buffer(i2s_port_t i2s_num)
-{
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-
-    /* Clear I2S RX DMA buffer */
-    if (p_i2s[i2s_num]->rx && p_i2s[i2s_num]->rx->buf != NULL && p_i2s[i2s_num]->rx->buf_size != 0) {
-        for (int i = 0; i < p_i2s[i2s_num]->dma_buf_count; i++) {
-            memset(p_i2s[i2s_num]->rx->buf[i], 0, p_i2s[i2s_num]->rx->buf_size);
-        }
-    }
-
-    /* Clear I2S TX DMA buffer */
-    if (p_i2s[i2s_num]->tx && p_i2s[i2s_num]->tx->buf != NULL && p_i2s[i2s_num]->tx->buf_size != 0) {
-        /* Finish to write all tx data */
-        int bytes_left = (p_i2s[i2s_num]->tx->buf_size - p_i2s[i2s_num]->tx->rw_pos) % 4;
-        if (bytes_left) {
-            size_t zero_bytes = 0, bytes_written;
-            m_i2s_write(i2s_num, (void *)&zero_bytes, bytes_left, &bytes_written, portMAX_DELAY);
-        }
-        for (int i = 0; i < p_i2s[i2s_num]->dma_buf_count; i++) {
-            memset(p_i2s[i2s_num]->tx->buf[i], 0, p_i2s[i2s_num]->tx->buf_size);
-        }
-    }
-    return ESP_OK;
-}
-
-/*-------------------------------------------------------------
-                   I2S clock operation
-  -------------------------------------------------------------*/
-#if SOC_I2S_SUPPORTS_APLL
-static esp_err_t m_i2s_set_apll_freq(uint32_t expt_freq, uint32_t *real_freq)
-{
-    uint32_t rtc_xtal_freq = (uint32_t)rtc_clk_xtal_freq_get();
-    ESP_RETURN_ON_FALSE(rtc_xtal_freq, ESP_ERR_INVALID_STATE, TAG, "Get xtal clock frequency failed, it has not been set yet");
-
-    /* Reference formula: apll_freq = xtal_freq * (4 + sdm2 + sdm1/256 + sdm0/65536) / ((o_div + 2) * 2)
-     *                                ----------------------------------------------   -----------------
-     *                                     350 MHz <= Numerator <= 500 MHz                Denominator
-     */
-    int o_div = 0; // range: 0~31
-    int sdm0 = 0;  // range: 0~255
-    int sdm1 = 0;  // range: 0~255
-    int sdm2 = 0;  // range: 0~63
-    /* Firstly try to satisfy the condition that the operation frequency of numerator should be greater than 350 MHz,
-     * i.e. xtal_freq * (4 + sdm2 + sdm1/256 + sdm0/65536) >= 350 MHz, '+1' in the following code is to get the ceil value.
-     * With this condition, as we know the 'o_div' can't be greater than 31, then we can calculate the APLL minimum support frequency is
-     * 350 MHz / ((31 + 2) * 2) = 5303031 Hz (for ceil) */
-    o_div = (int)(SOC_APLL_MULTIPLIER_OUT_MIN_HZ / (float)(expt_freq * 2) + 1) - 2;
-    ESP_RETURN_ON_FALSE(o_div < 32, ESP_ERR_INVALID_ARG, TAG, "Expected frequency is too small");
-    if (o_div < 0) {
-        /* Try to satisfy the condition that the operation frequency of numerator should be smaller than 500 MHz,
-         * i.e. xtal_freq * (4 + sdm2 + sdm1/256 + sdm0/65536) <= 500 MHz, we need to get the floor value in the following code.
-         * With this condition, as we know the 'o_div' can't be smaller than 0, then we can calculate the APLL maximum support frequency is
-         * 500 MHz / ((0 + 2) * 2) = 125000000 Hz */
-        o_div = (int)(SOC_APLL_MULTIPLIER_OUT_MAX_HZ / (float)(expt_freq * 2)) - 2;
-        ESP_RETURN_ON_FALSE(o_div >= 0, ESP_ERR_INVALID_ARG, TAG, "Expected frequency is too small");
-    }
-    // sdm2 = (int)(((o_div + 2) * 2) * apll_freq / xtal_freq) - 4
-    sdm2 = (int)(((o_div + 2) * 2 * expt_freq) / (rtc_xtal_freq * 1000000)) - 4;
-    // numrator = (((o_div + 2) * 2) * apll_freq / xtal_freq) - 4 - sdm2
-    float numrator = (((o_div + 2) * 2 * expt_freq) / ((float)rtc_xtal_freq * 1000000)) - 4 - sdm2;
-    // If numrator is bigger than 255/256 + 255/65536 + (1/65536)/2 = 1 - (1 / 65536)/2, carry bit to sdm2
-    if (numrator > 1.0 - (1.0 / 65536.0) / 2.0) {
-        sdm2++;
-    }
-    // If numrator is smaller than (1/65536)/2, keep sdm0 = sdm1 = 0, otherwise calculate sdm0 and sdm1
-    else if (numrator > (1.0 / 65536.0) / 2.0) {
-        // Get the closest sdm1
-        sdm1 = (int)(numrator * 65536.0 + 0.5) / 256;
-        // Get the closest sdm0
-        sdm0 = (int)(numrator * 65536.0 + 0.5) % 256;
-    }
-    rtc_clk_apll_enable(true, sdm0, sdm1, sdm2, o_div);
-    *real_freq = (uint32_t)(rtc_xtal_freq * 1000000 * (4 + sdm2 + (float)sdm1/256.0 + (float)sdm0/65536.0) / (((float)o_div + 2) * 2));
-
-    return ESP_OK;
-}
-#endif
-/**
- * @brief   Config I2S source clock and get its frequency
- *
- * @param   i2s_num         I2S device number
- * @param   use_apll        Whether use apll, only take effect when chip supports
- * @param   mclk            module clock
- *
- * @return
- *      - 0                 use I2S_CLK_APLL as clock source, no I2S system clock to set
- *      - I2S_LL_BASE_CLK   use I2S_CLK_D2CLK as clock source, return APB clock frequency
- */
-static uint32_t m_i2s_config_source_clock(i2s_port_t i2s_num, bool use_apll, uint32_t mclk)
-{
-#if SOC_I2S_SUPPORTS_APLL
-    if (use_apll) {
-        /* Calculate the expected APLL  */
-        int div = (int)((SOC_APLL_MIN_HZ / mclk) + 1);
-        /* apll_freq = mclk * div
-         * when div = 1, hardware will still divide 2
-         * when div = 0, the final mclk will be unpredictable
-         * So the div here should be at least 2 */
-        div = div < 2 ? 2 : div;
-        uint32_t expt_freq = mclk * div;
-        /* Set APLL coefficients to the given frequency */
-        uint32_t real_freq = 0;
-        esp_err_t ret = m_i2s_set_apll_freq(expt_freq, &real_freq);
-        if (ret != ESP_OK) {
-            ESP_LOGE(TAG, "set APLL coefficients failed");
-            return 0;
-        }
-        ESP_LOGI(TAG, "APLL expected frequency is %d Hz, real frequency is %d Hz", expt_freq, real_freq);
-        /* Set I2S_APLL as I2S module clock source */
-        i2s_hal_set_clock_src(&(p_i2s[i2s_num]->hal), I2S_CLK_APLL);
-        /* In APLL mode, there is no sclk but only mclk, so return 0 here to indicate APLL mode */
-        return real_freq;
-    }
-    /* Set I2S_D2CLK (160M) as default I2S module clock source */
-    i2s_hal_set_clock_src(&(p_i2s[i2s_num]->hal), I2S_CLK_D2CLK);
-    return I2S_LL_BASE_CLK;
-#else
-    if (use_apll) {
-        ESP_LOGW(TAG, "APLL not supported on current chip, use I2S_CLK_D2CLK as default clock source");
-    }
-    /* Set I2S_D2CLK (160M) as I2S module clock source */
-    i2s_hal_set_clock_src(&(p_i2s[i2s_num]->hal), I2S_CLK_D2CLK);
-    return I2S_LL_BASE_CLK;
-#endif
-}
-
-#if _SOC_I2S_SUPPORTS_ADC || _SOC_I2S_SUPPORTS_DAC
-/**
- * @brief   I2S calculate clock for built-in ADC/DAC mode
- *
- * @param   i2s_num         I2S device number
- * @param   clk_cfg         Struct to restore clock confiuration
- * @return
- *      - ESP_OK                Get clock success
- *      - ESP_ERR_INVALID_ARG   Invalid args
- */
-static esp_err_t m_i2s_calculate_adc_dac_clock(int i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
-{
-    ESP_RETURN_ON_FALSE(clk_cfg, ESP_ERR_INVALID_ARG, TAG, "input clk_cfg is NULL");
-    ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->hal_cfg.mode & (I2S_MODE_DAC_BUILT_IN | I2S_MODE_ADC_BUILT_IN), ESP_ERR_INVALID_ARG, TAG, "current mode is not built-in ADC/DAC");
-
-    /* Set I2S bit clock */
-    clk_cfg->bclk = p_i2s[i2s_num]->hal_cfg.sample_rate * I2S_LL_AD_BCK_FACTOR;
-    /* Set I2S bit clock default division */
-    clk_cfg->bclk_div = p_i2s[i2s_num]->hal_cfg.chan_bits;
-    /* If fixed_mclk and use_apll are set, use fixed_mclk as mclk frequency, otherwise calculate by mclk = sample_rate * multiple */
-    clk_cfg->mclk = (p_i2s[i2s_num]->use_apll && p_i2s[i2s_num]->fixed_mclk) ?
-                    p_i2s[i2s_num]->fixed_mclk : clk_cfg->bclk * clk_cfg->bclk_div;
-    /* Calculate bclk_div = mclk / bclk */
-    clk_cfg->bclk_div = clk_cfg->mclk / clk_cfg->bclk;
-    /* Get I2S system clock by config source clock */
-    clk_cfg->sclk = m_i2s_config_source_clock(i2s_num, p_i2s[i2s_num]->use_apll, clk_cfg->mclk);
-    /* Get I2S master clock rough division, later will calculate the fine division parameters in HAL */
-    clk_cfg->mclk_div = clk_cfg->sclk / clk_cfg->mclk;
-
-    /* Check if the configuration is correct */
-    ESP_RETURN_ON_FALSE(clk_cfg->mclk <= clk_cfg->sclk, ESP_ERR_INVALID_ARG, TAG, "sample rate is too large");
-
-    return ESP_OK;
-}
-#endif // _SOC_I2S_SUPPORTS_ADC || _SOC_I2S_SUPPORTS_DAC
-
-#if SOC_I2S_SUPPORTS_PDM_TX
-/**
- * @brief   I2S calculate clock for PDM tx mode
- *
- * @param   i2s_num         I2S device number
- * @param   clk_cfg         Struct to restore clock confiuration
- * @return
- *      - ESP_OK                Get clock success
- *      - ESP_ERR_INVALID_ARG   Invalid args
- */
-static esp_err_t m_i2s_calculate_pdm_tx_clock(int i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
-{
-    ESP_RETURN_ON_FALSE(clk_cfg, ESP_ERR_INVALID_ARG, TAG, "input clk_cfg is NULL");
-    ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM, ESP_ERR_INVALID_ARG, TAG, "current mode is not PDM");
-
-    int fp = i2s_hal_get_tx_pdm_fp(&(p_i2s[i2s_num]->hal));
-    int fs = i2s_hal_get_tx_pdm_fs(&(p_i2s[i2s_num]->hal));
-    /* Set I2S bit clock */
-    clk_cfg->bclk = p_i2s[i2s_num]->hal_cfg.sample_rate * I2S_LL_PDM_BCK_FACTOR * fp / fs;
-    /* Set I2S bit clock default division */
-    clk_cfg->bclk_div = 8;
-    /* If fixed_mclk and use_apll are set, use fixed_mclk as mclk frequency, otherwise calculate by mclk = sample_rate * multiple */
-    clk_cfg->mclk = (p_i2s[i2s_num]->use_apll && p_i2s[i2s_num]->fixed_mclk) ?
-                    p_i2s[i2s_num]->fixed_mclk : clk_cfg->bclk * clk_cfg->bclk_div;
-    /* Calculate bclk_div = mclk / bclk */
-    clk_cfg->bclk_div = clk_cfg->mclk / clk_cfg->bclk;
-    /* Get I2S system clock by config source clock */
-    clk_cfg->sclk = m_i2s_config_source_clock(i2s_num, p_i2s[i2s_num]->use_apll, clk_cfg->mclk);
-    /* Get I2S master clock rough division, later will calculate the fine division parameters in HAL */
-    clk_cfg->mclk_div = clk_cfg->sclk / clk_cfg->mclk;
-
-    /* Check if the configuration is correct */
-    ESP_RETURN_ON_FALSE(clk_cfg->mclk <= clk_cfg->sclk, ESP_ERR_INVALID_ARG, TAG, "sample rate is too large");
-
-    return ESP_OK;
-}
-#endif  // SOC_I2S_SUPPORTS_PDM_TX
-
-#if SOC_I2S_SUPPORTS_PDM_RX
-/**
- * @brief   I2S calculate clock for PDM rx mode
- *
- * @param   i2s_num         I2S device number
- * @param   clk_cfg         Struct to restore clock confiuration
- * @return
- *      - ESP_OK                Get clock success
- *      - ESP_ERR_INVALID_ARG   Invalid args
- */
-static esp_err_t m_i2s_calculate_pdm_rx_clock(int i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
-{
-    ESP_RETURN_ON_FALSE(clk_cfg, ESP_ERR_INVALID_ARG, TAG, "input clk_cfg is NULL");
-    ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM, ESP_ERR_INVALID_ARG, TAG, "current mode is not PDM");
-
-    i2s_pdm_dsr_t dsr;
-    i2s_hal_get_rx_pdm_dsr(&(p_i2s[i2s_num]->hal), &dsr);
-    /* Set I2S bit clock */
-    clk_cfg->bclk = p_i2s[i2s_num]->hal_cfg.sample_rate * I2S_LL_PDM_BCK_FACTOR * (dsr == I2S_PDM_DSR_16S ? 2 : 1);
-    /* Set I2S bit clock default division */
-    clk_cfg->bclk_div = 8;
-    /* If fixed_mclk and use_apll are set, use fixed_mclk as mclk frequency, otherwise calculate by mclk = sample_rate * multiple */
-    clk_cfg->mclk = (p_i2s[i2s_num]->use_apll && p_i2s[i2s_num]->fixed_mclk) ?
-                    p_i2s[i2s_num]->fixed_mclk : clk_cfg->bclk * clk_cfg->bclk_div;
-    /* Calculate bclk_div = mclk / bclk */
-    clk_cfg->bclk_div = clk_cfg->mclk / clk_cfg->bclk;
-    /* Get I2S system clock by config source clock */
-    clk_cfg->sclk = m_i2s_config_source_clock(i2s_num, p_i2s[i2s_num]->use_apll, clk_cfg->mclk);
-    /* Get I2S master clock rough division, later will calculate the fine division parameters in HAL */
-    clk_cfg->mclk_div = clk_cfg->sclk / clk_cfg->mclk;
-
-    /* Check if the configuration is correct */
-    ESP_RETURN_ON_FALSE(clk_cfg->mclk <= clk_cfg->sclk, ESP_ERR_INVALID_ARG, TAG, "sample rate is too large");
-    ESP_LOGD(TAG, "[sclk] %d [mclk] %d [mclk_div] %d [bclk] %d [bclk_div] %d",
-             clk_cfg->sclk, clk_cfg->mclk, clk_cfg->mclk_div, clk_cfg->bclk, clk_cfg->bclk_div);
-
-    return ESP_OK;
-}
-#endif // SOC_I2S_SUPPORTS_PDM_RX
-
-/**
- * @brief   I2S calculate clock for common mode (philip, MSB, PCM)
- *
- * @param   i2s_num         I2S device number
- * @param   clk_cfg         Struct to restore clock confiuration
- * @return
- *      - ESP_OK                Get clock success
- *      - ESP_ERR_INVALID_ARG   Invalid args
- */
-static esp_err_t m_i2s_calculate_common_clock(int i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
-{
-    ESP_RETURN_ON_FALSE(clk_cfg, ESP_ERR_INVALID_ARG, TAG, "input clk_cfg is NULL");
-
-    uint32_t rate     = p_i2s[i2s_num]->hal_cfg.sample_rate;
-    uint32_t chan_num = p_i2s[i2s_num]->hal_cfg.total_chan < 2 ? 2 : p_i2s[i2s_num]->hal_cfg.total_chan;
-    uint32_t chan_bit = p_i2s[i2s_num]->hal_cfg.chan_bits;
-    uint32_t multi;
-    /* Calculate multiple */
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_MASTER || p_i2s[i2s_num]->use_apll) {
-        multi = p_i2s[i2s_num]->mclk_multiple ? p_i2s[i2s_num]->mclk_multiple : I2S_MCLK_MULTIPLE_256;
-    } else {
-        /* Only need to set the multiple of mclk to sample rate for MASTER mode,
-         * because BCK and WS clock are provided by the external codec in SLAVE mode.
-         * The multiple should be big enough to get a high module clock which could detect the edges of externel clock more accurately,
-         * otherwise the data we receive or send would get a large latency and go wrong due to the slow module clock.
-         * But on ESP32 and ESP32S2, due to the different clock work mode in hardware,
-         * their multiple should be set to an appropriate range according to the sample bits,
-         * and this particular multiple finally aims at guaranteeing the bclk_div not smaller than 8,
-         * if not, the I2S may can't send data or send wrong data.
-         * Here use 'SOC_I2S_SUPPORTS_TDM' to differentialize other chips with ESP32 and ESP32S2.
-         */
-#if SOC_I2S_SUPPORTS_TDM
-        multi = I2S_LL_BASE_CLK / rate;
-#else
-        multi =  64 * chan_bit;
-#endif
-    }
-    /* Set I2S bit clock */
-    clk_cfg->bclk = rate * chan_num * chan_bit;
-    /* If fixed_mclk and use_apll are set, use fixed_mclk as mclk frequency, otherwise calculate by mclk = sample_rate * multiple */
-    clk_cfg->mclk = (p_i2s[i2s_num]->use_apll && p_i2s[i2s_num]->fixed_mclk) ?
-                    p_i2s[i2s_num]->fixed_mclk : (rate * multi);
-    /* Calculate bclk_div = mclk / bclk */
-    clk_cfg->bclk_div = clk_cfg->mclk / clk_cfg->bclk;
-    /* Get I2S system clock by config source clock */
-    clk_cfg->sclk = m_i2s_config_source_clock(i2s_num, p_i2s[i2s_num]->use_apll, clk_cfg->mclk);
-    /* Get I2S master clock rough division, later will calculate the fine division parameters in HAL */
-    clk_cfg->mclk_div = clk_cfg->sclk / clk_cfg->mclk;
-
-    /* Check if the configuration is correct */
-    ESP_RETURN_ON_FALSE(clk_cfg->mclk <= clk_cfg->sclk, ESP_ERR_INVALID_ARG, TAG, "sample rate is too large");
-
-    return ESP_OK;
-}
-
-/**
- * @brief   I2S calculate clocks according to the selected I2S mode
- *
- * @param   i2s_num     I2S device number
- * @param   clk_cfg         Struct to restore clock confiuration
- * @return
- *      - ESP_OK                Claculate clock success
- *      - ESP_ERR_INVALID_ARG   Invalid args
- */
-static esp_err_t m_i2s_calculate_clock(i2s_port_t i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
-{
-    /* Calculate clock for ADC mode */
-#if _SOC_I2S_SUPPORTS_ADC
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_ADC_BUILT_IN) {
-        ESP_RETURN_ON_ERROR(m_i2s_calculate_adc_dac_clock(i2s_num, clk_cfg), TAG, "ADC clock calculate failed");
-        return ESP_OK;
-    }
-#endif // _SOC_I2S_SUPPORTS_ADC
-    /* Calculate clock for DAC mode */
-#if _SOC_I2S_SUPPORTS_DAC
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_DAC_BUILT_IN) {
-        ESP_RETURN_ON_ERROR(m_i2s_calculate_adc_dac_clock(i2s_num, clk_cfg), TAG, "DAC clock calculate failed");
-        return ESP_OK;
-    }
-#endif // _SOC_I2S_SUPPORTS_DAC
-
-    /* Calculate clock for PDM mode */
-#if SOC_I2S_SUPPORTS_PDM_TX || SOC_I2S_SUPPORTS_PDM_RX
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM) {
-#if SOC_I2S_SUPPORTS_PDM_TX
-        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-            ESP_RETURN_ON_ERROR(m_i2s_calculate_pdm_tx_clock(i2s_num, clk_cfg), TAG, "PDM TX clock calculate failed");
-        }
-#endif // SOC_I2S_SUPPORTS_PDM_TX
-#if SOC_I2S_SUPPORTS_PDM_RX
-        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-            ESP_RETURN_ON_ERROR(m_i2s_calculate_pdm_rx_clock(i2s_num, clk_cfg), TAG, "PDM RX clock calculate failed");
-        }
-#endif // SOC_I2S_SUPPORTS_PDM_RX
-        return ESP_OK;
-    }
-#endif // SOC_I2S_SUPPORTS_PDM_TX || SOC_I2S_SUPPORTS_PDM_RX
-
-    /* Calculate clock for common mode */
-    ESP_RETURN_ON_ERROR(m_i2s_calculate_common_clock(i2s_num, clk_cfg), TAG, "Common clock calculate failed");
-    return ESP_OK;
-}
-
-/*-------------------------------------------------------------
-                   I2S configuration
-  -------------------------------------------------------------*/
-#if SOC_I2S_SUPPORTS_TDM
-/**
- * @brief Get max actived channel number
- *
- * @param chan_mask I2S channel mask that indicates which channels are actived
- * @return
- *      - Max actived channel number
- */
-static uint32_t m_i2s_get_max_channel_num(i2s_channel_t chan_mask)
-{
-    uint32_t max_chan = 0;
-    uint32_t channel = chan_mask >> 16;
-    for (int i = 0; channel && i < 16; i++, channel >>= 1) {
-        if (channel & 0x01) {
-            max_chan = i + 1;
-        }
-    }
-    /* Can't be smaller than 2 */
-    return max_chan < 2 ? 2 : max_chan;
-}
-#endif
-
-/**
- * @brief Get active channel number according to channel format
- * @note  In 'I2S_CHANNEL_FMT_MULTIPLE' format, this function will check
- *        'total_chan' and fix it if it is not correct.
- *
- * @param hal_cfg   [input/output] I2S hal configuration structer
- * @return
- *      - Active channel number
- */
-static uint32_t m_i2s_get_active_channel_num(const i2s_hal_config_t *hal_cfg)
-{
-    switch (hal_cfg->chan_fmt) {
-    case I2S_CHANNEL_FMT_RIGHT_LEFT: //fall through
-    case I2S_CHANNEL_FMT_ALL_RIGHT:  //fall through
-    case I2S_CHANNEL_FMT_ALL_LEFT:
-        return 2;
-    case I2S_CHANNEL_FMT_ONLY_RIGHT: //fall through
-    case I2S_CHANNEL_FMT_ONLY_LEFT:
-        return 1;
-#if SOC_I2S_SUPPORTS_TDM
-    case I2S_CHANNEL_FMT_MULTIPLE: {
-        uint32_t num = 0;
-        uint32_t chan_mask = hal_cfg->chan_mask >> 16;
-        for (int i = 0; chan_mask && i < 16; i++, chan_mask >>= 1) {
-            if (chan_mask & 0x01) {
-                num++;
-            }
-        }
-        return num;
-    }
-#endif
-    default:
-        return 0;
-    }
-}
-
-#if _SOC_I2S_SUPPORTS_DAC
-/**
- * @brief   I2S set built-in DAC mode
- *
- * @param   dac_mode    DAC mode
- * @return
- *      - ESP_OK                Set DAC success
- *      - ESP_ERR_INVALID_ARG   Wrong DAC mode
- */
-esp_err_t m_i2s_set_dac_mode(i2s_dac_mode_t dac_mode)
-{
-    ESP_RETURN_ON_FALSE((dac_mode < I2S_DAC_CHANNEL_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s dac mode error");
-    if (dac_mode == I2S_DAC_CHANNEL_DISABLE) {
-        dac_output_disable(DAC_CHANNEL_1);
-        dac_output_disable(DAC_CHANNEL_2);
-        dac_i2s_disable();
-    } else {
-        dac_i2s_enable();
-    }
-
-    if (dac_mode & I2S_DAC_CHANNEL_RIGHT_EN) {
-        //DAC1, right channel
-        dac_output_enable(DAC_CHANNEL_1);
-    }
-    if (dac_mode & I2S_DAC_CHANNEL_LEFT_EN) {
-        //DAC2, left channel
-        dac_output_enable(DAC_CHANNEL_2);
-    }
-    return ESP_OK;
-}
-#endif // _SOC_I2S_SUPPORTS_DAC
-
-#if _SOC_I2S_SUPPORTS_ADC
-/**
- * @brief   ADC mode recover
- *
- * @return
- *      - ESP_OK ADC            Recover success
- *      - ESP_ERR_INVALID_ARG   ADC not initialized yet
- */
-static esp_err_t m__i2s_adc_mode_recover(void)
-{
-    ESP_RETURN_ON_FALSE(((_i2s_adc_unit != -1) && (_i2s_adc_channel != -1)), ESP_ERR_INVALID_ARG, TAG, "i2s ADC recover error, not initialized...");
-    return adc_i2s_mode_init(_i2s_adc_unit, _i2s_adc_channel);
-}
-
-/**
- * @brief   I2S set adc mode
- *
- * @param   adc_unit    ADC unit number
- * @param   adc_channel ADC channel
- * @return
- *      - ESP_OK ADC            Recover success
- *      - ESP_ERR_INVALID_ARG   ADC not initialized yet
- */
-esp_err_t m_i2s_set_adc_mode(adc_unit_t adc_unit, adc1_channel_t adc_channel)
-{
-    ESP_RETURN_ON_FALSE((adc_unit < ADC_UNIT_2), ESP_ERR_INVALID_ARG, TAG, "i2s ADC unit error, only support ADC1 for now");
-    // For now, we only support SAR ADC1.
-    _i2s_adc_unit = adc_unit;
-    _i2s_adc_channel = adc_channel;
-    return adc_i2s_mode_init(adc_unit, adc_channel);
-}
-
-/**
- * @brief   I2S enable ADC mode
- *
- * @param   i2s_num         I2S device number
- * @return
- *      - ESP_OK                Enable ADC success
- *      - ESP_ERR_INVALID_ARG   Invalid argument
- *      - ESP_ERR_INVALID_STATE Current I2S mode is not built-in ADC
- */
-esp_err_t m_i2s_adc_enable(i2s_port_t i2s_num)
-{
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num] != NULL), ESP_ERR_INVALID_STATE, TAG, "Not initialized yet");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_ADC_BUILT_IN), ESP_ERR_INVALID_STATE, TAG, "i2s built-in adc not enabled");
-
-    adc1_dma_mode_acquire();
-    m__i2s_adc_mode_recover();
-    m_i2s_rx_reset(i2s_num);
-    return m_i2s_set_clk(i2s_num, p_i2s[i2s_num]->hal_cfg.sample_rate, p_i2s[i2s_num]->hal_cfg.sample_bits, p_i2s[i2s_num]->hal_cfg.active_chan);
-}
-
-/**
- * @brief   I2S disable ADC
- *
- * @param   i2s_num         I2S device number
- * @return
- *      - ESP_OK        I2S ADC mode successfully disabled
- *      - ESP_ERR_INVALID_ARG   Invalid argument
- *      - ESP_ERR_INVALID_STATE Current I2S mode is not built-in ADC
- */
-esp_err_t m_i2s_adc_disable(i2s_port_t i2s_num)
-{
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num] != NULL), ESP_ERR_INVALID_STATE, TAG, "Not initialized yet");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_ADC_BUILT_IN), ESP_ERR_INVALID_STATE, TAG, "i2s built-in adc not enabled");
-
-    i2s_hal_stop_rx(&(p_i2s[i2s_num]->hal));
-    adc1_lock_release();
-    return ESP_OK;
-}
-#endif
-
-/**
- * @brief   Set sample rate used for I2S RX and TX.
- * @note    The bit clock rate is determined by the sample rate and i2s_config_t configuration parameters (number of channels, bits_per_sample).
- *          `bit_clock = rate * (number of channels) * bits_per_sample`
- *
- * @param   i2s_num  I2S device number
- * @param   rate I2S sample rate (ex: 8000, 44100...)
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- */
-esp_err_t m_i2s_set_sample_rates(i2s_port_t i2s_num, uint32_t rate)
-{
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.sample_bits > 0), ESP_ERR_INVALID_ARG, TAG, "sample bits not set");
-    return m_i2s_set_clk(i2s_num, rate, p_i2s[i2s_num]->hal_cfg.sample_bits, p_i2s[i2s_num]->hal_cfg.active_chan);
-}
-
-#if SOC_I2S_SUPPORTS_PCM
-/**
- * @brief   Configure I2S a/u-law decompress or compress
- * @note    This function should be called after i2s driver installed
- *          Only take effect when the i2s 'communication_format' is set to 'I2S_COMM_FORMAT_STAND_PCM_SHORT' or 'I2S_COMM_FORMAT_STAND_PCM_LONG'
- *
- * @param   i2s_num  I2S_NUM_0
- * @param   pcm_cfg  Including mode selection and a/u-law decompress or compress configuration paramater
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_pcm_config(i2s_port_t i2s_num, const i2s_pcm_cfg_t *pcm_cfg)
-{
-    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_FAIL, TAG, "i2s has not installed yet");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.comm_fmt & I2S_COMM_FORMAT_STAND_PCM_SHORT),
-                        ESP_ERR_INVALID_ARG, TAG, "i2s communication mode is not PCM mode");
-
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-        xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
-    }
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-        xSemaphoreTake(p_i2s[i2s_num]->rx->mux, (portTickType)portMAX_DELAY);
-    }
-
-    i2s_stop(i2s_num);
-    I2S_ENTER_CRITICAL(i2s_num);
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-        i2s_hal_tx_pcm_cfg(&(p_i2s[i2s_num]->hal), pcm_cfg->pcm_type);
-    } else if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-        i2s_hal_rx_pcm_cfg(&(p_i2s[i2s_num]->hal), pcm_cfg->pcm_type);
-    }
-    I2S_EXIT_CRITICAL(i2s_num);
-    i2s_start(i2s_num);
-
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-        xSemaphoreGive(p_i2s[i2s_num]->tx->mux);
-    }
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-        xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
-    }
-
-    return ESP_OK;
-}
-#endif
-
-#if SOC_I2S_SUPPORTS_PDM_RX
-/**
- * @brief   Set PDM mode down-sample rate
- *          In PDM RX mode, there would be 2 rounds of downsample process in hardware.
- *          In the first downsample process, the sampling number can be 16 or 8.
- *          In the second downsample process, the sampling number is fixed as 8.
- *          So the clock frequency in PDM RX mode would be (fpcm * 64) or (fpcm * 128) accordingly.
- * @note    After calling this function, it would call i2s_set_clk inside to update the clock frequency.
- *          Please call this function after I2S driver has been initialized.
- *
- * @param   i2s_num I2S device number
- * @param   downsample i2s RX down sample rate for PDM mode.
- * @return
- *     - ESP_OK Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- */
-esp_err_t m_i2s_set_pdm_rx_down_sample(i2s_port_t i2s_num, i2s_pdm_dsr_t downsample)
-{
-    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_FAIL, TAG, "i2s has not installed yet");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM), ESP_ERR_INVALID_ARG, TAG, "i2s mode is not PDM mode");
-
-    xSemaphoreTake(p_i2s[i2s_num]->rx->mux, (portTickType)portMAX_DELAY);
-    m_i2s_stop(i2s_num);
-    i2s_hal_set_rx_pdm_dsr(&(p_i2s[i2s_num]->hal), downsample);
-    m_i2s_start(i2s_num);
-    xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
-    return m_i2s_set_clk(i2s_num, p_i2s[i2s_num]->hal_cfg.sample_rate, p_i2s[i2s_num]->hal_cfg.sample_bits, p_i2s[i2s_num]->hal_cfg.active_chan);
-}
-#endif
-
-#if SOC_I2S_SUPPORTS_PDM_TX
-/**
- * @brief   Set TX PDM mode up-sample rate
- * @note    If you have set PDM mode while calling 'i2s_driver_install',
- *          default PDM TX upsample parameters have already been set,
- *          no need to call this function again if you don't have to change the default configuration
- *
- * @param   i2s_num         I2S device number
- * @param   upsample_cfg    Set I2S PDM up-sample rate configuration
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- */
-esp_err_t m_i2s_set_pdm_tx_up_sample(i2s_port_t i2s_num, const i2s_pdm_tx_upsample_cfg_t *upsample_cfg)
-{
-    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_FAIL, TAG, "i2s has not installed yet");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM), ESP_ERR_INVALID_ARG, TAG, "i2s mode is not PDM mode");
-
-    xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
-    m_i2s_stop(i2s_num);
-    i2s_hal_set_tx_pdm_fpfs(&(p_i2s[i2s_num]->hal), upsample_cfg->fp, upsample_cfg->fs);
-    m_i2s_start(i2s_num);
-    xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
-    return m_i2s_set_clk(i2s_num, upsample_cfg->sample_rate, p_i2s[i2s_num]->hal_cfg.sample_bits, p_i2s[i2s_num]->hal_cfg.active_chan);
-}
-#endif
-
-/**
- * @brief   I2S check the validity of configuration
- *
- * @param   i2s_num     I2S device number
- * @param   cfg         I2S HAL configuration
- * @return
- *      - ESP_OK                I2S configuration is valid
- *      - ESP_ERR_INVALID_ARG   I2S configuration is invalid
- */
-static esp_err_t m_i2s_check_cfg_validity(i2s_port_t i2s_num, i2s_hal_config_t *cfg)
-{
-#if SOC_I2S_SUPPORTS_PDM_TX || SOC_I2S_SUPPORTS_PDM_RX
-    /* Check PDM mode */
-    if (cfg->mode & I2S_MODE_PDM) {
-        ESP_RETURN_ON_FALSE(i2s_num == I2S_NUM_0, ESP_ERR_INVALID_ARG, TAG, "I2S PDM mode only support on I2S0");
-#if !SOC_I2S_SUPPORTS_PDM_TX
-        ESP_RETURN_ON_FALSE(!(cfg->mode & I2S_MODE_TX), ESP_ERR_INVALID_ARG, TAG, "PDM does not support TX on this chip");
-#endif // SOC_I2S_SUPPORTS_PDM_TX
-#if !SOC_I2S_SUPPORTS_PDM_RX
-        ESP_RETURN_ON_FALSE(!(cfg->mode & I2S_MODE_RX), ESP_ERR_INVALID_ARG, TAG, "PDM does not support RX on this chip");
-#endif // SOC_I2S_SUPPORTS_PDM_RX
-    }
-#else
-    ESP_RETURN_ON_FALSE(!(cfg->mode & I2S_MODE_PDM), ESP_ERR_INVALID_ARG, TAG, "I2S PDM mode not supported on current chip");
-#endif // SOC_I2S_SUPPORTS_PDM_TX || SOC_I2S_SUPPORTS_PDM_RX
-
-#if _SOC_I2S_SUPPORTS_ADC || _SOC_I2S_SUPPORTS_DAC
-    /* Check built-in ADC/DAC mode */
-    if (cfg->mode & (I2S_MODE_ADC_BUILT_IN | I2S_MODE_DAC_BUILT_IN)) {
-        ESP_RETURN_ON_FALSE(i2s_num == I2S_NUM_0, ESP_ERR_INVALID_ARG, TAG, "I2S built-in ADC/DAC only support on I2S0");
-    }
-#else
-    /* Check the transmit/receive mode */
-    ESP_RETURN_ON_FALSE((cfg->mode & I2S_MODE_TX) || (cfg->mode & I2S_MODE_RX), ESP_ERR_INVALID_ARG, TAG, "I2S no TX/RX mode selected");
-    /* Check communication format */
-    ESP_RETURN_ON_FALSE(cfg->comm_fmt && (cfg->comm_fmt < I2S_COMM_FORMAT_STAND_MAX), ESP_ERR_INVALID_ARG, TAG, "invalid communication formats");
-#endif // _SOC_I2S_SUPPORTS_ADC || _SOC_I2S_SUPPORTS_DAC
-
-    return ESP_OK;
-}
-
-static void m_i2s_tx_set_clk_and_channel(i2s_port_t i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
-{
-    i2s_hal_tx_clock_config(&(p_i2s[i2s_num]->hal), clk_cfg);
-    i2s_hal_set_tx_sample_bit(&(p_i2s[i2s_num]->hal), p_i2s[i2s_num]->hal_cfg.chan_bits, p_i2s[i2s_num]->hal_cfg.sample_bits);
-    i2s_hal_tx_set_channel_style(&(p_i2s[i2s_num]->hal), &(p_i2s[i2s_num]->hal_cfg));
-}
-
-static void m_i2s_rx_set_clk_and_channel(i2s_port_t i2s_num, i2s_hal_clock_cfg_t *clk_cfg)
-{
-    i2s_hal_rx_clock_config(&(p_i2s[i2s_num]->hal), clk_cfg);
-    i2s_hal_set_rx_sample_bit(&(p_i2s[i2s_num]->hal), p_i2s[i2s_num]->hal_cfg.chan_bits, p_i2s[i2s_num]->hal_cfg.sample_bits);
-    i2s_hal_rx_set_channel_style(&(p_i2s[i2s_num]->hal), &(p_i2s[i2s_num]->hal_cfg));
-}
-
-/**
- * @brief   Get clock set on particular port number.
- *
- * @param   i2s_num         I2S device number
- * @return
- *      - sample rate
- */
-float m_i2s_get_clk(i2s_port_t i2s_num)
-{
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    return (float)p_i2s[i2s_num]->hal_cfg.sample_rate;
-}
-
-/**
- * @brief   Set clock & bit width used for I2S RX and TX.
- *          Similar to i2s_set_sample_rates(), but also sets bit width.
- *
- * 1. stop i2s
- * 2. calculate mclk, bck, bck_factor
- * 3. set clock configurations
- * 4. realloc dma buffer if DMA buffer size changed
- * 5. start i2s
- *
- * @param   i2s_num     I2S device number
- * @param   rate        I2S sample rate (ex: 8000, 44100...)
- * @param   bits_cfg    I2S bits configuration
- *             the low 16 bits is for data bits per sample in one channel (see 'i2s_bits_per_sample_t')
- *             the high 16 bits is for total bits in one channel (see 'i2s_bits_per_chan_t')
- *             high 16bits =0 means same as the bits per sample.
- * @param   ch          I2S channel, (I2S_CHANNEL_MONO, I2S_CHANNEL_STEREO or specific channel in TDM mode)
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- */
-esp_err_t m_i2s_set_clk(i2s_port_t i2s_num, uint32_t rate, uint32_t bits_cfg, i2s_channel_t ch)
-{
-    esp_err_t ret = ESP_OK;
-
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_ERR_INVALID_ARG, TAG, "I2S%d has not installed yet", i2s_num);
-
-    i2s_hal_config_t *cfg = &p_i2s[i2s_num]->hal_cfg;
-
-    /* Acquire the lock before stop i2s, otherwise reading/writing operation will stuck on receiving the message queue from interrupt */
-    if (cfg->mode & I2S_MODE_TX) {
-        xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
-    }
-    if (cfg->mode & I2S_MODE_RX) {
-        xSemaphoreTake(p_i2s[i2s_num]->rx->mux, (portTickType)portMAX_DELAY);
-    }
-
-    /* Stop I2S */
-    m_i2s_stop(i2s_num);
-
-    /* If not the first time, update configuration */
-    if (p_i2s[i2s_num]->last_buf_size) {
-        cfg->sample_rate = rate;
-        cfg->sample_bits = bits_cfg & 0xFFFF;
-        cfg->chan_bits = (bits_cfg >> 16) > cfg->sample_bits ? (bits_cfg >> 16) : cfg->sample_bits;
-#if SOC_I2S_SUPPORTS_TDM
-        if (ch & I2S_CHANNEL_MONO) {
-            if (ch >> 16) {
-                cfg->chan_fmt = I2S_CHANNEL_FMT_MULTIPLE;
-                cfg->chan_mask = 1 << __builtin_ctz(ch & 0xFFFF0000); // mono the minimun actived slot
-                cfg->total_chan = m_i2s_get_max_channel_num(ch);
-            } else {
-                if (p_i2s[i2s_num]->init_chan_fmt == I2S_CHANNEL_FMT_ONLY_LEFT) {
-                    cfg->chan_mask = I2S_TDM_ACTIVE_CH1; // left slot mono
-                    cfg->chan_fmt = I2S_CHANNEL_FMT_ONLY_LEFT;
-                } else {
-                    cfg->chan_mask = I2S_TDM_ACTIVE_CH0; // right slot mono
-                    cfg->chan_fmt = I2S_CHANNEL_FMT_ONLY_RIGHT;
-                }
-#if SOC_I2S_SUPPORTS_PDM_RX
-                cfg->total_chan = (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM) ? 1 : 2;
-#else
-                cfg->total_chan = 2;
-#endif
-            }
-        } else {
-            if (ch >> 16) {
-                cfg->chan_fmt = I2S_CHANNEL_FMT_MULTIPLE;
-                cfg->chan_mask = ch & 0xFFFF0000;
-                cfg->total_chan = m_i2s_get_max_channel_num(cfg->chan_mask);
-            } else {
-                /* If no TDM channels activated, use 2 channels as defualt */
-                cfg->chan_fmt = I2S_CHANNEL_FMT_RIGHT_LEFT;
-                cfg->chan_mask = I2S_TDM_ACTIVE_CH0 | I2S_TDM_ACTIVE_CH1;
-                cfg->total_chan = 2;
-            }
-        }
-#else
-        /* Default */
-        if (ch & I2S_CHANNEL_MONO) {
-            if (p_i2s[i2s_num]->init_chan_fmt == I2S_CHANNEL_FMT_ONLY_LEFT) {
-                cfg->chan_fmt = I2S_CHANNEL_FMT_ONLY_LEFT;
-            } else {
-                cfg->chan_fmt = I2S_CHANNEL_FMT_ONLY_RIGHT;
-            }
-        } else {
-            cfg->chan_fmt = I2S_CHANNEL_FMT_RIGHT_LEFT;
-        }
-        cfg->active_chan = m_i2s_get_active_channel_num(cfg);
-        cfg->total_chan = 2;
-#endif
-        if (cfg->mode & I2S_MODE_TX) {
-            i2s_hal_tx_set_channel_style(&(p_i2s[i2s_num]->hal), cfg);
-        }
-        if (cfg->mode & I2S_MODE_RX) {
-            i2s_hal_rx_set_channel_style(&(p_i2s[i2s_num]->hal), cfg);
-        }
-    }
-    uint32_t data_bits = cfg->sample_bits;
-
-    /* Check the validity of sample bits */
-    ESP_RETURN_ON_FALSE((data_bits % 8 == 0), ESP_ERR_INVALID_ARG, TAG, "Invalid bits per sample");
-    ESP_RETURN_ON_FALSE((data_bits <= I2S_BITS_PER_SAMPLE_32BIT), ESP_ERR_INVALID_ARG, TAG, "Invalid bits per sample");
-
-    i2s_hal_clock_cfg_t clk_cfg;
-    /* To get sclk, mclk, mclk_div bclk and bclk_div */
-    m_i2s_calculate_clock(i2s_num, &clk_cfg);
-
-    uint32_t buf_size = m_i2s_get_buf_size(i2s_num);
-    bool need_realloc = p_i2s[i2s_num]->last_buf_size != buf_size;
-
-    /* TX mode clock reset */
-    if (cfg->mode & I2S_MODE_TX) {
-        ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->tx, ESP_ERR_INVALID_ARG, TAG, "I2S TX DMA object has not initialized yet");
-        /* Waiting for transmit finish */
-        m_i2s_tx_set_clk_and_channel(i2s_num, &clk_cfg);
-        /* Workaround for ESP32-S3/C3, overwrite with speicial coefficients to lower down the noise */
-#if SOC_I2S_SUPPORTS_PDM_CODEC
-        if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_PDM) {
-            i2s_ll_tx_set_raw_clk_div(p_i2s[i2s_num]->hal.dev, 1, 1, 0, 0);
-        }
-#endif // SOC_I2S_SUPPORTS_PDM_TX
-
-        /* If buffer size changed, the DMA buffer need realloc */
-        if (need_realloc) {
-            p_i2s[i2s_num]->tx->buf_size = buf_size;
-            ret = m_i2s_realloc_dma_buffer(i2s_num, p_i2s[i2s_num]->tx);
-        }
-        /* If not the first time, update I2S tx channel style */
-        if (p_i2s[i2s_num]->last_buf_size) {
-            i2s_hal_tx_set_channel_style(&(p_i2s[i2s_num]->hal), &(p_i2s[i2s_num]->hal_cfg));
-        }
-        /* Reset the queue to avoid receive invalid data */
-        xQueueReset(p_i2s[i2s_num]->tx->queue);
-        ESP_RETURN_ON_ERROR(ret, TAG, "I2S%d tx DMA buffer malloc failed", i2s_num);
-    }
-    /* RX mode clock reset */
-    if (cfg->mode & I2S_MODE_RX) {
-        ESP_RETURN_ON_FALSE(p_i2s[i2s_num]->rx, ESP_ERR_INVALID_ARG, TAG, "I2S TX DMA object has not initialized yet");
-        /* Waiting for receive finish */
-        m_i2s_rx_set_clk_and_channel(i2s_num, &clk_cfg);
-        /* If buffer size changed, the DMA buffer need realloc */
-        if (need_realloc) {
-            p_i2s[i2s_num]->rx->buf_size = buf_size;
-            ret = m_i2s_realloc_dma_buffer(i2s_num, p_i2s[i2s_num]->rx);
-            /* Reset the end-of-frame number */
-            i2s_hal_set_rx_eof_num(&(p_i2s[i2s_num]->hal), buf_size);
-        }
-        /* If not the first time, update I2S rx channel style */
-        if (p_i2s[i2s_num]->last_buf_size) {
-            i2s_hal_rx_set_channel_style(&(p_i2s[i2s_num]->hal), &(p_i2s[i2s_num]->hal_cfg));
-        }
-        /* Reset the queue to avoid receiving invalid data */
-        xQueueReset(p_i2s[i2s_num]->rx->queue);
-        ESP_RETURN_ON_ERROR(ret, TAG, "I2S%d rx DMA buffer malloc failed", i2s_num);
-    }
-    /* Update last buffer size */
-    p_i2s[i2s_num]->last_buf_size = buf_size;
-
-    /* I2S start */
-    m_i2s_start(i2s_num);
-
-    if (cfg->mode & I2S_MODE_TX) {
-        xSemaphoreGive(p_i2s[i2s_num]->tx->mux);
-    }
-    if (cfg->mode & I2S_MODE_RX) {
-        xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
-    }
-
-    return ESP_OK;
-}
-
-/*-------------------------------------------------------------
-                   I2S driver operation
-  -------------------------------------------------------------*/
-/**
- * @brief   Start I2S driver
- * @note    It is not necessary to call this function after i2s_driver_install() (it is started automatically), however it is necessary to call it after i2s_stop().
- *
- * @param   i2s_num  I2S device number
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_start(i2s_port_t i2s_num)
-{
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    //start DMA link
-    I2S_ENTER_CRITICAL(i2s_num);
-
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-        m_i2s_tx_reset(i2s_num);
-        m_i2s_tx_start(i2s_num);
-    }
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-        m_i2s_rx_reset(i2s_num);
-        i2s_rx_start(i2s_num);
-    }
-#if !SOC_GDMA_SUPPORTED
-    esp_intr_enable(p_i2s[i2s_num]->i2s_isr_handle);
-#endif
-    I2S_EXIT_CRITICAL(i2s_num);
-    return ESP_OK;
-}
-
-/**
- * @brief   Stop I2S driver
- * @note    There is no need to call i2s_stop() before calling i2s_driver_uninstall().
- *          Disables I2S TX/RX, until i2s_start() is called.
- *
- * @param   i2s_num     I2S device number
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_stop(i2s_port_t i2s_num)
-{
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    I2S_ENTER_CRITICAL(i2s_num);
-#if !SOC_GDMA_SUPPORTED
-    esp_intr_disable(p_i2s[i2s_num]->i2s_isr_handle);
-#endif
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-        m_i2s_tx_stop(i2s_num);
-    }
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-        m_i2s_rx_stop(i2s_num);
-    }
-#if !SOC_GDMA_SUPPORTED
-    i2s_hal_clear_intr_status(&(p_i2s[i2s_num]->hal), I2S_INTR_MAX);
-#endif
-    I2S_EXIT_CRITICAL(i2s_num);
-    return ESP_OK;
-}
-
-/**
- * @brief   Initialize I2S driver configurations
- *
- * @param   i2s_num     I2S device number
- * @param   i2s_config  I2S configurations - see i2s_config_t struct
- * @return
- *      - ESP_OK        I2S initialize success
- *      - ESP_ERR_INVALID_ARG   No channel enabled in multiple channel format
- */
-static esp_err_t m_i2s_driver_init(i2s_port_t i2s_num, const i2s_config_t *i2s_config)
-{
-    ESP_RETURN_ON_FALSE(i2s_config, ESP_ERR_INVALID_ARG, TAG, "The pointer of I2S configuration structure is NULL");
-
-    /* I2S driver configuration assignment */
-    p_i2s[i2s_num]->i2s_num = i2s_num;
-    p_i2s[i2s_num]->dma_buf_count = i2s_config->dma_buf_count;
-    p_i2s[i2s_num]->dma_buf_len = i2s_config->dma_buf_len;
-    p_i2s[i2s_num]->last_buf_size = 0;
-    p_i2s[i2s_num]->use_apll = i2s_config->use_apll;
-    p_i2s[i2s_num]->fixed_mclk = i2s_config->fixed_mclk;
-    p_i2s[i2s_num]->mclk_multiple = i2s_config->mclk_multiple;
-    p_i2s[i2s_num]->tx_desc_auto_clear = i2s_config->tx_desc_auto_clear;
-    p_i2s[i2s_num]->init_chan_fmt = i2s_config->channel_format;
-
-    /* I2S HAL configuration assignment */
-    p_i2s[i2s_num]->hal_cfg.mode = i2s_config->mode;
-    p_i2s[i2s_num]->hal_cfg.sample_rate = i2s_config->sample_rate;
-    p_i2s[i2s_num]->hal_cfg.comm_fmt = i2s_config->communication_format;
-    p_i2s[i2s_num]->hal_cfg.chan_fmt = i2s_config->channel_format;
-    p_i2s[i2s_num]->hal_cfg.sample_bits = i2s_config->bits_per_sample;
-    p_i2s[i2s_num]->hal_cfg.chan_bits = (uint32_t)i2s_config->bits_per_chan < (uint32_t)i2s_config->bits_per_sample ?
-                                        (uint32_t)i2s_config->bits_per_sample : (uint32_t)i2s_config->bits_per_chan;
-
-#if SOC_I2S_SUPPORTS_TDM
-    /* I2S HAL TDM configuration assignment */
-    p_i2s[i2s_num]->hal_cfg.left_align    = i2s_config->left_align;
-    p_i2s[i2s_num]->hal_cfg.big_edin      = i2s_config->big_edin;
-    p_i2s[i2s_num]->hal_cfg.bit_order_msb = i2s_config->bit_order_msb;
-    p_i2s[i2s_num]->hal_cfg.skip_msk      = i2s_config->skip_msk;
-
-    /* Set chan_mask according to channel format */
-    switch (i2s_config->channel_format) {
-    case I2S_CHANNEL_FMT_RIGHT_LEFT:    // fall through
-    case I2S_CHANNEL_FMT_ALL_RIGHT:     // fall through
-    case I2S_CHANNEL_FMT_ALL_LEFT:
-        p_i2s[i2s_num]->hal_cfg.chan_mask = I2S_TDM_ACTIVE_CH0 | I2S_TDM_ACTIVE_CH1;
-        p_i2s[i2s_num]->hal_cfg.total_chan = 2;
-        break;
-    case I2S_CHANNEL_FMT_ONLY_RIGHT:
-        p_i2s[i2s_num]->hal_cfg.chan_mask = I2S_TDM_ACTIVE_CH1;
-        p_i2s[i2s_num]->hal_cfg.total_chan = 2;
-        break;
-    case I2S_CHANNEL_FMT_ONLY_LEFT:
-        p_i2s[i2s_num]->hal_cfg.chan_mask = I2S_TDM_ACTIVE_CH0;
-        p_i2s[i2s_num]->hal_cfg.total_chan = 2;
-        break;
-    case I2S_CHANNEL_FMT_MULTIPLE:
-        ESP_RETURN_ON_FALSE((i2s_config->chan_mask >> 16), ESP_ERR_INVALID_ARG, TAG, "i2s all channel are disabled");
-        p_i2s[i2s_num]->hal_cfg.chan_mask = i2s_config->chan_mask & 0xFFFF0000;
-        /* Get the max actived channel number */
-        uint32_t max_channel = m_i2s_get_max_channel_num(p_i2s[i2s_num]->hal_cfg.chan_mask);
-        /* If total channel is smaller than max actived channel number then set it to the max active channel number */
-        p_i2s[i2s_num]->hal_cfg.total_chan    = p_i2s[i2s_num]->hal_cfg.total_chan < max_channel ? max_channel :
-                                                p_i2s[i2s_num]->hal_cfg.total_chan;
-        break;
-    default:
-        ESP_RETURN_ON_FALSE(false, ESP_ERR_INVALID_ARG, TAG, "wrong i2s channel format, going to uninstall i2s");
-    }
-
-    /* Calculate actived channel number in channel mask */
-    p_i2s[i2s_num]->hal_cfg.active_chan   = i2s_get_active_channel_num(&p_i2s[i2s_num]->hal_cfg);
-
-#else
-    /* Calculate actived channel number in channel mask */
-    p_i2s[i2s_num]->hal_cfg.active_chan   = m_i2s_get_active_channel_num(&p_i2s[i2s_num]->hal_cfg);
-    /* Total channel number is equal to the actived channel number in non-TDM mode */
-    p_i2s[i2s_num]->hal_cfg.total_chan    = 2;
-#endif
-    return ESP_OK;
-}
-
-/**
- * @brief   Initialize I2S DMA object
- *
- * @param   i2s_num     I2S device number
- * @return
- *      - ESP_OK            DMA object initialize success
- *      - ESP_ERR_NO_MEM    No memory for DMA object
- */
-static esp_err_t m_i2s_dma_object_init(i2s_port_t i2s_num)
-{
-    uint32_t buf_size = m_i2s_get_buf_size(i2s_num);
-    /* Create DMA object */
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-        ESP_RETURN_ON_ERROR(m_i2s_create_dma_object(i2s_num, &p_i2s[i2s_num]->tx), TAG, "I2S TX DMA object create failed");
-        p_i2s[i2s_num]->tx->buf_size = buf_size;
-    }
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-        ESP_RETURN_ON_ERROR(m_i2s_create_dma_object(i2s_num, &p_i2s[i2s_num]->rx), TAG, "I2S RX DMA object create failed");
-        p_i2s[i2s_num]->rx->buf_size = buf_size;
-    }
-    return ESP_OK;
-}
-
-/**
- * @brief   Install and start I2S driver.
- * @note    This function must be called before any I2S driver read/write operations.
- *
- *
- * @param   i2s_num         I2S device number
- * @param   i2s_config      I2S configurations - see i2s_config_t struct
- * @param   queue_size      I2S event queue size/depth.
- * @param   i2s_queue       I2S event queue handle, if set NULL, driver will not use an event queue.
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- *     - ESP_ERR_INVALID_STATE  Current I2S port is in use
- */
-esp_err_t m_i2s_driver_install(i2s_port_t i2s_num, const i2s_config_t *i2s_config, int queue_size, void *i2s_queue)
-{
-    esp_err_t ret = ESP_OK;
-
-    /* Step 1: Check the validity of input parameters */
-    /* Check the validity of i2s device number */
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    ESP_RETURN_ON_FALSE(i2s_config, ESP_ERR_INVALID_ARG, TAG, "I2S configuration must not be NULL");
-    /* Check the size of DMA buffer */
-    ESP_RETURN_ON_FALSE((i2s_config->dma_buf_count >= 2 && i2s_config->dma_buf_count <= 128), ESP_ERR_INVALID_ARG, TAG, "I2S buffer count less than 128 and more than 2");
-    ESP_RETURN_ON_FALSE((i2s_config->dma_buf_len >= 8 && i2s_config->dma_buf_len <= 1024), ESP_ERR_INVALID_ARG, TAG, "I2S buffer length at most 1024 and more than 8");
-
-    /* Step 2: Allocate driver object and register to platform */
-    i2s_obj_t *pre_alloc_i2s_obj = calloc(1, sizeof(i2s_obj_t));
-    ESP_RETURN_ON_FALSE(pre_alloc_i2s_obj, ESP_ERR_NO_MEM, TAG, "no mem for I2S driver");
-    ret = m_i2s_priv_register_object(pre_alloc_i2s_obj, i2s_num);
-    if (ret != ESP_OK) {
-        free(pre_alloc_i2s_obj);
-        ESP_LOGE(TAG, "register I2S object to platform failed");
-        return ESP_ERR_INVALID_STATE;
-    }
-
-    /* Step 3: Initialize I2S object, assign configarations */
-    ESP_GOTO_ON_ERROR(m_i2s_driver_init(i2s_num, i2s_config), err, TAG, "I2S init failed");
-    /* Check the validity of I2S configuration */
-    ESP_GOTO_ON_ERROR(m_i2s_check_cfg_validity(i2s_num, &(pre_alloc_i2s_obj->hal_cfg)), err, TAG, "I2S configuration is invalid");
-
-    /* Get device instance */
-    i2s_hal_init(&(pre_alloc_i2s_obj->hal), i2s_num);
-
-#ifdef CONFIG_PM_ENABLE
-    esp_pm_lock_type_t pm_lock = ESP_PM_APB_FREQ_MAX;
-#if SOC_I2S_SUPPORTS_APLL
-    if (i2s_config->use_apll) {
-        pm_lock = ESP_PM_NO_LIGHT_SLEEP;
-    }
-#endif // SOC_I2S_SUPPORTS_APLL
-    ESP_GOTO_ON_ERROR(esp_pm_lock_create(pm_lock, 0, "i2s_driver", &pre_alloc_i2s_obj->pm_lock), err, TAG, "I2S pm lock error");
-#endif //CONFIG_PM_ENABLE
-
-    /* Step 4: Initialize I2S DMA interrupt and DMA object */
-    ESP_GOTO_ON_ERROR(m_i2s_dma_intr_init(i2s_num, i2s_config->intr_alloc_flags), err, TAG, "I2S interrupt initailze failed");
-    /* Initialize I2S DMA object */
-    ESP_GOTO_ON_ERROR(m_i2s_dma_object_init(i2s_num), err, TAG,  "I2S dma object create failed");
-
-#if _SOC_I2S_SUPPORTS_ADC
-    /* If using built-in ADC, we need to enable ADC power manerge*/
-    if (pre_alloc_i2s_obj->hal_cfg.mode & I2S_MODE_ADC_BUILT_IN) {
-        sar_periph_ctrl_adc_continuous_power_acquire();
-    }
-#endif
-    /* Enable module clock */
-    i2s_hal_enable_module_clock(&p_i2s[i2s_num]->hal);
-#if SOC_I2S_SUPPORTS_TDM
-    if (i2s_config->mode & I2S_MODE_TX) {
-        i2s_ll_tx_enable_clock(p_i2s[i2s_num]->hal.dev);
-    }
-    if (i2s_config->mode & I2S_MODE_RX) {
-        i2s_ll_rx_enable_clock(p_i2s[i2s_num]->hal.dev);
-    }
-#endif
-
-    /* Step 5: Initialize I2S configuration and set the configurations to register */
-    i2s_hal_config_param(&(pre_alloc_i2s_obj->hal), &pre_alloc_i2s_obj->hal_cfg);
-
-    /* Step 6: Initialise i2s event queue if user needs */
-    if (i2s_queue) {
-        pre_alloc_i2s_obj->i2s_queue = xQueueCreate(queue_size, sizeof(i2s_event_t));
-        ESP_GOTO_ON_FALSE(pre_alloc_i2s_obj->i2s_queue, ESP_ERR_NO_MEM, err, TAG, "I2S queue create failed");
-        *((QueueHandle_t *) i2s_queue) = pre_alloc_i2s_obj->i2s_queue;
-        ESP_LOGI(TAG, "queue free spaces: %d", uxQueueSpacesAvailable(pre_alloc_i2s_obj->i2s_queue));
-    } else {
-        pre_alloc_i2s_obj->i2s_queue = NULL;
-    }
-
-    /* Step 7: Set I2S clocks and start. No need to give parameters since configurations has been set in 'i2s_driver_init' */
-    ESP_GOTO_ON_ERROR(m_i2s_set_clk(i2s_num, 0, 0, 0), err, TAG, "I2S set clock failed");
-
-    return ESP_OK;
-
-err:
-    /* I2S install failed, prepare to uninstall */
-    m_i2s_driver_uninstall(i2s_num);
-    return ret;
-}
-
-/**
- * @brief Uninstall I2S driver.
- *
- * @param   i2s_num     I2S device number
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_driver_uninstall(i2s_port_t i2s_num)
-{
-    ESP_RETURN_ON_FALSE(i2s_num < I2S_NUM_MAX, ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    ESP_RETURN_ON_FALSE(p_i2s[i2s_num], ESP_ERR_INVALID_STATE, TAG, "I2S port %d has not installed", i2s_num);
-    i2s_obj_t *obj = p_i2s[i2s_num];
-    m_i2s_stop(i2s_num);
-#if _SOC_I2S_SUPPORTS_DAC
-    m_i2s_set_dac_mode(I2S_DAC_CHANNEL_DISABLE);
-#endif
-#if SOC_GDMA_SUPPORTED
-    if (p_i2s[i2s_num]->tx_dma_chan) {
-        gdma_disconnect(p_i2s[i2s_num]->tx_dma_chan);
-        gdma_del_channel(p_i2s[i2s_num]->tx_dma_chan);
-    }
-    if (p_i2s[i2s_num]->rx_dma_chan) {
-        gdma_disconnect(p_i2s[i2s_num]->rx_dma_chan);
-        gdma_del_channel(p_i2s[i2s_num]->rx_dma_chan);
-    }
-#else
-    if (p_i2s[i2s_num]->i2s_isr_handle) {
-        esp_intr_free(p_i2s[i2s_num]->i2s_isr_handle);
-    }
-#endif
-    /* Destroy dma object if exist */
-    m_i2s_destroy_dma_object(i2s_num, &p_i2s[i2s_num]->tx);
-    m_i2s_destroy_dma_object(i2s_num, &p_i2s[i2s_num]->rx);
-
-    if (p_i2s[i2s_num]->i2s_queue) {
-        vQueueDelete(p_i2s[i2s_num]->i2s_queue);
-        p_i2s[i2s_num]->i2s_queue = NULL;
-    }
-
-#if SOC_I2S_SUPPORTS_APLL
-    if (p_i2s[i2s_num]->use_apll) {
-        // switch back to PLL clock source
-        i2s_hal_set_clock_src(&(p_i2s[i2s_num]->hal), I2S_CLK_D2CLK);
-        rtc_clk_apll_enable(0, 0, 0, 0, 0);
-    }
-#endif
-
-#ifdef CONFIG_PM_ENABLE
-    if (p_i2s[i2s_num]->pm_lock) {
-        esp_pm_lock_delete(p_i2s[i2s_num]->pm_lock);
-        p_i2s[i2s_num]->pm_lock = NULL;
-    }
-#endif
-#if SOC_I2S_SUPPORTS_TDM
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_TX) {
-        i2s_ll_tx_disable_clock(p_i2s[i2s_num]->hal.dev);
-    }
-    if (p_i2s[i2s_num]->hal_cfg.mode & I2S_MODE_RX) {
-        i2s_ll_rx_disable_clock(p_i2s[i2s_num]->hal.dev);
-    }
-#endif
-    /* Disable module clock */
-    i2s_hal_disable_module_clock(&p_i2s[i2s_num]->hal);
-    m_i2s_priv_deregister_object(i2s_num);
-    free(obj);
-    return ESP_OK;
-}
-
-/**
- * @brief   Write data to I2S DMA transmit buffer.
- * @note    Many ticks pass without space becoming available in the DMA
- *          transmit buffer, then the function will return (note that if the
- *          data is written to the DMA buffer in pieces, the overall operation
- *          may still take longer than this timeout.) Pass portMAX_DELAY for no
- *          timeout.
- *
- * @param       i2s_num             I2S device number
- * @param       src                 Source address to write from
- * @param       size                Size of data in bytes
- * @param[out]  bytes_written       Number of bytes written, if timeout, the result will be less than the size passed in.
- * @param       ticks_to_wait       TX buffer wait timeout in RTOS ticks. If this
- * @return
- *     - ESP_OK               Success
- *     - ESP_ERR_INVALID_ARG  Parameter error
- */
-esp_err_t m_i2s_write(i2s_port_t i2s_num, const void *src, size_t size, size_t *bytes_written, TickType_t ticks_to_wait)
-{
-    char *data_ptr, *src_byte;
-    size_t bytes_can_write;
-    *bytes_written = 0;
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->tx), ESP_ERR_INVALID_ARG, TAG, "TX mode is not enabled");
-    xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
-#ifdef CONFIG_PM_ENABLE
-    esp_pm_lock_acquire(p_i2s[i2s_num]->pm_lock);
-#endif
-    src_byte = (char *)src;
-    while (size > 0) {
-        if (p_i2s[i2s_num]->tx->rw_pos == p_i2s[i2s_num]->tx->buf_size || p_i2s[i2s_num]->tx->curr_ptr == NULL) {
-            if (xQueueReceive(p_i2s[i2s_num]->tx->queue, &p_i2s[i2s_num]->tx->curr_ptr, ticks_to_wait) == pdFALSE) {
-                break;
-            }
-            p_i2s[i2s_num]->tx->rw_pos = 0;
-        }
-        ESP_LOGD(TAG, "size: %d, rw_pos: %d, buf_size: %d, curr_ptr: %d", size, p_i2s[i2s_num]->tx->rw_pos, p_i2s[i2s_num]->tx->buf_size, (int)p_i2s[i2s_num]->tx->curr_ptr);
-        data_ptr = (char *)p_i2s[i2s_num]->tx->curr_ptr;
-        data_ptr += p_i2s[i2s_num]->tx->rw_pos;
-        bytes_can_write = p_i2s[i2s_num]->tx->buf_size - p_i2s[i2s_num]->tx->rw_pos;
-        if (bytes_can_write > size) {
-            bytes_can_write = size;
-        }
-        memcpy(data_ptr, src_byte, bytes_can_write);
-        size -= bytes_can_write;
-        src_byte += bytes_can_write;
-        p_i2s[i2s_num]->tx->rw_pos += bytes_can_write;
-        (*bytes_written) += bytes_can_write;
-    }
-#ifdef CONFIG_PM_ENABLE
-    esp_pm_lock_release(p_i2s[i2s_num]->pm_lock);
-#endif
-    xSemaphoreGive(p_i2s[i2s_num]->tx->mux);
-    return ESP_OK;
-}
-
-/**
- * @brief   Write data to I2S DMA transmit buffer while expanding the number of bits per sample. For example, expanding 16-bit PCM to 32-bit PCM.
- * @note    Many ticks pass without space becoming available in the DMA
- *          transmit buffer, then the function will return (note that if the
- *          data is written to the DMA buffer in pieces, the overall operation
- *          may still take longer than this timeout.) Pass portMAX_DELAY for no
- *          timeout.
- *          Format of the data in source buffer is determined by the I2S configuration (see i2s_config_t).
- *
- * @param       i2s_num             I2S device number
- * @param       src                 Source address to write from
- * @param       size                Size of data in bytes
- * @param       src_bits            Source audio bit
- * @param       aim_bits            Bit wanted, no more than 32, and must be greater than src_bits
- * @param[out]  bytes_written       Number of bytes written, if timeout, the result will be less than the size passed in.
- * @param       ticks_to_wait       TX buffer wait timeout in RTOS ticks. If this
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_write_expand(i2s_port_t i2s_num, const void *src, size_t size, size_t src_bits, size_t aim_bits, size_t *bytes_written, TickType_t ticks_to_wait)
-{
-    char *data_ptr;
-    int bytes_can_write, tail;
-    int src_bytes, aim_bytes, zero_bytes;
-    *bytes_written = 0;
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    ESP_RETURN_ON_FALSE((size > 0), ESP_ERR_INVALID_ARG, TAG, "size must greater than zero");
-    ESP_RETURN_ON_FALSE((aim_bits >= src_bits), ESP_ERR_INVALID_ARG, TAG, "aim_bits mustn't be less than src_bits");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->tx), ESP_ERR_INVALID_ARG, TAG, "TX mode is not enabled");
-    if (src_bits < I2S_BITS_PER_SAMPLE_8BIT || aim_bits < I2S_BITS_PER_SAMPLE_8BIT) {
-        ESP_LOGE(TAG, "bits mustn't be less than 8, src_bits %d aim_bits %d", src_bits, aim_bits);
-        return ESP_ERR_INVALID_ARG;
-    }
-    if (src_bits > I2S_BITS_PER_SAMPLE_32BIT || aim_bits > I2S_BITS_PER_SAMPLE_32BIT) {
-        ESP_LOGE(TAG, "bits mustn't be greater than 32, src_bits %d aim_bits %d", src_bits, aim_bits);
-        return ESP_ERR_INVALID_ARG;
-    }
-    if ((src_bits == I2S_BITS_PER_SAMPLE_16BIT || src_bits == I2S_BITS_PER_SAMPLE_32BIT) && (size % 2 != 0)) {
-        ESP_LOGE(TAG, "size must be a even number while src_bits is even, src_bits %d size %d", src_bits, size);
-        return ESP_ERR_INVALID_ARG;
-    }
-    if (src_bits == I2S_BITS_PER_SAMPLE_24BIT && (size % 3 != 0)) {
-        ESP_LOGE(TAG, "size must be a multiple of 3 while src_bits is 24, size %d", size);
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    src_bytes = src_bits / 8;
-    aim_bytes = aim_bits / 8;
-    zero_bytes = aim_bytes - src_bytes;
-    xSemaphoreTake(p_i2s[i2s_num]->tx->mux, (portTickType)portMAX_DELAY);
-    size = size * aim_bytes / src_bytes;
-    ESP_LOGD(TAG, "aim_bytes %d src_bytes %d size %d", aim_bytes, src_bytes, size);
-    while (size > 0) {
-        if (p_i2s[i2s_num]->tx->rw_pos == p_i2s[i2s_num]->tx->buf_size || p_i2s[i2s_num]->tx->curr_ptr == NULL) {
-            if (xQueueReceive(p_i2s[i2s_num]->tx->queue, &p_i2s[i2s_num]->tx->curr_ptr, ticks_to_wait) == pdFALSE) {
-                break;
-            }
-            p_i2s[i2s_num]->tx->rw_pos = 0;
-        }
-        data_ptr = (char *)p_i2s[i2s_num]->tx->curr_ptr;
-        data_ptr += p_i2s[i2s_num]->tx->rw_pos;
-        bytes_can_write = p_i2s[i2s_num]->tx->buf_size - p_i2s[i2s_num]->tx->rw_pos;
-        if (bytes_can_write > (int)size) {
-            bytes_can_write = size;
-        }
-        tail = bytes_can_write % aim_bytes;
-        bytes_can_write = bytes_can_write - tail;
-
-        memset(data_ptr, 0, bytes_can_write);
-        for (int j = 0; j < bytes_can_write; j += (aim_bytes - zero_bytes)) {
-            j += zero_bytes;
-            memcpy(&data_ptr[j], (const char *)(src + *bytes_written), aim_bytes - zero_bytes);
-            (*bytes_written) += (aim_bytes - zero_bytes);
-        }
-        size -= bytes_can_write;
-        p_i2s[i2s_num]->tx->rw_pos += bytes_can_write;
-    }
-    xSemaphoreGive(p_i2s[i2s_num]->tx->mux);
-    return ESP_OK;
-}
-
-/**
- * @brief   Read data from I2S DMA receive buffer
- * @note    If the built-in ADC mode is enabled, we should call i2s_adc_enable and i2s_adc_disable around the whole reading process,
- *          to prevent the data getting corrupted.
- *
- * @param       i2s_num         I2S device number
- * @param       dest            Destination address to read into
- * @param       size            Size of data in bytes
- * @param[out]  bytes_read      Number of bytes read, if timeout, bytes read will be less than the size passed in.
- * @param       ticks_to_wait   RX buffer wait timeout in RTOS ticks. If this many ticks pass without bytes becoming available in the DMA receive buffer, then the function will return (note that if data is read from the DMA buffer in pieces, the overall operation may still take longer than this timeout.) Pass portMAX_DELAY for no timeout.
- * @return
- *     - ESP_OK               Success
- *     - ESP_ERR_INVALID_ARG  Parameter error
- */
-esp_err_t m_i2s_read(i2s_port_t i2s_num, void *dest, size_t size, size_t *bytes_read, TickType_t ticks_to_wait)
-{
-    char *data_ptr, *dest_byte;
-    int bytes_can_read;
-    *bytes_read = 0;
-    dest_byte = (char *)dest;
-    ESP_RETURN_ON_FALSE((i2s_num < I2S_NUM_MAX), ESP_ERR_INVALID_ARG, TAG, "i2s_num error");
-    ESP_RETURN_ON_FALSE((p_i2s[i2s_num]->rx), ESP_ERR_INVALID_ARG, TAG, "RX mode is not enabled");
-    xSemaphoreTake(p_i2s[i2s_num]->rx->mux, (portTickType)portMAX_DELAY);
-#ifdef CONFIG_PM_ENABLE
-    esp_pm_lock_acquire(p_i2s[i2s_num]->pm_lock);
-#endif
-    while (size > 0) {
-        if (p_i2s[i2s_num]->rx->rw_pos == p_i2s[i2s_num]->rx->buf_size || p_i2s[i2s_num]->rx->curr_ptr == NULL) {
-            if (xQueueReceive(p_i2s[i2s_num]->rx->queue, &p_i2s[i2s_num]->rx->curr_ptr, ticks_to_wait) == pdFALSE) {
-                break;
-            }
-            p_i2s[i2s_num]->rx->rw_pos = 0;
-        }
-        data_ptr = (char *)p_i2s[i2s_num]->rx->curr_ptr;
-        data_ptr += p_i2s[i2s_num]->rx->rw_pos;
-        bytes_can_read = p_i2s[i2s_num]->rx->buf_size - p_i2s[i2s_num]->rx->rw_pos;
-        if (bytes_can_read > (int)size) {
-            bytes_can_read = size;
-        }
-        memcpy(dest_byte, data_ptr, bytes_can_read);
-        size -= bytes_can_read;
-        dest_byte += bytes_can_read;
-        p_i2s[i2s_num]->rx->rw_pos += bytes_can_read;
-        (*bytes_read) += bytes_can_read;
-    }
-#ifdef CONFIG_PM_ENABLE
-    esp_pm_lock_release(p_i2s[i2s_num]->pm_lock);
-#endif
-    xSemaphoreGive(p_i2s[i2s_num]->rx->mux);
-    return ESP_OK;
-}
-
-esp_err_t m_i2s_priv_register_object(void *driver_obj, int port_id)
-{
-    esp_err_t ret = ESP_ERR_NOT_FOUND;
-    ESP_RETURN_ON_FALSE(driver_obj && (port_id < SOC_I2S_NUM), ESP_ERR_INVALID_ARG, TAG, "invalid arguments");
-    portENTER_CRITICAL(&i2s_platform_spinlock);
-    if (!p_i2s[port_id]) {
-        ret = ESP_OK;
-        p_i2s[port_id] = driver_obj;
-        periph_module_enable(i2s_periph_signal[port_id].module);
-    }
-    portEXIT_CRITICAL(&i2s_platform_spinlock);
-    return ret;
-}
-
-esp_err_t m_i2s_priv_deregister_object(int port_id)
-{
-    esp_err_t ret = ESP_ERR_INVALID_STATE;
-    ESP_RETURN_ON_FALSE(port_id < SOC_I2S_NUM, ESP_ERR_INVALID_ARG, TAG, "invalid arguments");
-    portENTER_CRITICAL(&i2s_platform_spinlock);
-    if (p_i2s[port_id]) {
-        ret = ESP_OK;
-        p_i2s[port_id] = NULL;
-        periph_module_disable(i2s_periph_signal[port_id].module);
-    }
-    portEXIT_CRITICAL(&i2s_platform_spinlock);
-    return ret;
-}
-
-#endif // def SUPPORT_I2S

From 2c000bf4e7e4febaf4e725d56d46a62980ed3fb1 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 28 Aug 2026 11:41:58 -0400
Subject: [PATCH 14/34] Added debug macro. Reneamed Start Frame Methods

---
 src/output/OutputPixel.cpp | 85 ++++++++++++++------------------------
 1 file changed, 32 insertions(+), 53 deletions(-)

diff --git a/src/output/OutputPixel.cpp b/src/output/OutputPixel.cpp
index 3bac9a1b4..ddc364b03 100644
--- a/src/output/OutputPixel.cpp
+++ b/src/output/OutputPixel.cpp
@@ -180,6 +180,7 @@ bool c_OutputPixel::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     // DEBUG_START;
 
     // PrettyPrint(jsonConfig, "SetConfig");
+    c_OutputCommon::SetConfig (jsonConfig);
 
     // enums need to be converted to uints for json
     setFromJSON (color_order,             jsonConfig, CN_color_order);
@@ -195,8 +196,6 @@ bool c_OutputPixel::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     setFromJSON (PrependNullPixelCount,   jsonConfig, CN_prependnullcount);
     setFromJSON (AppendNullPixelCount,    jsonConfig, CN_appendnullcount);
 
-    c_OutputCommon::SetConfig (jsonConfig);
-
     // DEBUG_V (String (                "gamma: ") + String (gamma));
     // DEBUG_V (String ("PrependNullPixelCount: ") + String (PrependNullPixelCount));
     // DEBUG_V (String (" AppendNullPixelCount: ") + String (AppendNullPixelCount));
@@ -382,7 +381,7 @@ void IRAM_ATTR c_OutputPixel::ISR_SetStartingSendPixelState()
     }
     else
     {
-#ifdef SUPPORT_OutputProtocol_GECE
+        #ifdef SUPPORT_OutputProtocol_GECE
         if (OutputType == OTYPE_t::OutputProtocol_GECE)
         {
             FrameStateFuncPtr = &c_OutputPixel::ISR_PixelSendGECEIntensity;
@@ -391,27 +390,25 @@ void IRAM_ATTR c_OutputPixel::ISR_SetStartingSendPixelState()
         {
             FrameStateFuncPtr = &c_OutputPixel::ISR_PixelSendIntensity;
         }
-#else
+        #else
         FrameStateFuncPtr = &c_OutputPixel::ISR_PixelSendIntensity;
-#endif // def SUPPORT_OutputProtocol_GECE
+        #endif // def SUPPORT_OutputProtocol_GECE
     }
     // DEBUG_END;
 } // SetStartingSendPixelState
 
 //----------------------------------------------------------------------------
-void c_OutputPixel::StartNewFrame ()
+void IRAM_ATTR c_OutputPixel::ISR_StartNewFrame ()
 {
     // DEBUG_START;
 
-#ifdef USE_PIXEL_DEBUG_COUNTERS
     if (ISR_MoreDataToSend ())
     {
-        AbortFrameCounter++;
+        INC_PIXEL_DEBUG_COUNTER(AbortFrameCounter);
     }
-    FrameStartCounter++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+    INC_PIXEL_DEBUG_COUNTER(FrameStartCounter);
 
-    NextPixelToSend = GetBufferAddress();
+    NextPixelToSend = ISR_GetBufferAddress();
     FramePrependDataCurrentIndex    = 0;
     FrameAppendDataCurrentIndex     = 0;
     SentPixelsCount                 = 0;
@@ -435,14 +432,14 @@ void c_OutputPixel::StartNewFrame ()
         ISR_SetStartingSendPixelState ();
     }
 
-#ifdef USE_PIXEL_DEBUG_COUNTERS
+    #ifdef USE_PIXEL_DEBUG_COUNTERS
     SentPixels         = SentPixelsCount;
     PixelsToSend       = pixel_count;
     IntensityBytesSent = 0;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+    #endif // def USE_PIXEL_DEBUG_COUNTERS
 
     // NumIntensityBytesPerPixel = 1;
-    ReportNewFrame();
+    c_OutputCommon::ISR_ReportNewFrame();
 
     // DEBUG_END;
 } // StartNewFrame
@@ -458,9 +455,7 @@ void c_OutputPixel::SetIntensityDataWidth(uint32_t DataWidth)
 //----------------------------------------------------------------------------
 uint32_t IRAM_ATTR c_OutputPixel::ISR_FramePrependData()
 {
-#ifdef USE_PIXEL_DEBUG_COUNTERS
-    FramePrependDataCounter++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+    INC_PIXEL_DEBUG_COUNTER(FramePrependDataCounter);
 
     uint32_t response = pFramePrependData[FramePrependDataCurrentIndex];
     if (++FramePrependDataCurrentIndex >= FramePrependDataSize)
@@ -488,9 +483,7 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelPrependNulls()
     uint32_t response = 0x00;
     do // once
     {
-#ifdef USE_PIXEL_DEBUG_COUNTERS
-        PixelPrependNullsCounter++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+        INC_PIXEL_DEBUG_COUNTER(PixelPrependNullsCounter);
 
         if (PixelPrependDataCurrentIndex < PixelPrependDataSize)
         {
@@ -526,10 +519,8 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelPrependNulls()
 //----------------------------------------------------------------------------
 uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelSendPrependIntensity()
 {
-#ifdef USE_PIXEL_DEBUG_COUNTERS
-        PixelSendIntensityCounter++;
-        IntensityBytesSent++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+    INC_PIXEL_DEBUG_COUNTER(PixelSendIntensityCounter);
+    INC_PIXEL_DEBUG_COUNTER(IntensityBytesSent);
 
     uint32_t response = PixelPrependData[PixelPrependDataCurrentIndex++];
 
@@ -542,10 +533,10 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelSendPrependIntensity()
 #ifdef SUPPORT_OutputProtocol_GECE
             if (OutputType == OTYPE_t::OutputProtocol_GECE)
             {
-#ifdef USE_PIXEL_DEBUG_COUNTERS
+                #ifdef USE_PIXEL_DEBUG_COUNTERS
                 LastGECEdataSent = response;
-                NumGECEdataSent++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+                #endif // def USE_PIXEL_DEBUG_COUNTERS
+                INC_PIXEL_DEBUG_COUNTER(NumGECEdataSent);
                 FrameStateFuncPtr = &c_OutputPixel::ISR_PixelSendGECEIntensity;
             }
             else
@@ -566,10 +557,8 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelSendGECEIntensity()
 {
     uint32_t response = 0x00;
 
-#ifdef USE_PIXEL_DEBUG_COUNTERS
-        PixelSendIntensityCounter++;
-        IntensityBytesSent++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+    INC_PIXEL_DEBUG_COUNTER(PixelSendIntensityCounter);
+    INC_PIXEL_DEBUG_COUNTER(IntensityBytesSent);
 
     // build a GECE intensity frame
     response = GECEBrightness;
@@ -579,8 +568,8 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelSendGECEIntensity()
     response |= GECE_SET_BLUE(ISR_GetIntensityData());
 #ifdef USE_PIXEL_DEBUG_COUNTERS
     LastGECEdataSent = response;
-    NumGECEdataSent++;
 #endif // def USE_PIXEL_DEBUG_COUNTERS
+    INC_PIXEL_DEBUG_COUNTER(NumGECEdataSent);
 
     return response;
 }
@@ -589,10 +578,8 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelSendGECEIntensity()
 //----------------------------------------------------------------------------
 uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelSendIntensity()
 {
-#ifdef USE_PIXEL_DEBUG_COUNTERS
-    PixelSendIntensityCounter++;
-    IntensityBytesSent++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+    INC_PIXEL_DEBUG_COUNTER(PixelSendIntensityCounter);
+    INC_PIXEL_DEBUG_COUNTER(IntensityBytesSent);
 
     return ISR_GetIntensityData();
 } // fPixelSendIntensity
@@ -603,10 +590,9 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelAppendNulls()
     uint32_t response = 0x00;
     do // once
     {
-#ifdef USE_PIXEL_DEBUG_COUNTERS
-        PixelAppendNullsCounter++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
-// pixel prepend goes here
+        INC_PIXEL_DEBUG_COUNTER(PixelAppendNullsCounter);
+        
+        // pixel prepend goes here
         if (PixelPrependDataCurrentIndex < PixelPrependDataSize)
         {
             response = PixelPrependData[PixelPrependDataCurrentIndex++];
@@ -643,9 +629,7 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_PixelAppendNulls()
 //----------------------------------------------------------------------------
 uint32_t IRAM_ATTR c_OutputPixel::ISR_FrameAppendData()
 {
-#ifdef USE_PIXEL_DEBUG_COUNTERS
-    FrameAppendDataCounter++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+    INC_PIXEL_DEBUG_COUNTER(FrameAppendDataCounter)
 
     uint32_t response = pFrameAppendData[FrameAppendDataCurrentIndex];
 
@@ -660,23 +644,18 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_FrameAppendData()
 //----------------------------------------------------------------------------
 uint32_t IRAM_ATTR c_OutputPixel::ISR_FrameDone()
 {
-#ifdef USE_PIXEL_DEBUG_COUNTERS
-    FrameDoneCounter++;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+    INC_PIXEL_DEBUG_COUNTER(FrameDoneCounter);
     return 0x00;
 }
 
 //----------------------------------------------------------------------------
 bool IRAM_ATTR c_OutputPixel::ISR_GetNextIntensityToSend (uint32_t &DataToSend)
 {
-
-#ifdef USE_PIXEL_DEBUG_COUNTERS
-    GetNextIntensityToSendCounter++;
+    INC_PIXEL_DEBUG_COUNTER(GetNextIntensityToSendCounter);
     if(!ISR_MoreDataToSend())
     {
-        GetNextIntensityToSendFailedCounter++;
+        INC_PIXEL_DEBUG_COUNTER(GetNextIntensityToSendFailedCounter);
     }
-#endif // def USE_PIXEL_DEBUG_COUNTERS
 
     DataToSend = (this->*FrameStateFuncPtr)();
 
@@ -715,9 +694,9 @@ uint32_t IRAM_ATTR c_OutputPixel::ISR_GetIntensityData()
         }
         else
         {
-#ifdef USE_PIXEL_DEBUG_COUNTERS
+            #ifdef USE_PIXEL_DEBUG_COUNTERS
             IntensityBytesSentLastFrame = IntensityBytesSent;
-#endif // def USE_PIXEL_DEBUG_COUNTERS
+            #endif // def USE_PIXEL_DEBUG_COUNTERS
 
             FrameStateFuncPtr = &c_OutputPixel::ISR_FrameDone;
         }

From 858121b4576d1a548b330070a51d87dfb648a75d Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 28 Aug 2026 11:42:40 -0400
Subject: [PATCH 15/34] Code format change

---
 src/output/OutputMgr.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/output/OutputMgr.cpp b/src/output/OutputMgr.cpp
index 0af1f704a..362c09d53 100644
--- a/src/output/OutputMgr.cpp
+++ b/src/output/OutputMgr.cpp
@@ -606,9 +606,9 @@ void c_OutputMgr::GetStatus (JsonObject & jsonStatus)
 {
     // DEBUG_START;
 
-#if defined(SUPPORT_I2S)
+    #if defined(SUPPORT_I2S)
     OutputI2S.GetStatus(jsonStatus);
-#endif // defined(SUPPORT_I2S)
+    #endif // defined(SUPPORT_I2S)
 
     JsonArray OutputStatus = jsonStatus[(char*)CN_output].to<JsonArray> ();
     for (uint8_t index = 0; index < NumOutputPorts; ++index)

From 2cbd42efdb80d995c5b792ddf9417b43cdd917ca Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 28 Aug 2026 14:51:27 -0400
Subject: [PATCH 16/34] Renamed new frame and made the new frame calls ISR
 compatible.

---
 include/output/OutputCommon.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/output/OutputCommon.hpp b/include/output/OutputCommon.hpp
index 3304c3d73..f1af328c3 100644
--- a/include/output/OutputCommon.hpp
+++ b/include/output/OutputCommon.hpp
@@ -47,7 +47,7 @@ class c_OutputCommon
 #endif // def ARDUINO_ARCH_ESP32
     virtual void         GetDriverName (String & sDriverName) = 0;             ///< get the name for the instantiated driver
             OM_PortId_t  GetOutputPortId ()    { return OutputPortDefinition.PortId; }     ///< return the output channel number
-            uint8_t    * GetBufferAddress ()   { return pOutputBuffer;}        ///< Get the address of the buffer into which the E1.31 handler will stuff data
+    IRAM_ATTR uint8_t  * ISR_GetBufferAddress(){ return pOutputBuffer;}        ///< Get the address of the buffer into which the E1.31 handler will stuff data
             uint32_t     GetBufferUsedSize ()  { return OutputBufferSize;}     ///< Get the address of the buffer into which the E1.31 handler will stuff data
             OM_GPIOS_t   GetOutputGpio ()      { return OutputPortDefinition.gpios; }
             OTYPE_t      GetOutputType ()      { return OutputType; }          ///< Have the instance report its type.
@@ -77,7 +77,7 @@ class c_OutputCommon
     uint32_t    FrameCount                  = 0;
     bool        Paused = false;
 
-    virtual void ReportNewFrame ();
+    void ISR_ReportNewFrame ();
 
     inline bool canRefresh ()
     {

From 435e6078f31886d7d819883b317b66a2737b3f3e Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 28 Aug 2026 14:52:24 -0400
Subject: [PATCH 17/34] Added debug counter macro Rename New Frame method

---
 include/output/OutputPixel.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/include/output/OutputPixel.hpp b/include/output/OutputPixel.hpp
index 4c47d6df2..2bdeb397c 100644
--- a/include/output/OutputPixel.hpp
+++ b/include/output/OutputPixel.hpp
@@ -99,6 +99,9 @@ class c_OutputPixel : public c_OutputCommon
     uint32_t   GetNextIntensityToSendFailedCounter = 0;
     uint32_t   LastGECEdataSent                    = uint32_t(-1);
     uint32_t   NumGECEdataSent                     = 0;
+#define INC_PIXEL_DEBUG_COUNTER(c) ++c
+#else
+#define INC_PIXEL_DEBUG_COUNTER(c)
 #endif // def USE_PIXEL_DEBUG_COUNTERS
 
     // functions used to implement pixel FSM
@@ -164,7 +167,7 @@ class c_OutputPixel : public c_OutputCommon
     virtual  void         ReadChannelData (uint32_t StartChannelId, uint32_t ChannelCount, byte *pTargetData);
     inline   void         SetIntensityBitTimeInUS (float value) { IntensityBitTimeInUs = value; }
              void         SetIntensityDataWidth(uint32_t value);
-    virtual  void         StartNewFrame();
+             void         ISR_StartNewFrame();
     inline   bool IRAM_ATTR ISR_MoreDataToSend () {return (&c_OutputPixel::ISR_FrameDone != FrameStateFuncPtr);}
              bool         ISR_GetNextIntensityToSend (uint32_t &DataToSend);
              void         SetPixelCount(uint32_t value) {pixel_count = value;}

From 68ad37b0a4df13967e523912390bff943c2da2b7 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 28 Aug 2026 14:54:48 -0400
Subject: [PATCH 18/34] Removed old file.

---
 include/service/m_i2s.h | 518 ----------------------------------------
 1 file changed, 518 deletions(-)
 delete mode 100644 include/service/m_i2s.h

diff --git a/include/service/m_i2s.h b/include/service/m_i2s.h
deleted file mode 100644
index 501e3d4f1..000000000
--- a/include/service/m_i2s.h
+++ /dev/null
@@ -1,518 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#pragma once
-#ifdef SUPPORT_I2S
-
-#include "esp_types.h"
-#include "esp_err.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/semphr.h"
-#include "soc/i2s_periph.h"
-#include "soc/rtc_periph.h"
-#include "soc/soc_caps.h"
-#include "hal/i2s_types.h"
-#include "driver/periph_ctrl.h"
-#include "esp_intr_alloc.h"
-
-#if SOC_I2S_SUPPORTS_ADC
-#include "driver/adc.h"
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define I2S_PIN_NO_CHANGE (-1) /*!< Use in i2s_pin_config_t for pins which should not be changed */
-
-/**
- * @brief I2S port number, the max port number is (I2S_NUM_MAX -1).
- */
-typedef enum {
-    I2S_NUM_0 = 0,                 /*!< I2S port 0 */
-#if SOC_I2S_NUM > 1
-    I2S_NUM_1 = 1,                 /*!< I2S port 1 */
-#endif
-    I2S_NUM_MAX,                   /*!< I2S port max */
-} i2s_port_t;
-
-#if SOC_I2S_SUPPORTS_PCM
-/**
- * @brief I2S PCM configuration
- *
- */
-typedef struct {
-    i2s_pcm_compress_t  pcm_type;       /*!< I2S PCM a/u-law decompress or compress type */
-} i2s_pcm_cfg_t;
-#endif
-
-#if SOC_I2S_SUPPORTS_PDM_TX
-/**
- * @brief Default I2S PDM Up-Sampling Rate configuration
- */
-#define I2S_PDM_DEFAULT_UPSAMPLE_CONFIG(rate) { \
-        .sample_rate = rate,                    \
-        .fp = 960,                              \
-        .fs = (rate) / 100,                     \
-    }
-
-/**
- * @brief I2S PDM up-sample rate configuration
- * @note  TX PDM can only be set to the following two upsampling rate configurations:
- *        1: fp = 960, fs = sample_rate / 100, in this case, Fpdm = 128*48000
- *        2: fp = 960, fs = 480, in this case, Fpdm = 128*Fpcm = 128*sample_rate
- *        If the pdm receiver do not care the pdm serial clock, it's recommended set Fpdm = 128*48000.
- *        Otherwise, the second configuration should be applied.
- */
-typedef struct  {
-    int sample_rate;                    /*!< I2S PDM sample rate */
-    int fp;                             /*!< I2S PDM TX upsampling paramater. Normally it should be set to 960 */
-    int fs;                             /*!< I2S PDM TX upsampling paramater. When it is set to 480, the pdm clock frequency Fpdm = 128 * sample_rate, when it is set to sample_rate / 100， Fpdm will be fixed to 128*48000 */
-} i2s_pdm_tx_upsample_cfg_t;
-#endif
-
-/**
- * @brief I2S pin number for i2s_set_pin
- *
- */
-typedef struct {
-    int mck_io_num;     /*!< MCK in out pin. Note that ESP32 supports setting MCK on GPIO0/GPIO1/GPIO3 only*/
-    int bck_io_num;     /*!< BCK in out pin*/
-    int ws_io_num;      /*!< WS in out pin*/
-    int data_out_num;   /*!< DATA out pin*/
-    int data_in_num;    /*!< DATA in pin*/
-} i2s_pin_config_t;
-
-/**
- * @brief I2S driver configuration parameters
- *
- */
-typedef struct {
-
-    i2s_mode_t              mode;                       /*!< I2S work mode */
-    uint32_t                sample_rate;                /*!< I2S sample rate */
-    i2s_bits_per_sample_t   bits_per_sample;            /*!< I2S sample bits in one channel */
-    i2s_channel_fmt_t       channel_format;             /*!< I2S channel format.*/
-    i2s_comm_format_t       communication_format;       /*!< I2S communication format */
-    int                     intr_alloc_flags;           /*!< Flags used to allocate the interrupt. One or multiple (ORred) ESP_INTR_FLAG_* values. See esp_intr_alloc.h for more info */
-    int                     dma_buf_count;              /**< The total number of DMA buffers to receive/transmit data.
-                                                          * A descriptor includes some information such as buffer address,
-                                                          * the address of the next descriptor, and the buffer length.
-                                                          * Since one descriptor points to one buffer, therefore, 'dma_desc_num' can be interpreted as the total number of DMA buffers used to store data from DMA interrupt.
-                                                          * Notice that these buffers are internal to'i2s_read' and descriptors are created automatically inside of the I2S driver.
-                                                          * Users only need to set the buffer number while the length is derived from the parameter described below.
-                                                          */
-    int                     dma_buf_len;                /**< Number of frames in a DMA buffer.
-                                                          *  A frame means the data of all channels in a WS cycle.
-                                                          *  The real_dma_buf_size = dma_buf_len * chan_num * bits_per_chan / 8.
-                                                          *  For example, if two channels in stereo mode (i.e., 'channel_format' is set to 'I2S_CHANNEL_FMT_RIGHT_LEFT') are active,
-                                                          *  and each channel transfers 32 bits (i.e., 'bits_per_sample' is set to 'I2S_BITS_PER_CHAN_32BIT'),
-                                                          *  then the total number of bytes of a frame is 'channel_format' * 'bits_per_sample' = 2 * 32 / 8 = 8 bytes.
-                                                          *  We assume that the current 'dma_buf_len' is 100, then the real length of the DMA buffer is 8 * 100 = 800 bytes.
-                                                          *  Note that the length of an internal real DMA buffer shouldn't be greater than 4092.
-                                                          */
-
-    bool                    use_apll;                   /*!< I2S using APLL as main I2S clock, enable it to get accurate clock */
-    bool                    tx_desc_auto_clear;         /*!< I2S auto clear tx descriptor if there is underflow condition (helps in avoiding noise in case of data unavailability) */
-    int                     fixed_mclk;                 /*!< I2S using fixed MCLK output. If use_apll = true and fixed_mclk > 0, then the clock output for i2s is fixed and equal to the fixed_mclk value. If fixed_mclk set, mclk_multiple won't take effect */
-    i2s_mclk_multiple_t     mclk_multiple;              /*!< The multiple of I2S master clock(MCLK) to sample rate */
-    i2s_bits_per_chan_t     bits_per_chan;              /*!< I2S total bits in one channel， only take effect when larger than 'bits_per_sample', default '0' means equal to 'bits_per_sample' */
-
-#if SOC_I2S_SUPPORTS_TDM
-    i2s_channel_t           chan_mask;                  /*!< I2S active channel bit mask, set value in `i2s_channel_t` to enable specific channel, the bit map of active channel can not exceed (0x1<<total_chan). */
-    uint32_t                total_chan;                 /*!< I2S Total number of channels. If it is smaller than the biggest active channel number, it will be set to this number automatically. */
-    bool                    left_align;                 /*!< Set to enable left alignment */
-    bool                    big_edin;                   /*!< Set to enable big edin */
-    bool                    bit_order_msb;              /*!< Set to enable msb order */
-    bool                    skip_msk;                   /*!< Set to enable skip mask. If it is enabled, only the data of the enabled channels will be sent, otherwise all data stored in DMA TX buffer will be sent */
-#endif // SOC_I2S_SUPPORTS_TDM
-
-} i2s_driver_config_t;
-
-typedef i2s_driver_config_t i2s_config_t;       // for backward compatible
-typedef intr_handle_t i2s_isr_handle_t;         // for backward compatible
-
-/**
- * @brief I2S event queue types
- *
- */
-typedef enum {
-    I2S_EVENT_DMA_ERROR,
-    I2S_EVENT_TX_DONE,     /*!< I2S DMA finish sent 1 buffer*/
-    I2S_EVENT_RX_DONE,     /*!< I2S DMA finish received 1 buffer*/
-    I2S_EVENT_TX_Q_OVF,    /*!< I2S DMA sent queue overflow*/
-    I2S_EVENT_RX_Q_OVF,    /*!< I2S DMA receive queue overflow*/
-    I2S_EVENT_MAX,         /*!< I2S event max index*/
-} i2s_event_type_t;
-
-/**
- * @brief Event structure used in I2S event queue
- *
- */
-typedef struct {
-    i2s_event_type_t    type;   /*!< I2S event type */
-    size_t              size;   /*!< I2S data size for I2S_DATA event*/
-} i2s_event_t;
-
-/**
- * @brief Set I2S pin number
- *
- * @note
- * The I2S peripheral output signals can be connected to multiple GPIO pads.
- * However, the I2S peripheral input signal can only be connected to one GPIO pad.
- *
- * @param   i2s_num     I2S port number
- *
- * @param   pin         I2S Pin structure, or NULL to set 2-channel 8-bit internal DAC pin configuration (GPIO25 & GPIO26)
- *
- * Inside the pin configuration structure, set I2S_PIN_NO_CHANGE for any pin where
- * the current configuration should not be changed.
- *
- * @note if *pin is set as NULL, this function will initialize both of the built-in DAC channels by default.
- *       if you don't want this to happen and you want to initialize only one of the DAC channels, you can call i2s_set_dac_mode instead.
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_FAIL            IO error
- */
-esp_err_t m_i2s_set_pin(i2s_port_t i2s_num, const i2s_pin_config_t *pin);
-
-#if SOC_I2S_SUPPORTS_PDM_RX
-/**
- * @brief Set PDM mode down-sample rate
- *        In PDM RX mode, there would be 2 rounds of downsample process in hardware.
- *        In the first downsample process, the sampling number can be 16 or 8.
- *        In the second downsample process, the sampling number is fixed as 8.
- *        So the clock frequency in PDM RX mode would be (fpcm * 64) or (fpcm * 128) accordingly.
- * @param i2s_num I2S port number
- * @param downsample i2s RX down sample rate for PDM mode.
- *
- * @note After calling this function, it would call i2s_set_clk inside to update the clock frequency.
- *       Please call this function after I2S driver has been initialized.
- *
- * @return
- *     - ESP_OK Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- */
-esp_err_t m_i2s_set_pdm_rx_down_sample(i2s_port_t i2s_num, i2s_pdm_dsr_t downsample);
-#endif
-
-#if SOC_I2S_SUPPORTS_PDM_TX
-/**
- * @brief Set TX PDM mode up-sample rate
- * @note  If you have set PDM mode while calling 'i2s_driver_install',
- *        default PDM TX upsample parameters have already been set,
- *        no need to call this function again if you don't have to change the default configuration
- *
- * @param i2s_num I2S port number
- * @param upsample_cfg Set I2S PDM up-sample rate configuration
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- */
-esp_err_t m_i2s_set_pdm_tx_up_sample(i2s_port_t i2s_num, const i2s_pdm_tx_upsample_cfg_t *upsample_cfg);
-#endif
-
-/**
- * @brief Install and start I2S driver.
- *
- * @param i2s_num         I2S port number
- *
- * @param i2s_config      I2S configurations - see i2s_config_t struct
- *
- * @param queue_size      I2S event queue size/depth.
- *
- * @param i2s_queue       I2S event queue handle, if set NULL, driver will not use an event queue.
- *
- * This function must be called before any I2S driver read/write operations.
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- *     - ESP_ERR_INVALID_STATE  Current I2S port is in use
- */
-esp_err_t m_i2s_driver_install(i2s_port_t i2s_num, const i2s_config_t *i2s_config, int queue_size, void *i2s_queue);
-
-/**
- * @brief Uninstall I2S driver.
- *
- * @param i2s_num  I2S port number
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_INVALID_STATE I2S port has been uninstalled by others (e.g. LCD i80)
- */
-esp_err_t m_i2s_driver_uninstall(i2s_port_t i2s_num);
-
-/**
- * @brief Write data to I2S DMA transmit buffer.
- *
- * @param i2s_num             I2S port number
- *
- * @param src                 Source address to write from
- *
- * @param size                Size of data in bytes
- *
- * @param[out] bytes_written  Number of bytes written, if timeout, the result will be less than the size passed in.
- *
- * @param ticks_to_wait       TX buffer wait timeout in RTOS ticks. If this
- * many ticks pass without space becoming available in the DMA
- * transmit buffer, then the function will return (note that if the
- * data is written to the DMA buffer in pieces, the overall operation
- * may still take longer than this timeout.) Pass portMAX_DELAY for no
- * timeout.
- *
- * @return
- *     - ESP_OK               Success
- *     - ESP_ERR_INVALID_ARG  Parameter error
- */
-esp_err_t m_i2s_write(i2s_port_t i2s_num, const void *src, size_t size, size_t *bytes_written, TickType_t ticks_to_wait);
-
-/**
- * @brief Write data to I2S DMA transmit buffer while expanding the number of bits per sample. For example, expanding 16-bit PCM to 32-bit PCM.
- *
- * @param i2s_num             I2S port number
- *
- * @param src                 Source address to write from
- *
- * @param size                Size of data in bytes
- *
- * @param src_bits            Source audio bit
- *
- * @param aim_bits            Bit wanted, no more than 32, and must be greater than src_bits
- *
- * @param[out] bytes_written  Number of bytes written, if timeout, the result will be less than the size passed in.
- *
- * @param ticks_to_wait       TX buffer wait timeout in RTOS ticks. If this
- * many ticks pass without space becoming available in the DMA
- * transmit buffer, then the function will return (note that if the
- * data is written to the DMA buffer in pieces, the overall operation
- * may still take longer than this timeout.) Pass portMAX_DELAY for no
- * timeout.
- *
- * Format of the data in source buffer is determined by the I2S
- * configuration (see i2s_config_t).
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_write_expand(i2s_port_t i2s_num, const void *src, size_t size, size_t src_bits, size_t aim_bits, size_t *bytes_written, TickType_t ticks_to_wait);
-
-/**
- * @brief Read data from I2S DMA receive buffer
- *
- * @param i2s_num         I2S port number
- *
- * @param dest            Destination address to read into
- *
- * @param size            Size of data in bytes
- *
- * @param[out] bytes_read Number of bytes read, if timeout, bytes read will be less than the size passed in.
- *
- * @param ticks_to_wait   RX buffer wait timeout in RTOS ticks. If this many ticks pass without bytes becoming available in the DMA receive buffer, then the function will return (note that if data is read from the DMA buffer in pieces, the overall operation may still take longer than this timeout.) Pass portMAX_DELAY for no timeout.
- *
- * @note If the built-in ADC mode is enabled, we should call i2s_adc_enable and i2s_adc_disable around the whole reading process,
- *       to prevent the data getting corrupted.
- *
- * @return
- *     - ESP_OK               Success
- *     - ESP_ERR_INVALID_ARG  Parameter error
- */
-esp_err_t m_i2s_read(i2s_port_t i2s_num, void *dest, size_t size, size_t *bytes_read, TickType_t ticks_to_wait);
-
-/**
- * @brief Set sample rate used for I2S RX and TX.
- *
- * The bit clock rate is determined by the sample rate and i2s_config_t configuration parameters (number of channels, bits_per_sample).
- *
- * `bit_clock = rate * (number of channels) * bits_per_sample`
- *
- * @param i2s_num  I2S port number
- *
- * @param rate I2S sample rate (ex: 8000, 44100...)
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- */
-esp_err_t m_i2s_set_sample_rates(i2s_port_t i2s_num, uint32_t rate);
-
-/**
- * @brief Stop I2S driver
- *
- * There is no need to call i2s_stop() before calling i2s_driver_uninstall().
- *
- * Disables I2S TX/RX, until i2s_start() is called.
- *
- * @param i2s_num  I2S port number
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_stop(i2s_port_t i2s_num);
-
-/**
- * @brief Start I2S driver
- *
- * It is not necessary to call this function after i2s_driver_install() (it is started automatically), however it is necessary to call it after i2s_stop().
- *
- *
- * @param i2s_num  I2S port number
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_start(i2s_port_t i2s_num);
-
-/**
- * @brief Zero the contents of the TX DMA buffer.
- *
- * Pushes zero-byte samples into the TX DMA buffer, until it is full.
- *
- * @param i2s_num  I2S port number
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_zero_dma_buffer(i2s_port_t i2s_num);
-
-#if SOC_I2S_SUPPORTS_PCM
-/**
- * @brief Configure I2S a/u-law decompress or compress
- *
- * @note  This function should be called after i2s driver installed
- *        Only take effecttive when the i2s 'communication_format' is set to 'I2S_COMM_FORMAT_STAND_PCM_SHORT' or 'I2S_COMM_FORMAT_STAND_PCM_LONG'
- *
- * @param i2s_num  I2S port number
- *
- * @param pcm_cfg  including mode selection and a/u-law decompress or compress configuration paramater
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t i2s_pcm_config(i2s_port_t i2s_num, const i2s_pcm_cfg_t *pcm_cfg);
-#endif
-
-/**
- * @brief Set clock & bit width used for I2S RX and TX.
- *
- * Similar to i2s_set_sample_rates(), but also sets bit width.
- *
- * 1. stop i2s;
- * 2. calculate mclk, bck, bck_factor
- * 3. malloc dma buffer;
- * 4. start i2s
- *
- * @param i2s_num  I2S port number
- *
- * @param rate I2S sample rate (ex: 8000, 44100...)
- *
- * @param bits_cfg I2S bits configuration
- *             the low 16 bits is for data bits per sample in one channel (see 'i2s_bits_per_sample_t')
- *             the high 16 bits is for total bits in one channel (see 'i2s_bits_per_chan_t')
- *             high 16bits =0 means same as the bits per sample.
- *
- * @param ch I2S channel, (I2S_CHANNEL_MONO, I2S_CHANNEL_STEREO or specific channel in TDM mode)
- *
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- *     - ESP_ERR_NO_MEM      Out of memory
- */
-esp_err_t m_i2s_set_clk(i2s_port_t i2s_num, uint32_t rate, uint32_t bits_cfg, i2s_channel_t ch);
-
-/**
- * @brief get clock set on particular port number.
- *
- * @param i2s_num  I2S port number
- *
- * @return
- *     - actual clock set by i2s driver
- */
-float m_i2s_get_clk(i2s_port_t i2s_num);
-
-#if SOC_I2S_SUPPORTS_ADC
-/**
- * @brief Set built-in ADC mode for I2S DMA, this function will initialize ADC pad,
- *        and set ADC parameters.
- * @note  In this mode, the ADC maximum sampling rate is 150KHz. Set the sampling rate through ``i2s_config_t``.
- * @param adc_unit    SAR ADC unit index
- * @param adc_channel ADC channel index
- * @return
- *     - ESP_OK              Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t m_i2s_set_adc_mode(adc_unit_t adc_unit, adc1_channel_t adc_channel);
-
-/**
- * @brief Start to use I2S built-in ADC mode
- * @note This function would acquire the lock of ADC to prevent the data getting corrupted
- *       during the I2S peripheral is being used to do fully continuous ADC sampling.
- *
- * @param i2s_num i2s port index
- * @return
- *     - ESP_OK                Success
- *     - ESP_ERR_INVALID_ARG   Parameter error
- *     - ESP_ERR_INVALID_STATE Driver state error
- */
-esp_err_t m_i2s_adc_enable(i2s_port_t i2s_num);
-
-/**
- * @brief Stop to use I2S built-in ADC mode
- * @param i2s_num i2s port index
- * @note This function would release the lock of ADC so that other tasks can use ADC.
- * @return
- *     - ESP_OK                 Success
- *     - ESP_ERR_INVALID_ARG    Parameter error
- *     - ESP_ERR_INVALID_STATE  Driver state error
- */
-esp_err_t m_i2s_adc_disable(i2s_port_t i2s_num);
-#endif // SOC_I2S_SUPPORTS_ADC
-
-#if SOC_I2S_SUPPORTS_DAC
-/**
- * @brief Set I2S dac mode, I2S built-in DAC is disabled by default
- *
- * @param dac_mode DAC mode configurations - see i2s_dac_mode_t
- *
- * @note Built-in DAC functions are only supported on I2S0 for current ESP32 chip.
- *       If either of the built-in DAC channel are enabled, the other one can not
- *       be used as RTC DAC function at the same time.
- *
- * @return
- *     - ESP_OK               Success
- *     - ESP_ERR_INVALID_ARG  Parameter error
- */
-esp_err_t m_i2s_set_dac_mode(i2s_dac_mode_t dac_mode);
-#endif //SOC_I2S_SUPPORTS_DAC
-
-/**
- * @brief Associate GPIO MUX signal with GPIO pad.
- *
- * @param gpio Pad identifier or -1 for no connection
- * @param signal_idx Signal index to connect
- * @param out_inv Output inversion flag
- * @param oen_inv Output enable inversion flag
- *
- */
-void m_gpio_matrix_out_check_and_set(gpio_num_t gpio, uint32_t signal_idx, bool out_inv, bool oen_inv);
-
-#ifdef __cplusplus
-}
-#endif
-#endif // defined(SUPPORT_I2S)

From 68d169566be28f441fbeaf1cfc192386c89dabf2 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 28 Aug 2026 16:01:18 -0400
Subject: [PATCH 19/34] Rename new frame method

---
 src/output/OutputCommon.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/output/OutputCommon.cpp b/src/output/OutputCommon.cpp
index 21d0369af..dd6169ff8 100644
--- a/src/output/OutputCommon.cpp
+++ b/src/output/OutputCommon.cpp
@@ -63,7 +63,7 @@ void c_OutputCommon::BaseGetStatus (JsonObject & jsonStatus)
 } // GetStatus
 
 //----------------------------------------------------------------------------
-void c_OutputCommon::ReportNewFrame ()
+void IRAM_ATTR c_OutputCommon::ISR_ReportNewFrame ()
 {
     // DEBUG_START;
 
@@ -111,9 +111,9 @@ void c_OutputCommon::WriteChannelData (uint32_t StartChannelId, uint32_t Channel
 
     if((StartChannelId + ChannelCount) > OutputBufferSize)
     {
-        DEBUG_V("ERROR: Writting beyond the end of the output buffer");
-        DEBUG_V(String("StartChannelId: 0x") + String(StartChannelId, HEX));
-        DEBUG_V(String("  ChannelCount: 0x") + String(ChannelCount));
+        // DEBUG_V("ERROR: Writting beyond the end of the output buffer");
+        // DEBUG_V(String("StartChannelId: 0x") + String(StartChannelId, HEX));
+        // DEBUG_V(String("  ChannelCount: 0x") + String(ChannelCount));
     }
     else
     {

From 7ad98b9a9e83e6c18970f284613f02557b7997b5 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 31 Aug 2026 21:47:26 -0400
Subject: [PATCH 20/34] Lots of cleanup. Moved all register access
 functionality to the parallel driver. This layer works only with the DMA
 buffers.

---
 include/output/OutputI2S.hpp |  80 +++----
 src/output/OutputI2S.cpp     | 442 +++++++++++++----------------------
 2 files changed, 198 insertions(+), 324 deletions(-)

diff --git a/include/output/OutputI2S.hpp b/include/output/OutputI2S.hpp
index e27eb2bd5..5d5ef8302 100644
--- a/include/output/OutputI2S.hpp
+++ b/include/output/OutputI2S.hpp
@@ -20,70 +20,66 @@
 
 #ifdef SUPPORT_I2S
 #include "ESPixelStick.h"
-#include "m_i2s.h"
+#include "i2s_parallel.hpp"
 #include "driver/gpio.h"
 
-// a slot is one bit in the output item
-#define I2S_NUM_SLOTA i2s_bits_per_chan_t::I2S_BITS_PER_CHAN_8BIT
-#define I2S_MAX_NUM_PORTS 8
-union I2S_item_t
-{
-    struct
-    {
-        uint8_t data;
-        uint8_t reserved;
-    };
-    uint16_t RawData;
-};
+// #define USE_I2S_DEBUG_COUNTERS
 
 class c_OutputI2S
 {
 public:
-struct OutputI2SChannelConfig_t
-{
-    uint32_t    I2SChannelId;
-    gpio_num_t  DataPin;
-    void        *arg;
-    bool        (*GetNextIntensityBit) (void*arg, I2S_item_t * data, uint32_t numSlices) = nullptr;
-    bool        IsActive;
-};
+    // a slot is one bit in the output item
+    #define I2S_NUM_SLOTA i2s_bits_per_chan_t::I2S_BITS_PER_CHAN_8BIT
+    #define I2S_MAX_NUM_PORTS 8
+    typedef uint8_t I2S_Item_t;
 
-private:
+    struct OutputI2SChannelConfig_t
+    {
+        uint32_t    I2SChannelId;
+        gpio_num_t  DataPin;
+        void        *arg;
+        void        (*GetNextIntensityBitSlices) (void*arg, I2S_Item_t * data, uint32_t numSlices) = nullptr;
+        bool        IsActive;
+    };
 
-    const int   clock_pin = I2S_PIN_NO_CHANGE; // Pixel Clock
-    bool        OutputIsPaused = false;
-    double      I2S_TickTimeInNS;
+    // must be a multiple of 32
+    #define I2S_NumSendBufferItems 1024
 
-    #define I2STargetBitSliceTimeNS 150
+    struct TransmitDmaBuffer_t
+    {
+        alignas (4) lldesc_t   header; // must be first
+        #ifdef USE_I2S_DEBUG_COUNTERS
+        alignas (4) uint32_t   id;
+        alignas (4) uint32_t   UsageCounter;
+        #endif // def USE_I2S_DEBUG_COUNTERS
+        alignas (4) I2S_Item_t data[I2S_NumSendBufferItems];
+    };
 
-    uint32_t SetBitSliceLen (uint8_t ChanId, double BitSliceLenNs);
-    void StartSendingData   ();
-    void StopSendingData    ();
-    void InitI2Sdriver      ();
+private:
+    // array of configuration settings
+    OutputI2SChannelConfig_t OutputI2SSlotConfigs[I2S_MAX_NUM_PORTS];
 
-#ifndef HasBeenInitialized
-    bool HasBeenInitialized = false;
-#endif // ndef HasBeenInitialized
+    // must be more than zero
+    #define I2S_NumSendBuffers 4
 
-    TaskHandle_t I2sTaskHandle = NULL;
+    // Class to manage the io device
+    esp_i2s_parallel    i2sParallel;
 
 public:
     c_OutputI2S ();
     virtual ~c_OutputI2S ();
 
     void        Begin               ();
-    uint8_t     RegisterSlotDevice  (OutputI2SChannelConfig_t config);
-    void        RemoveSlotDevice    (OutputI2SChannelConfig_t config);
+    void        RegisterSlotDevice  (OutputI2SChannelConfig_t config, uint32_t * DataBit, uint32_t * DataBitMask);
+    void        RemoveSlotDevice    (uint32_t I2SChannelId);
     void        GetStatus           (ArduinoJson::JsonObject& jsonStatus);
-    void        PauseOutput         (bool State);
     void        GetDriverName       (String &value)  { value = F("I2S"); }
     uint32_t    GetBitTimeSlices    (uint32_t BitTimeInNanoSec);
     void        SetOutputState      (uint32_t I2SChannelId, bool NewState);
     void        SetGpio             (uint32_t I2SChannelId, gpio_num_t NewGpio);
+    void        ISR_Handler         (void * _TransmitDmaBuffer);
 
-// #define USE_I2S_DEBUG_COUNTERS
 #ifdef USE_I2S_DEBUG_COUNTERS
-// #define IncludeBufferData
    // debug counters
     struct I2SDebugCounters_t
     {
@@ -94,7 +90,11 @@ struct OutputI2SChannelConfig_t
         uint32_t I2SXmtFills = 0;
         uint32_t ISRpaused = 0;
         uint32_t WriteToBuffer = 0;
-    } ;
+        uint32_t ISR_handler_count = 0;
+        uint32_t ISR_FillBuffer = 0;
+        uint32_t BufferOwnerFlagError = 0;
+        uint32_t ISR_NullBufferPointer = 0;
+    };
     I2SDebugCounters_t I2SDebugCounters;
 
 #define I2S_DEBUG_INC_COUNTER(p) (++I2SDebugCounters.p)
diff --git a/src/output/OutputI2S.cpp b/src/output/OutputI2S.cpp
index dc724ffa8..3ca87f3a2 100644
--- a/src/output/OutputI2S.cpp
+++ b/src/output/OutputI2S.cpp
@@ -17,65 +17,64 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(SUPPORT_I2S)
+#if defined (SUPPORT_I2S)
 
 #include "output/OutputI2S.hpp"
-#include "m_i2s.h"
 #include "driver/gpio.h"
-#include "soc/io_mux_reg.h"
 #include "esp_rom_gpio.h"
 #include <numeric>
+#include "esp_attr.h"
 
-#define I2S_DeviceID i2s_port_t::I2S_NUM_0
-#define I2S_Device I2S0
-#define I2S_DataStartSignal I2S0O_DATA_OUT8_IDX
+//----------------------------------------------------------------------------
+// array of transmit buffers that get chained into a ring
+static c_OutputI2S::TransmitDmaBuffer_t TransmitDmaBuffers[I2S_NumSendBuffers] DRAM_ATTR __attribute__ ( (aligned (4)));
 
-static c_OutputI2S::OutputI2SChannelConfig_t OutputI2SSlotConfigs[I2S_MAX_NUM_PORTS];
-#define                         I2S_NumSendBufferItems 512
-static I2S_item_t               I2S_SendBuffer[I2S_NumSendBufferItems];
+//----------------------------------------------------------------------------
+static void IRAM_ATTR IRQ_Handler (void * arg, void * buffer)
+{
+    static_cast<c_OutputI2S*>(arg)->ISR_Handler(buffer);
+} // IRQ_Handler
 
 //----------------------------------------------------------------------------
-void I2S_Task(void*)
+void IRAM_ATTR c_OutputI2S::ISR_Handler (void * _TransmitDmaBuffer)
 {
-    size_t bytes_written = 0;
-    DEBUG_V(String("Current CPU ID: ") + String(xPortGetCoreID()));
+    I2S_DEBUG_INC_COUNTER(ISR_handler_count);
+
+    TransmitDmaBuffer_t * TransmitDmaBuffer = (TransmitDmaBuffer_t*)_TransmitDmaBuffer;
 
-    while(true)
+    #ifdef USE_I2S_DEBUG_COUNTERS
+    // show we have used the buffer
+    TransmitDmaBuffer->UsageCounter++;
+
+    if (TransmitDmaBuffer->header.owner == I2sParallelDmaBufferOwnerDMA)
     {
-        bool FoundActiveChannel = false;
-        // DEBUG_V("Processing all possible channels");
-        for (auto & CurrentChannel : OutputI2SSlotConfigs)
-        {
-            // DEBUG_V(String("Processing channel: 0x") + String(uint32_t(CurrentChannel.pThis), HEX));
-            // do we have a driver on this channel?
-            if(true == CurrentChannel.IsActive)
-            {
-                FoundActiveChannel = true;
+        I2S_DEBUG_INC_COUNTER(BufferOwnerFlagError);
+    }
+    #endif // def USE_I2S_DEBUG_COUNTERS
 
-                // DEBUG_V(String("Getting more data for channel: 0x") + String(uint32_t(CurrentChannel.arg), HEX));
+    I2S_DEBUG_INC_COUNTER(ISR_FillBuffer);
 
-                // invoke the channel
-                CurrentChannel.GetNextIntensityBit(CurrentChannel.arg, I2S_SendBuffer, I2S_NumSendBufferItems);
-            }
-        }
+    // reset the buffer management fields
+    TransmitDmaBuffer->header.length = TransmitDmaBuffer->header.size;
+    TransmitDmaBuffer->header.offset = 0; // Always start to the begining of the buffer
 
-        if(FoundActiveChannel)
-        {
-            // send the data to the I2S driver
-            size_t bytes_written = 0;
-            m_i2s_write(I2S_DeviceID, I2S_SendBuffer, sizeof(I2S_SendBuffer), &bytes_written, portMAX_DELAY);
-            // DEBUG_V(String("Bytes written: ") + String(bytes_written) + " bytes");
-        }
-        else
+    // fill in the new data
+    for (auto & CurrentPort : OutputI2SSlotConfigs)
+    {
+        if (CurrentPort.IsActive)
         {
-            // DEBUG_V("No active channels, pausing task");
-            vTaskDelay(2000 / portTICK_PERIOD_MS);
+            CurrentPort.GetNextIntensityBitSlices (CurrentPort.arg, (I2S_Item_t *) (TransmitDmaBuffer->header.buf), TransmitDmaBuffer->header.size);
         }
     }
-} // I2S_Task
+
+    // hand the buffer back to the dma engine
+    TransmitDmaBuffer->header.eof = true; // cause an end of buffer interrupt
+    TransmitDmaBuffer->header.owner = I2sParallelDmaBufferOwnerDMA;
+
+} // ISR_Handler
 
 //----------------------------------------------------------------------------
-c_OutputI2S::c_OutputI2S()
+c_OutputI2S::c_OutputI2S ()
 {
     // DEBUG_START;
 
@@ -83,12 +82,38 @@ c_OutputI2S::c_OutputI2S()
     for (auto & CurrentChannel : OutputI2SSlotConfigs)
     {
         CurrentChannel.I2SChannelId = id++;
-        CurrentChannel.DataPin = gpio_num_t(I2S_PIN_NO_CHANGE);
+        CurrentChannel.DataPin = gpio_num_t (I2S_PIN_NO_CHANGE);
         CurrentChannel.arg = nullptr;
-        CurrentChannel.GetNextIntensityBit = nullptr;
+        CurrentChannel.GetNextIntensityBitSlices = nullptr;
         CurrentChannel.IsActive = false;
     }
 
+    uint BufferId = 0;
+    for (auto &CurrentDmaBuffer : TransmitDmaBuffers)
+    {
+        #ifdef USE_I2S_DEBUG_COUNTERS
+        CurrentDmaBuffer.id = BufferId;
+        CurrentDmaBuffer.UsageCounter = 0;
+        #endif // def USE_I2S_DEBUG_COUNTERS
+        CurrentDmaBuffer.header.size = sizeof (CurrentDmaBuffer.data);
+        CurrentDmaBuffer.header.length = sizeof (CurrentDmaBuffer.data);
+        CurrentDmaBuffer.header.offset = 0; // Always start to the begining of the buffer
+        CurrentDmaBuffer.header.sosf = false;
+        CurrentDmaBuffer.header.eof = true; // cause an end of buffer interrupt
+        CurrentDmaBuffer.header.buf = (uint8_t*)&CurrentDmaBuffer.data[0];
+        CurrentDmaBuffer.header.qe.stqe_next = & (TransmitDmaBuffers[BufferId + 1].header);
+        CurrentDmaBuffer.header.owner = I2sParallelDmaBufferOwnerDMA;
+
+        // clear the data space
+        memset (CurrentDmaBuffer.data, 0xff, CurrentDmaBuffer.header.size);
+
+        // next buffer ID
+        ++BufferId;
+    }
+
+    // link last buffer to the first buffer
+    TransmitDmaBuffers[I2S_NumSendBuffers-1].header.qe.stqe_next = & (TransmitDmaBuffers[0].header);
+
     // DEBUG_END;
 } // c_OutputI2S
 
@@ -97,155 +122,44 @@ c_OutputI2S::~c_OutputI2S ()
 {
     // DEBUG_START;
 
-    if (HasBeenInitialized)
-    {
-
-    }
-
     // DEBUG_END;
 } // ~c_OutputI2S
 
 //----------------------------------------------------------------------------
-static uint32_t gcd(uint32_t a, uint32_t b)
+void c_OutputI2S::Begin ()
 {
-    while (b != 0)
-    {
-        uint32_t temp = b;
-        b = a % b;
-        a = temp;
-    }
-  return a;
-}
+    // DEBUG_START;
 
-//----------------------------------------------------------------------------
-void c_OutputI2S::InitI2Sdriver ()
-{
+    do // once
+    {
         // 1. Configure the core I2S settings
-        i2s_config_t i2s_config;
-            i2s_config.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX);
-            i2s_config.sample_rate = 10; // This is over written later
-            i2s_config.bits_per_chan = i2s_bits_per_chan_t::I2S_BITS_PER_CHAN_DEFAULT; // follow bits_per_sample
-            i2s_config.bits_per_sample = i2s_bits_per_sample_t::I2S_BITS_PER_SAMPLE_16BIT;
-            i2s_config.channel_format = i2s_channel_fmt_t::I2S_CHANNEL_FMT_RIGHT_LEFT;
-            i2s_config.communication_format = i2s_comm_format_t::I2S_COMM_FORMAT_STAND_I2S;
-            i2s_config.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
-            i2s_config.dma_buf_count = 2;
-            i2s_config.dma_buf_len = sizeof(I2S_SendBuffer);
-            i2s_config.use_apll = false;
-            i2s_config.fixed_mclk = 0;
-            i2s_config.tx_desc_auto_clear = true;
-
-        // DEBUG_V(String("Install driver onto I2S Port ") + String(I2S_DeviceID));
-        if(ESP_OK != m_i2s_driver_install(I2S_DeviceID, &i2s_config, 0, NULL))
-        {
-            logcon(F("Failed to install I2S driver"));
-        }
-
-        //DEBUG_V("Stop I2S Driver");
-        m_i2s_stop(I2S_DeviceID);
-
-        // DEBUG_V("Set clock pins");
-        i2s_pin_config_t pin_config =
-        {
-            .mck_io_num = I2S_PIN_NO_CHANGE,
-            .bck_io_num = I2S_PIN_NO_CHANGE,
-            .ws_io_num = I2S_PIN_NO_CHANGE,
-            .data_out_num = I2S_PIN_NO_CHANGE,
-            .data_in_num = I2S_PIN_NO_CHANGE
-        };
-        if(ESP_OK != m_i2s_set_pin(I2S_DeviceID, &pin_config))
+        i2s_parallel_config_t i2s_config;
+            i2s_config.port = i2s_port_t::I2S_NUM_1;
+            i2s_config.gpio_clk = I2S_PIN_NO_CHANGE;
+            i2s_config.sample_width = i2s_parallel_sample_width_t::I2S_PARALLEL_WIDTH_8;
+            i2s_config.sample_rate = 800000 * 4; // 800khz divided into 4 time slices
+            i2s_config.invert_clk = false;
+            i2s_config.irq_hndlr = IRQ_Handler;
+            i2s_config.arg1 = this;
+            memset (i2s_config.gpios_bus, I2S_PIN_NO_CHANGE, sizeof (i2s_config.gpios_bus));
+    
+        // DEBUG_V (String ("Install driver onto I2S Port ") + String (I2S_DeviceID));
+        if (ESP_OK != i2sParallel.driver_install (i2s_config))
         {
-            logcon(F("Failed to set I2S pin configuration"));
-        }
-
-        // DEBUG_V("Set i2s mode to LCD mode");
-        I2S_Device.conf2.lcd_en = true;
-        I2S_Device.conf2.camera_en = false;
-
-        double ClockFrequency = 80000000.0;
-        double TargetTickNS = I2STargetBitSliceTimeNS;
-        double ClkNS = (1.0 / ClockFrequency) * 1000000000;
-        double ClkDiv = TargetTickNS / ClkNS;
-        double integralPart;
-        double fractionalPart = std::modf(ClkDiv, &integralPart);
-        fractionalPart = std::abs(fractionalPart);
-        double denominator = std::pow(10,9);
-        double numerator = std::round(fractionalPart * denominator);
-        double commonDivisor = gcd(numerator, denominator);
-        numerator = numerator / commonDivisor;
-        denominator = denominator / commonDivisor;
-        I2S_TickTimeInNS = TargetTickNS;
-
-        if(int(denominator) == 0 || int(numerator) == 0)
-        {
-            denominator = 0.0;
-            numerator = 0.0;
-        }
-        // Setup i2s clock
-        I2S_Device.clkm_conf.clka_en = false;
-        I2S_Device.clkm_conf.clk_en = false; // Use PLL_D2_CLK (160MHz)
-        I2S_Device.clkm_conf.clkm_div_num = int(ClkDiv);
-        I2S_Device.clkm_conf.clkm_div_a = int(denominator);
-        I2S_Device.clkm_conf.clkm_div_b = int(numerator);
-        I2S_Device.sample_rate_conf.tx_bck_div_num = 4;
-        I2S_Device.sample_rate_conf.tx_bits_mod = i2s_bits_per_chan_t::I2S_BITS_PER_CHAN_8BIT;
-
-        // DEBUG_V(String("  ClockFrequency: ") + String(ClockFrequency));
-        // DEBUG_V(String("           ClkNS: ") + String(ClkNS, 10));
-        // DEBUG_V(String("          ClkDiv: ") + String(ClkDiv, 10));
-        // DEBUG_V(String("    TargetTickNS: ") + String(TargetTickNS, 10));
-        // DEBUG_V(String("  fractionalPart: ") + String(fractionalPart, 10));
-        // DEBUG_V(String("     denominator: ") + String(denominator, 10));
-        // DEBUG_V(String("       numerator: ") + String(numerator, 10));
-        // DEBUG_V(String("   commonDivisor: ") + String(commonDivisor, 10));
-        // DEBUG_V(String("    clkm_div_num: ") + String(I2S_Device.clkm_conf.clkm_div_num));
-        // DEBUG_V(String("      clkm_div_b: ") + String(I2S_Device.clkm_conf.clkm_div_b));
-        // DEBUG_V(String("      clkm_div_a: ") + String(I2S_Device.clkm_conf.clkm_div_a));
-
-        // Dictated by datasheet
-        I2S_Device.fifo_conf.tx_fifo_mod_force_en = true;
-        I2S_Device.fifo_conf.tx_fifo_mod = 2; // I2S_TX_CHAN_MODE_MONO;
-
-        I2S_Device.conf1.tx_stop_en = false;
-        I2S_Device.conf1.tx_zeros_rm_en = false;
-        I2S_Device.conf1.tx_pcm_conf = 0;
-        I2S_Device.conf1.tx_pcm_bypass = true;
-
-        // DEBUG_V("3. Enable LCD mode specific register flags");
-        I2S_Device.conf.val = 0;
-        I2S_Device.conf.tx_slave_mod = false;
-
-        // DEBUG_V("4. disconnect all of the I2S connections from the matrix");
-        for (auto currentConfig : OutputI2SSlotConfigs)
-        {
-            m_gpio_matrix_out_check_and_set(currentConfig.DataPin, I2S_DataStartSignal + currentConfig.I2SChannelId, false, false);
+            String FailReason = (F ("Failed to install I2S driver"));
+            RequestReboot (FailReason, 10000, true);
+            break;
         }
-
-        // set the reserved bits to 1 to avoid sending garbage data
-        memset(&I2S_SendBuffer, 0xFF, sizeof(I2S_SendBuffer));
-
-        // DEBUG_V("Start the peripheral clocking");
-        if(ESP_OK != m_i2s_start(I2S_DeviceID))
+        // DEBUG_V ();
+    
+        // start the outputs
+        if (ESP_OK != i2sParallel.send_dma (& (TransmitDmaBuffers[0].header)))
         {
-            logcon(F("Failed to start I2S peripheral"));
+            logcon (F ("Could not start the I2S DMA channel"));
         }
+    
+        // DEBUG_V ();
 
-} // InitI2Sdriver
-
-//----------------------------------------------------------------------------
-void c_OutputI2S::Begin ()
-{
-    // DEBUG_START;
-
-    do // once
-    {
-        InitI2Sdriver();
-
-        // DEBUG_V();
-        xTaskCreatePinnedToCore(I2S_Task, "I2S_Task", 4096, NULL, 5, &I2sTaskHandle, 1);
-        vTaskPrioritySet(I2sTaskHandle, 5);
-
-        HasBeenInitialized = true;
     } while (false);
 
     // DEBUG_END;
@@ -257,116 +171,80 @@ void c_OutputI2S::GetStatus (ArduinoJson::JsonObject& jsonStatus)
 {
     // // DEBUG_START;
 
-#ifdef USE_I2S_DEBUG_COUNTERS
-    jsonStatus[F("OutputIsPaused")] = OutputIsPaused;
-    JsonObject debugStatus = jsonStatus["I2S Debug"].to<JsonObject>();
-    debugStatus["I2SChannelId"]                 = OutputI2SConfig.I2SChannelId;
-    debugStatus["GPIO"]                         = OutputI2SConfig.DataPin;
+    #ifdef USE_I2S_DEBUG_COUNTERS
+    jsonStatus[F ("ISR_handler_count")]     = I2S_DEBUG_COUNTER(ISR_handler_count);
+    jsonStatus[F ("ISR_NullBufferPointer")] = String (I2S_DEBUG_COUNTER(ISR_NullBufferPointer));
+    jsonStatus[F ("BufferOwnerFlagError")]  = I2S_DEBUG_COUNTER(BufferOwnerFlagError);
+    jsonStatus[F ("ISR_NextBuffer")]        = I2S_DEBUG_COUNTER(ISR_FillBuffer);
 
-    debugStatus["IntensityBitsSent"]            = I2S_DEBUG_COUNTER(IntensityBitsSent);
-    debugStatus["I2SEntriesTransfered"]         = I2S_DEBUG_COUNTER(I2SEntriesTransfered);
-    debugStatus["I2SXmtFills"]                  = I2S_DEBUG_COUNTER(I2SXmtFills);
-#endif // def USE_I2S_DEBUG_COUNTERS
+    JsonObject debugStatus = jsonStatus["I2S Debug"].to<JsonObject> ();
+
+    debugStatus["IntensityBitsSent"]            = I2S_DEBUG_COUNTER (IntensityBitsSent);
+    debugStatus["I2SEntriesTransfered"]         = I2S_DEBUG_COUNTER (I2SEntriesTransfered);
+    debugStatus["I2SXmtFills"]                  = I2S_DEBUG_COUNTER (I2SXmtFills);
+    #endif // def USE_I2S_DEBUG_COUNTERS
     // // DEBUG_END;
 } // GetStatus
 
 //----------------------------------------------------------------------------
-uint32_t c_OutputI2S::SetBitSliceLen (uint8_t ChanId, double BitSliceLenNs)
-{
-    // DEBUG_START;
-    uint32_t Result = 0;
-
-    // DEBUG_END;
-    return Result;
-} // SetBitDuration
-
-//----------------------------------------------------------------------------
-void c_OutputI2S::PauseOutput(bool PauseOutput)
-{
-    /// DEBUG_START;
-
-    if (OutputIsPaused == PauseOutput)
-    {
-        ///DEBUG_V("no change. Ignore the call");
-    }
-    else if (PauseOutput)
-    {
-        ///DEBUG_V("stop the output");
-        // Stop the transmitter
-        m_i2s_stop(I2S_DeviceID);
-    }
-
-    OutputIsPaused = PauseOutput;
-
-    ///DEBUG_END;
-} // PauseOutput
-
-//----------------------------------------------------------------------------
-void c_OutputI2S::StopSendingData ()
-{
-    // DEBUG_START;
-
-    do // once
-    {
-    } while(false);
-
-    // DEBUG_END;
-} // StopSendingData
-
-//----------------------------------------------------------------------------
-void c_OutputI2S::StartSendingData ()
+void c_OutputI2S::RegisterSlotDevice  (OutputI2SChannelConfig_t config, uint32_t * DataBit, uint32_t * DataBitMask)
 {
     // DEBUG_START;
 
     do // once
     {
-        if(OutputIsPaused)
+        if (config.I2SChannelId >= I2S_MAX_NUM_PORTS)
+        {
+            logcon (F ("Invalid I2S channel ID"));
+            break;
+        }
+        if (nullptr == config.GetNextIntensityBitSlices)
         {
-            // DEBUG_V("Paused");
+            logcon (F ("Invalid GetNextIntensityBit function pointer"));
             break;
         }
 
-        // DEBUG_V();
+        auto & currentConfig = OutputI2SSlotConfigs[config.I2SChannelId];
+        currentConfig.arg = config.arg;
+        currentConfig.GetNextIntensityBitSlices = config.GetNextIntensityBitSlices;
 
-    } while(false);
+        *DataBit = 1 << config.I2SChannelId;
+        *DataBitMask = ~(1 << config.I2SChannelId);
+        // DEBUG_V (String ("DataBit: 0x") + String (*DataBit, HEX));
+        SetGpio (config.I2SChannelId, config.DataPin);
+
+        // must be last
+        currentConfig.IsActive = config.IsActive;
+    } while (false);
 
     // DEBUG_END;
-} // StartSendingData
+} // RegisterSlotDevice
 
 //----------------------------------------------------------------------------
-uint8_t c_OutputI2S::RegisterSlotDevice  (OutputI2SChannelConfig_t config)
+void c_OutputI2S::RemoveSlotDevice  (uint32_t I2SChannelId)
 {
     // DEBUG_START;
 
-    uint8_t DataBit = 0;
-
     do // once
     {
-        if (config.I2SChannelId >= I2S_MAX_NUM_PORTS)
-        {
-            logcon(F("Invalid I2S channel ID"));
-            break;
-        }
-        if (nullptr == config.GetNextIntensityBit)
+        if (I2SChannelId >= I2S_MAX_NUM_PORTS)
         {
-            logcon(F("Invalid GetNextIntensityBit function pointer"));
+            logcon (F ("Invalid I2S channel ID"));
             break;
         }
+        auto & currentConfig = OutputI2SSlotConfigs[I2SChannelId];
 
-        auto & currentConfig = OutputI2SSlotConfigs[config.I2SChannelId];
-        currentConfig.arg = config.arg;
-        currentConfig.GetNextIntensityBit = config.GetNextIntensityBit;
-        currentConfig.IsActive = config.IsActive;
-        
-        DataBit = 1 << config.I2SChannelId;
+        // must be first
+        currentConfig.IsActive = false;
+        currentConfig.arg = nullptr;
+        currentConfig.GetNextIntensityBitSlices = nullptr;
 
-        SetGpio(config.I2SChannelId, config.DataPin);
+        SetGpio (I2SChannelId, gpio_num_t(I2S_PIN_NO_CHANGE));
 
-    } while(false);
+    } while (false);
 
     // DEBUG_END;
-    return DataBit;
-} // RegisterSlotDevice
+} // RemoveSlotDevice
 
 //----------------------------------------------------------------------------
 void c_OutputI2S::SetGpio (uint32_t I2SChannelId, gpio_num_t NewGpio)
@@ -377,31 +255,31 @@ void c_OutputI2S::SetGpio (uint32_t I2SChannelId, gpio_num_t NewGpio)
     {
         if (I2SChannelId >= I2S_MAX_NUM_PORTS)
         {
-            logcon(F("ERROR: Invalid I2S channel ID"));
+            logcon (F ("ERROR: Invalid I2S channel ID"));
             break;
         }
 
-        // DEBUG_V(String("I2SChannelId: ") + String(I2SChannelId));
-        // DEBUG_V(String("     NewGpio: ") + String(NewGpio));
-        // DEBUG_V(String("     DataPin: ") + String(OutputI2SSlotConfigs[I2SChannelId].DataPin));
+        // DEBUG_V (String ("I2SChannelId: ") + String (I2SChannelId));
+        // DEBUG_V (String ("     NewGpio: ") + String (NewGpio));
+        // DEBUG_V (String ("     DataPin: ") + String (OutputI2SSlotConfigs[I2SChannelId].DataPin));
 
-        if(NewGpio == OutputI2SSlotConfigs[I2SChannelId].DataPin)
+        if (NewGpio == OutputI2SSlotConfigs[I2SChannelId].DataPin)
         {
-            // DEBUG_V("GPIO did not change. Ignore the request");
+            // DEBUG_V ("GPIO did not change. Ignore the request");
             break;
         }
 
-        if(I2S_PIN_NO_CHANGE != OutputI2SSlotConfigs[I2SChannelId].DataPin)
+        if (I2S_PIN_NO_CHANGE != OutputI2SSlotConfigs[I2SChannelId].DataPin)
         {
-            // DEBUG_V("release the old GPIO from the matrix");
-            ResetGpio(OutputI2SSlotConfigs[I2SChannelId].DataPin);
+            // DEBUG_V ("release the old GPIO from the matrix");
+            ResetGpio (OutputI2SSlotConfigs[I2SChannelId].DataPin);
         }
 
-        // DEBUG_V("attach the new GPIO");
+        // DEBUG_V ("attach the new GPIO");
         OutputI2SSlotConfigs[I2SChannelId].DataPin = NewGpio;
-        m_gpio_matrix_out_check_and_set(NewGpio, I2S_DataStartSignal + I2SChannelId, false, false);
+        i2sParallel.iomux_set_signal (NewGpio, I2S1O_DATA_OUT0_IDX + I2SChannelId);
 
-    } while(false);
+    } while (false);
 
     // DEBUG_END;
 } // SetGpio
@@ -409,35 +287,31 @@ void c_OutputI2S::SetGpio (uint32_t I2SChannelId, gpio_num_t NewGpio)
 //----------------------------------------------------------------------------
 void c_OutputI2S::SetOutputState (uint32_t I2SChannelId, bool NewState)
 {
-    DEBUG_START;
+    // DEBUG_START;
 
     OutputI2SSlotConfigs[I2SChannelId].IsActive = NewState;
 
-    DEBUG_END;
+    // DEBUG_END;
 } // SetOutputState
 
 //----------------------------------------------------------------------------
-uint32_t c_OutputI2S::GetBitTimeSlices    (uint32_t BitTimeInNanoSec)
+uint32_t c_OutputI2S::GetBitTimeSlices (uint32_t TargetBitTimeInNanoSec)
 {
     // DEBUG_START;
 
     uint32_t Result = 0;
+    double I2S_TickTimeInNS = i2sParallel.get_clockNS ();
 
-    do // once
-    {
-        if (BitTimeInNanoSec < 200)
-        {
-            logcon(F("Invalid bit time"));
-            break;
-        }
-
-        // round up
-        Result = ((BitTimeInNanoSec + int(I2S_TickTimeInNS)) - 1) / int(I2S_TickTimeInNS);
-
-    } while(false);
+    // round up
+    Result = ( (TargetBitTimeInNanoSec + int (I2S_TickTimeInNS)) - 1) / int (I2S_TickTimeInNS);
+    if (0 == Result) Result = 1;
 
+    // DEBUG_V (String ("TargetBitTimeInNanoSec: ") + String (TargetBitTimeInNanoSec));
+    // DEBUG_V (String ("      I2S_TickTimeInNS: ") + String (I2S_TickTimeInNS));
+    // DEBUG_V (String ("                Result: ") + String (Result));
+    
     // DEBUG_END;
     return Result;
 }
 
-#endif // defined(SUPPORT_I2S)
+#endif // defined (SUPPORT_I2S)

From 79c56116df0d5c8496f7263076d49b9c95c70471 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 31 Aug 2026 21:49:04 -0400
Subject: [PATCH 21/34] Lots of cleanup. Still has errors in counting bytes.

---
 include/output/OutputWS2811I2S.hpp |  43 +++--
 src/output/OutputWS2811I2S.cpp     | 286 ++++++++++++++++-------------
 2 files changed, 188 insertions(+), 141 deletions(-)

diff --git a/include/output/OutputWS2811I2S.hpp b/include/output/OutputWS2811I2S.hpp
index 9813a5b07..0f5428212 100644
--- a/include/output/OutputWS2811I2S.hpp
+++ b/include/output/OutputWS2811I2S.hpp
@@ -38,35 +38,39 @@ class c_OutputWS2811I2S : public c_OutputWS2811
     // functions to be provided by the derived class
     void    Begin ();                                        ///< set up the operating environment based on the current config (or defaults)
     bool    SetConfig (ArduinoJson::JsonObject& jsonConfig); ///< Set a new config in the driver
-    uint32_t Poll ();                                        ///< Call from loop (),  renders output data
+    uint32_t Poll () {return 0;}                             ///< Call from loop (),  renders output data
     void    GetStatus (ArduinoJson::JsonObject& jsonStatus);
     void    SetOutputBufferSize (uint32_t NumChannelsAvailable);
     void    PauseOutput(bool State);
-    bool    GetNextBitToSend (I2S_item_t * DataToSend, uint32_t numSlices);
-    void    StartNewDataFrame();
+    void    ISR_GetNextBitsToSend (c_OutputI2S::I2S_Item_t * DataToSend, uint32_t numSlices);
+    void    ISR_StartNewDataFrame();
 
     // to be removed when the I2S driver is fully implemented
     virtual bool RmtPoll() {return false;}
 
 private:
+    void    CalculateFrameBitSlices ();
 
     // The adjustments compensate for rounding errors in the calculations
     c_OutputI2S     *I2Sdriver;
 
-    uint8_t         DataBitMask;
-    uint8_t         DataBit;
+    uint32_t        DataBitMask;
+    uint32_t        DataBit;
 
-    uint32_t        ZeroHighBitCount;
-    uint32_t        ZeroLowBitCount;
+    uint32_t        ZeroHighBitSliceCount;
+    uint32_t        ZeroLowBitSliceCount;
 
-    uint32_t        OneHighBitCount;
-    uint32_t        OneLowBitCount;
+    uint32_t        OneHighBitSliceCount;
+    uint32_t        OneLowBitSliceCount;
 
-    uint32_t        HighBitCurrentCount;
-    uint32_t        LowBitCurrentCount;
+    uint32_t        HighBitCurrentSliceCount;
+    uint32_t        LowBitCurrentSliceCount;
 
-    uint32_t        IfgBitCount;
-    uint32_t        IfgBitCurrentCount;
+    uint32_t        IfgSliceCount;
+    uint32_t        IfgCurrentSliceCount;
+
+    uint32_t        IdleSliceCount;
+    uint32_t        IdleCurrentSliceCount;
 
     uint32_t        DataPattern;
     uint32_t        DataPatternMask;
@@ -79,11 +83,16 @@ class c_OutputWS2811I2S : public c_OutputWS2811
         uint32_t GetNextBit;
         uint32_t FrameStarts;
         uint32_t FrameEnds;
-        uint32_t IfgBits;
-        uint32_t DataBits;
+        uint32_t IdleBitSlices;
+        uint32_t IfgBitSlices;
+        uint32_t DataBitSlices;
         uint32_t DataBytes;
-        uint32_t BitHigh;
-        uint32_t BitLow;
+        uint32_t BitSliceHigh;
+        uint32_t BitSliceLow;
+        uint32_t NextDataBit;
+        uint32_t DataBits;
+        uint32_t DataBitEnd;
+        uint32_t DataByteEnd;
     } I2SDebugCounters;
     #else
     #define INC_WS2811_I2S_DEBUG_COUNTERS(c)
diff --git a/src/output/OutputWS2811I2S.cpp b/src/output/OutputWS2811I2S.cpp
index fbf1a8ec6..f4abfea12 100644
--- a/src/output/OutputWS2811I2S.cpp
+++ b/src/output/OutputWS2811I2S.cpp
@@ -17,15 +17,15 @@
 *
 */
 #include "ESPixelStick.h"
-#if defined(SUPPORT_OutputProtocol_WS2811) && defined(SUPPORT_I2S)
+#if defined (SUPPORT_OutputProtocol_WS2811) && defined (SUPPORT_I2S)
 
 #include "output/OutputWS2811I2S.hpp"
 #include "output/OutputMgr.hpp"
 
 //----------------------------------------------------------------------------
-static bool GetNextBitToSendBase (void * arg, I2S_item_t * DataToSend, uint32_t numSlices)
+static void IRAM_ATTR GetNextBitToSendBase (void * arg, c_OutputI2S::I2S_Item_t * DataToSend, uint32_t numSlices)
 {
-    return reinterpret_cast<c_OutputWS2811I2S*>(arg)->GetNextBitToSend(DataToSend, numSlices);
+    reinterpret_cast<c_OutputWS2811I2S*> (arg)->ISR_GetNextBitsToSend (DataToSend, numSlices);
 } // ISR_GetNextBitToSend
 
 //----------------------------------------------------------------------------
@@ -49,6 +49,8 @@ c_OutputWS2811I2S::~c_OutputWS2811I2S ()
 {
     // DEBUG_START;
 
+    I2Sdriver->RemoveSlotDevice(OutputPortDefinition.PortId);
+
     // DEBUG_END;
 } // ~c_OutputWS2811I2S
 
@@ -57,42 +59,45 @@ void c_OutputWS2811I2S::Begin ()
 {
     // DEBUG_START;
 
-    I2Sdriver = static_cast<c_OutputI2S*>(OutputMgr.GetI2sDriver());
+    I2Sdriver = static_cast<c_OutputI2S*> (OutputMgr.GetI2sDriver ());
 
     c_OutputWS2811::Begin ();
 
     // DEBUG_V (String ("DataPin: ") + String (DataPin));
 
-    ZeroHighBitCount = I2Sdriver->GetBitTimeSlices(WS2811_PIXEL_NS_BIT_0_HIGH);
-    ZeroLowBitCount  = I2Sdriver->GetBitTimeSlices(WS2811_PIXEL_NS_BIT_0_LOW);
-    OneHighBitCount  = I2Sdriver->GetBitTimeSlices(WS2811_PIXEL_NS_BIT_1_HIGH);
-    OneLowBitCount   = I2Sdriver->GetBitTimeSlices(WS2811_PIXEL_NS_BIT_1_LOW);
+    ZeroHighBitSliceCount = I2Sdriver->GetBitTimeSlices (WS2811_PIXEL_NS_BIT_0_HIGH);
+    ZeroLowBitSliceCount  = I2Sdriver->GetBitTimeSlices (WS2811_PIXEL_NS_BIT_0_LOW);
+    OneHighBitSliceCount  = I2Sdriver->GetBitTimeSlices (WS2811_PIXEL_NS_BIT_1_HIGH);
+    OneLowBitSliceCount   = I2Sdriver->GetBitTimeSlices (WS2811_PIXEL_NS_BIT_1_LOW);
 
-    DEBUG_V(String("ZeroHighBitCount: ") + String(ZeroHighBitCount));
-    DEBUG_V(String(" ZeroLowBitCount: ") + String(ZeroLowBitCount));
-    DEBUG_V(String(" OneHighBitCount: ") + String(OneHighBitCount));
-    DEBUG_V(String("  OneLowBitCount: ") + String(OneLowBitCount));
+    // DEBUG_V (String ("ZeroHighBitCount: ") + String (ZeroHighBitCount));
+    // DEBUG_V (String (" ZeroLowBitCount: ") + String (ZeroLowBitCount));
+    // DEBUG_V (String (" OneHighBitCount: ") + String (OneHighBitCount));
+    // DEBUG_V (String ("  OneLowBitCount: ") + String (OneLowBitCount));
 
-    IfgBitCount         = 0;
-    IfgBitCurrentCount  = 0;
-    HighBitCurrentCount = 0;
-    LowBitCurrentCount  = 0;
+    IfgSliceCount            = 0;
+    IfgCurrentSliceCount     = 0;
+    HighBitCurrentSliceCount = 0;
+    LowBitCurrentSliceCount  = 0;
+    IdleSliceCount           = 0;
+    IdleCurrentSliceCount    = 0;
 
     DataBit = 0; // no data bit assigned yet
     DataBitMask = ~DataBit;
 
     c_OutputI2S::OutputI2SChannelConfig_t OutputI2SConfig;
-    OutputI2SConfig.I2SChannelId            = uint32_t(OutputPortDefinition.PortId);
-    OutputI2SConfig.DataPin                 = gpio_num_t(OutputPortDefinition.gpios.data);
+    OutputI2SConfig.I2SChannelId            = uint32_t (OutputPortDefinition.PortId);
+    OutputI2SConfig.DataPin                 = gpio_num_t (OutputPortDefinition.gpios.data);
     OutputI2SConfig.arg                     = this;
-    OutputI2SConfig.GetNextIntensityBit     = GetNextBitToSendBase;
+    OutputI2SConfig.GetNextIntensityBitSlices = GetNextBitToSendBase;
     OutputI2SConfig.IsActive                = false; // do not output data
 
-    DataBit = I2Sdriver->RegisterSlotDevice(OutputI2SConfig);
-    DataBitMask = ~ DataBit;
+    // prime the bit counters
+    ISR_StartNewDataFrame();
+    I2Sdriver->RegisterSlotDevice (OutputI2SConfig, &DataBit, &DataBitMask);
 
-    // DEBUG_V(String("    DataBit: 0x") + String(DataBit, HEX));
-    // DEBUG_V(String("DataBitMask: 0x") + String(DataBitMask, HEX));
+    // DEBUG_V (String ("    DataBit: 0x") + String (DataBit, HEX));
+    // DEBUG_V (String ("DataBitMask: 0x") + String (DataBitMask, HEX));
 
     HasBeenInitialized = true;
 
@@ -101,29 +106,49 @@ void c_OutputWS2811I2S::Begin ()
 } // Begin
 
 //----------------------------------------------------------------------------
-bool c_OutputWS2811I2S::SetConfig (ArduinoJson::JsonObject& jsonConfig)
+void c_OutputWS2811I2S::CalculateFrameBitSlices ()
 {
     // DEBUG_START;
 
-    bool response = c_OutputWS2811::SetConfig (jsonConfig);
-
-    uint32_t SavedIfgBitCount = IfgBitCount;
-    IfgBitCount = I2Sdriver->GetBitTimeSlices(InterFrameGapInMicroSec * NanoSecondsInAMicroSecond);
-    // DEBUG_V(String("     IfgBitCount: ") + String(IfgBitCount));
+    uint32_t MinFrameLenNS = 25 * NanoSecondsInAMilliSecond;
+    uint32_t FrameDurationInNanoSec = ActualFrameDurationMicroSec * NanoSecondsInAMicroSecond;
+    // DEBUG_V (String (" ActualFrameDurationMicroSec: ") + String (ActualFrameDurationMicroSec));
+    // DEBUG_V (String ("      FrameDurationInNanoSec: ") + String (FrameDurationInNanoSec));
+    // DEBUG_V (String ("     InterFrameGapInMicroSec: ") + String (InterFrameGapInMicroSec));
+    FrameDurationInNanoSec -= (InterFrameGapInMicroSec * NanoSecondsInAMicroSecond);
+    // DEBUG_V (String ("  new FrameDurationInNanoSec: ") + String (FrameDurationInNanoSec));
+    // DEBUG_V (String ("               MinFrameLenNS: ") + String (MinFrameLenNS));
+    uint32_t IdleLenNS = (MinFrameLenNS > FrameDurationInNanoSec) ? MinFrameLenNS - FrameDurationInNanoSec : NanoSecondsInAMicroSecond; 
+    // DEBUG_V (String ("                   IdleLenNS: ") + String (IdleLenNS));
+    IdleSliceCount = I2Sdriver->GetBitTimeSlices (IdleLenNS);
+    // DEBUG_V (String ("                   IdleCount: ") + String (IdleCount));
+
+    IfgSliceCount = I2Sdriver->GetBitTimeSlices (InterFrameGapInMicroSec * NanoSecondsInAMicroSecond);
+    // DEBUG_V (String ("                 IfgBitCount: ") + String (IfgBitCount));
 
     // update the output GPIO
-    I2Sdriver->SetGpio(OutputPortDefinition.PortId, OutputPortDefinition.gpios.data);
+    I2Sdriver->SetGpio (OutputPortDefinition.PortId, OutputPortDefinition.gpios.data);
 
-    if(!SavedIfgBitCount)
-    {
-        // get all of the slice counters set up for the first frame
-        StartNewDataFrame();
+    // start the transmiter
+    I2Sdriver->SetOutputState (OutputPortDefinition.PortId, true);
 
-        // start the transmiter
-        I2Sdriver->SetOutputState(OutputPortDefinition.PortId, true);
-    }
+    // DEBUG_END;
 
-    // DEBUG_V();
+} // CalculateFrameBits
+
+//----------------------------------------------------------------------------
+bool c_OutputWS2811I2S::SetConfig (ArduinoJson::JsonObject& jsonConfig)
+{
+    // DEBUG_START;
+
+    bool response = c_OutputWS2811::SetConfig (jsonConfig);
+    CalculateFrameBitSlices ();
+
+    // update the output GPIO
+    I2Sdriver->SetGpio (OutputPortDefinition.PortId, OutputPortDefinition.gpios.data);
+
+    // start the transmiter
+    I2Sdriver->SetOutputState (OutputPortDefinition.PortId, true);
 
     // DEBUG_END;
     return response;
@@ -136,6 +161,7 @@ void c_OutputWS2811I2S::SetOutputBufferSize (uint32_t NumChannelsAvailable)
     // DEBUG_START;
 
     c_OutputWS2811::SetOutputBufferSize (NumChannelsAvailable);
+    CalculateFrameBitSlices ();
 
     // DEBUG_END;
 
@@ -146,154 +172,165 @@ void c_OutputWS2811I2S::GetStatus (ArduinoJson::JsonObject& jsonStatus)
 {
     // // DEBUG_START;
     c_OutputWS2811::GetStatus (jsonStatus);
-    I2Sdriver->GetStatus (jsonStatus);
 
     #ifdef USE_I2S_DEBUG_COUNTERS
-    jsonStatus[F("FrameDurationInMicroSec")] = FrameDurationInMicroSec;
-    jsonStatus[F("FrameStartTimeInMicroSec")] = GetFrameStartTimeInMicroSec();
-    uint32_t now = micros();
-    jsonStatus[F("Now")] = now;
-    jsonStatus[F("FrameStartDelta")] = now - GetFrameStartTimeInMicroSec();
+    jsonStatus[F ("FrameDurationInMicroSec")] = FrameDurationInMicroSec;
+    jsonStatus[F ("FrameStartTimeInMicroSec")] = GetFrameStartTimeInMicroSec ();
+    uint32_t now = micros ();
+    jsonStatus[F ("Now")] = now;
+    jsonStatus[F ("FrameStartDelta")] = now - GetFrameStartTimeInMicroSec ();
     #endif // def USE_I2S_DEBUG_COUNTERS
 
     #ifdef WS2811_I2S_DEBUG_COUNTERS
-    JsonObject JsonCounters = jsonStatus["JsonCounters"].to<JsonObject>();
-    JsonWrite(JsonCounters, "GetNextBit",  I2SDebugCounters.GetNextBit);
-    JsonWrite(JsonCounters, "FrameStarts", I2SDebugCounters.FrameStarts);
-    JsonWrite(JsonCounters, "FrameEnds",   I2SDebugCounters.FrameEnds);
-    JsonWrite(JsonCounters, "IfgBits",     I2SDebugCounters.IfgBits);
-    JsonWrite(JsonCounters, "DataBits",    I2SDebugCounters.DataBits);
-    JsonWrite(JsonCounters, "DataBytes",   I2SDebugCounters.DataBytes);
-    JsonWrite(JsonCounters, "BitHigh",     I2SDebugCounters.BitHigh);
-    JsonWrite(JsonCounters, "BitLow",      I2SDebugCounters.BitLow);
+    JsonObject JsonCounters = jsonStatus["JsonCounters"].to<JsonObject> ();
+    JsonWrite (JsonCounters, "GetNextBit",      I2SDebugCounters.GetNextBit);
+    JsonWrite (JsonCounters, "FrameStarts",     I2SDebugCounters.FrameStarts);
+    JsonWrite (JsonCounters, "FrameEnds",       I2SDebugCounters.FrameEnds);
+    JsonWrite (JsonCounters, "IfgBitSlices",    I2SDebugCounters.IfgBitSlices);
+    JsonWrite (JsonCounters, "IdleBitSlices",   I2SDebugCounters.IdleBitSlices);
+    JsonWrite (JsonCounters, "DataBitSlices",   I2SDebugCounters.DataBitSlices);
+    JsonWrite (JsonCounters, "DataBits",        I2SDebugCounters.DataBits);
+    JsonWrite (JsonCounters, "DataBytes",       I2SDebugCounters.DataBytes);
+    JsonWrite (JsonCounters, "BitSliceHigh",    I2SDebugCounters.BitSliceHigh);
+    JsonWrite (JsonCounters, "BitSliceLow",     I2SDebugCounters.BitSliceLow);
+    JsonWrite (JsonCounters, "DataBitEnd",      I2SDebugCounters.DataBitEnd);
+    JsonWrite (JsonCounters, "DataByteEnd",     I2SDebugCounters.DataByteEnd);
+    JsonWrite (JsonCounters, "IdleCount",       IdleSliceCount);
+    JsonWrite (JsonCounters, "IfgBitCount",     IfgSliceCount);
+
     #endif // def WS2811_I2S_DEBUG_COUNTERS
 
     // // DEBUG_END;
 } // GetStatus
 
 //----------------------------------------------------------------------------
-uint32_t c_OutputWS2811I2S::Poll ()
+void IRAM_ATTR c_OutputWS2811I2S::ISR_StartNewDataFrame ()
 {
     // DEBUG_START;
 
-    // DEBUG_END;
-    return ActualFrameDurationMicroSec;
-
-} // Poll
-
-//----------------------------------------------------------------------------
-void c_OutputWS2811I2S::StartNewDataFrame()
-{
-    // DEBUG_START;
+    c_OutputWS2811::ISR_StartNewFrame ();
 
-    StartNewFrame();
+    // DEBUG_V (String ("frame started on ") + String (OutputPortDefinition.gpios.data));
+    INC_WS2811_I2S_DEBUG_COUNTERS (FrameStarts);
 
-    // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
-    INC_WS2811_I2S_DEBUG_COUNTERS(FrameStarts);
-    IfgBitCurrentCount = IfgBitCount;
+    IdleCurrentSliceCount = IdleSliceCount;
+    IfgCurrentSliceCount  = IfgSliceCount;
 
     // set up for the next data byte
-    INC_WS2811_I2S_DEBUG_COUNTERS(DataBytes);
-    c_OutputPixel::ISR_GetNextIntensityToSend(DataPattern);
+    INC_WS2811_I2S_DEBUG_COUNTERS (DataBytes);
+
+    // restore c_OutputPixel::ISR_GetNextIntensityToSend (DataPattern);
     DataPatternMask = 0x80;
 
-    if(DataPattern & DataPatternMask)
+    if (DataPattern & DataPatternMask)
     {
         // send a one bit
-        HighBitCurrentCount = OneHighBitCount;
-        LowBitCurrentCount  = OneLowBitCount;
+        HighBitCurrentSliceCount = OneHighBitSliceCount;
+        LowBitCurrentSliceCount  = OneLowBitSliceCount;
     }
     else // send a zero bit
     {
-        HighBitCurrentCount = ZeroHighBitCount;
-        LowBitCurrentCount  = ZeroLowBitCount;
+        HighBitCurrentSliceCount = ZeroHighBitSliceCount;
+        LowBitCurrentSliceCount  = ZeroLowBitSliceCount;
     }
 
     // DEBUG_END;
 } // StartNewDataFrame
 
 //----------------------------------------------------------------------------
-bool c_OutputWS2811I2S::GetNextBitToSend (I2S_item_t * pDataToSend, uint32_t numSlices)
+void IRAM_ATTR c_OutputWS2811I2S::ISR_GetNextBitsToSend (c_OutputI2S::I2S_Item_t * pDataToSend, uint32_t numSlices)
 {
-    INC_WS2811_I2S_DEBUG_COUNTERS(GetNextBit);
-    bool Response = true;
+    INC_WS2811_I2S_DEBUG_COUNTERS (GetNextBit);
 
-    for(int CurrentSliceId = 0; CurrentSliceId < numSlices; ++CurrentSliceId, ++pDataToSend)
+    for (int CurrentSliceId = 0; CurrentSliceId < numSlices; ++CurrentSliceId, ++pDataToSend)
     {
-        if (IfgBitCurrentCount)
+        if (IdleCurrentSliceCount)
         {
-            INC_WS2811_I2S_DEBUG_COUNTERS(IfgBits);
-            pDataToSend->data &= DataBitMask; // output low
-            --IfgBitCurrentCount;
+            INC_WS2811_I2S_DEBUG_COUNTERS (IdleBitSlices);
+            *pDataToSend |= uint8_t(DataBit); // output high
+            --IdleCurrentSliceCount;
             continue;
         }
 
-        INC_WS2811_I2S_DEBUG_COUNTERS(DataBits);
-        if(HighBitCurrentCount)
+        if (IfgCurrentSliceCount)
         {
-            INC_WS2811_I2S_DEBUG_COUNTERS(BitHigh);
+            INC_WS2811_I2S_DEBUG_COUNTERS (IfgBitSlices);
+            *pDataToSend &= uint8_t(DataBitMask); // output low
+            --IfgCurrentSliceCount;
+            continue;
+        }
 
-            --HighBitCurrentCount;
-            pDataToSend->data |= DataBit; // output high
+        INC_WS2811_I2S_DEBUG_COUNTERS (DataBitSlices);
+
+        if (HighBitCurrentSliceCount)
+        {
+            INC_WS2811_I2S_DEBUG_COUNTERS (BitSliceHigh);
+
+            --HighBitCurrentSliceCount;
+            *pDataToSend |= uint8_t(DataBit); // output high
             continue;
         }
 
-        if(LowBitCurrentCount)
+        if (LowBitCurrentSliceCount)
         {
-            INC_WS2811_I2S_DEBUG_COUNTERS(BitLow);
-            pDataToSend->data &= DataBitMask; // output low
-            --LowBitCurrentCount;
-            if(LowBitCurrentCount)
+            INC_WS2811_I2S_DEBUG_COUNTERS (BitSliceLow);
+            *pDataToSend &= uint8_t(DataBitMask); // output low
+            --LowBitCurrentSliceCount;
+            if (LowBitCurrentSliceCount)
             {
                 // more low bits to send
                 continue;
             }
         }
 
-        // bit data has completed
+        INC_WS2811_I2S_DEBUG_COUNTERS (DataBitEnd);
+
+        // 1 bit of data has completed
         DataPatternMask = DataPatternMask >> 1;
+
         // do we need to set up the next data byte to send?
-        if(0 == DataPatternMask)
+        if (0 == DataPatternMask)
         {
-            if(c_OutputPixel::ISR_MoreDataToSend())
-            {
-                INC_WS2811_I2S_DEBUG_COUNTERS(DataBytes);
-                c_OutputPixel::ISR_GetNextIntensityToSend(DataPattern);
-                DataPatternMask = 0x80;
-                if(DataPattern & DataPatternMask)
-                {
-                    HighBitCurrentCount = OneHighBitCount;
-                    LowBitCurrentCount  = OneLowBitCount;
-                }
-                else
-                {
-                    HighBitCurrentCount = ZeroHighBitCount;
-                    LowBitCurrentCount  = ZeroLowBitCount;
-                }
-            }
-            else
+            // entire data byte has been sent
+            INC_WS2811_I2S_DEBUG_COUNTERS (DataByteEnd);
+
+            // is there another data byte to send?
+            if (!c_OutputPixel::ISR_MoreDataToSend ())
             {
-                INC_WS2811_I2S_DEBUG_COUNTERS(FrameEnds);
-                StartNewDataFrame();
+                INC_WS2811_I2S_DEBUG_COUNTERS (FrameEnds);
+
+                ISR_StartNewDataFrame ();
+
+                // force a huge idle gap
+                // IdleCurrentSliceCount = -1;
+                continue;
             }
-            continue;
+
+            // there is more data to send
+            INC_WS2811_I2S_DEBUG_COUNTERS (DataBytes);
+
+            // set up to output the next data byte
+            c_OutputPixel::ISR_GetNextIntensityToSend (DataPattern);
+            DataPatternMask = 0x80;
         }
+
         // more bits to send in the current data byte
-        INC_WS2811_I2S_DEBUG_COUNTERS(DataBits);
-        if(DataPattern & DataPatternMask)
+        INC_WS2811_I2S_DEBUG_COUNTERS (DataBits);
+        if (DataPattern & DataPatternMask)
         {
             // send a one bit
-            HighBitCurrentCount = OneHighBitCount;
-            LowBitCurrentCount  = OneLowBitCount;
+            HighBitCurrentSliceCount = OneHighBitSliceCount;
+            LowBitCurrentSliceCount  = OneLowBitSliceCount;
         }
-        else // send a zero bit
+        else
         {
-            HighBitCurrentCount = ZeroHighBitCount;
-            LowBitCurrentCount  = ZeroLowBitCount;
+            // send a zero bit
+            HighBitCurrentSliceCount = ZeroHighBitSliceCount;
+            LowBitCurrentSliceCount  = ZeroLowBitSliceCount;
         }
     };
 
-    return Response;
+    return;
 } // ISR_GetNextBitToSend
 
 //----------------------------------------------------------------------------
@@ -301,9 +338,10 @@ void c_OutputWS2811I2S::PauseOutput (bool State)
 {
     // DEBUG_START;
 
-    c_OutputWS2811::PauseOutput(State);
+    I2Sdriver->SetOutputState (OutputPortDefinition.PortId, State);
+    c_OutputWS2811::PauseOutput (State);
 
     // DEBUG_END;
 } // PauseOutput
 
-#endif // defined(SUPPORT_OutputProtocol_WS2811) && defined(ARDUINO_ARCH_ESP32)
+#endif // defined (SUPPORT_OutputProtocol_WS2811) && defined (ARDUINO_ARCH_ESP32)

From 6d3751a3ba26045d09c10f0d226b94d5c93904b9 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 31 Aug 2026 22:15:35 -0400
Subject: [PATCH 22/34] Preparing for I2S. Have to move some functionality back
 into IRAM

---
 include/output/OutputGECERmt.hpp              |  2 +-
 include/output/OutputGS8208Rmt.hpp            |  2 +-
 include/output/OutputMgr.hpp                  |  2 +-
 include/output/OutputTM1814Rmt.hpp            |  2 +-
 include/output/OutputUCS8903Rmt.hpp           |  2 +-
 include/output/OutputUart.hpp                 |  2 +-
 .../GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp      | 30 +++++++++----------
 platformio.ini                                |  6 ++++
 src/FileMgr.cpp                               |  4 +--
 src/WebMgr.cpp                                |  2 +-
 src/output/OutputAPA102Spi.cpp                |  2 +-
 src/output/OutputCommon.cpp                   |  4 +--
 src/output/OutputGECERmt.cpp                  |  8 ++---
 src/output/OutputGS8208Rmt.cpp                |  8 ++---
 src/output/OutputGrinch.cpp                   |  4 +--
 src/output/OutputGrinchSpi.cpp                |  2 +-
 src/output/OutputMgr.cpp                      |  2 +-
 src/output/OutputPixel.cpp                    |  2 +-
 src/output/OutputRelay.cpp                    |  2 +-
 src/output/OutputSerial.cpp                   |  4 +--
 src/output/OutputSerialRmt.cpp                |  2 +-
 src/output/OutputServoPCA9685.cpp             |  4 +--
 src/output/OutputTLS3001Rmt.cpp               |  6 ++--
 src/output/OutputTM1814Rmt.cpp                |  8 ++---
 src/output/OutputUCS1903Rmt.cpp               |  6 ++--
 src/output/OutputUCS8903Rmt.cpp               |  8 ++---
 src/output/OutputWS2801Spi.cpp                |  2 +-
 src/output/OutputWS2811Rmt.cpp                |  4 +--
 28 files changed, 69 insertions(+), 63 deletions(-)

diff --git a/include/output/OutputGECERmt.hpp b/include/output/OutputGECERmt.hpp
index 927b6767b..c5affe0e0 100644
--- a/include/output/OutputGECERmt.hpp
+++ b/include/output/OutputGECERmt.hpp
@@ -45,7 +45,7 @@ class c_OutputGECERmt : public c_OutputGECE
     void    GetStatus (ArduinoJson::JsonObject& jsonStatus);
     void    SetOutputBufferSize (uint32_t NumChannelsAvailable);
     void    PauseOutput (bool State);
-    void    StartNewDataFrame();
+    void    ISR_StartNewDataFrame();
     bool    ISR_GetNextBitToSend (rmt_item32_t & DataToSend);
 
 private:
diff --git a/include/output/OutputGS8208Rmt.hpp b/include/output/OutputGS8208Rmt.hpp
index e897ef64b..3bb7ba69a 100644
--- a/include/output/OutputGS8208Rmt.hpp
+++ b/include/output/OutputGS8208Rmt.hpp
@@ -44,7 +44,7 @@ class c_OutputGS8208Rmt : public c_OutputGS8208
     void    GetStatus (ArduinoJson::JsonObject& jsonStatus);
     void    SetOutputBufferSize (uint32_t NumChannelsAvailable);
     void    PauseOutput (bool State);
-    void    StartNewDataFrame();
+    void    ISR_StartNewDataFrame();
     bool    ISR_GetNextBitToSend (rmt_item32_t & DataToSend);
 
 private:
diff --git a/include/output/OutputMgr.hpp b/include/output/OutputMgr.hpp
index 737201bf9..1d2f4fb90 100644
--- a/include/output/OutputMgr.hpp
+++ b/include/output/OutputMgr.hpp
@@ -65,7 +65,7 @@ class c_OutputMgr
     void      SetConfig         (const char * NewConfig);  ///< Save the current configuration data to nvram
     void      SetConfig         (ArduinoJson::JsonDocument & NewConfig);  ///< Save the current configuration data to nvram
     void      GetStatus         (JsonObject & jsonStatus);
-    uint8_t*  GetBufferAddress  () { return pOutputBuffer; } ///< Get the address of the buffer into which the E1.31 handler will stuff data
+    IRAM_ATTR uint8_t * ISR_GetBufferAddress  () { return pOutputBuffer; } ///< Get the address of the buffer into which the E1.31 handler will stuff data
     uint32_t  GetBufferUsedSize () { return UsedBufferSize; } ///< Get the size (in intensities) of the buffer into which the E1.31 handler will stuff data
     uint32_t  GetBufferSize     () { return uint32_t(OM_MAX_NUM_CHANNELS); } ///< Get the size (in intensities) of the buffer into which the E1.31 handler will stuff data
     void      DeleteConfig      () { FileMgr.DeleteFlashFile (ConfigFileName); }
diff --git a/include/output/OutputTM1814Rmt.hpp b/include/output/OutputTM1814Rmt.hpp
index eeac6b5d7..05f50b94b 100644
--- a/include/output/OutputTM1814Rmt.hpp
+++ b/include/output/OutputTM1814Rmt.hpp
@@ -44,7 +44,7 @@ class c_OutputTM1814Rmt : public c_OutputTM1814
     void    SetOutputBufferSize (uint32_t NumChannelsAvailable);
     void    PauseOutput(bool State);
     bool    ISR_GetNextBitToSend (rmt_item32_t &DataToSend);
-    void    StartNewDataFrame();
+    void    ISR_StartNewDataFrame();
 
 private:
 
diff --git a/include/output/OutputUCS8903Rmt.hpp b/include/output/OutputUCS8903Rmt.hpp
index 8cbededb3..8347ecdd8 100644
--- a/include/output/OutputUCS8903Rmt.hpp
+++ b/include/output/OutputUCS8903Rmt.hpp
@@ -45,7 +45,7 @@ class c_OutputUCS8903Rmt : public c_OutputUCS8903
     void    SetOutputBufferSize (uint32_t NumChannelsAvailable);
     void    PauseOutput(bool State);
     bool    ISR_GetNextBitToSend (rmt_item32_t &DataToSend);
-    void    StartNewDataFrame();
+    void    ISR_StartNewDataFrame();
 
 private:
     // The adjustments compensate for rounding errors in the calculations
diff --git a/include/output/OutputUart.hpp b/include/output/OutputUart.hpp
index 6a3142b53..10c892de2 100644
--- a/include/output/OutputUart.hpp
+++ b/include/output/OutputUart.hpp
@@ -118,7 +118,7 @@ class c_OutputUart
     void set_pin                        ();
     void TerminateSerialPortOperation   ();
     void RestoreSerialPortOperation     ();
-    void ReportNewFrame                 ();
+    void ISR_ReportNewFrame                 ();
     void StartBreak                     ();
     void EndBreak                       ();
     void GenerateBreak                  (uint32_t DurationInUs, uint32_t MarkDurationInUs);
diff --git a/include/platforms/GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp b/include/platforms/GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp
index 949095ec2..71cb6872d 100644
--- a/include/platforms/GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp
+++ b/include/platforms/GPIO_Defs_ESP32_QUINLED_Dig-Octa.hpp
@@ -75,19 +75,19 @@ const OM_OutputPortDefinition_t OM_OutputPortDefinitions[] =
 #define DEFAULT_ETH_MDIO_PIN    gpio_num_t::GPIO_NUM_18
 
 // Output Types
-// #define SUPPORT_OutputProtocol_TLS3001          // OM_SERIAL
-// #define SUPPORT_OutputProtocol_APA102           // OM_SPI
-// #define SUPPORT_OutputProtocol_DMX              // OM_SERIAL
-// #define SUPPORT_OutputProtocol_GECE             // OM_SERIAL
-// #define SUPPORT_OutputProtocol_GS8208           // OM_SERIAL
-// #define SUPPORT_OutputProtocol_Renard           // OM_SERIAL
-// #define SUPPORT_OutputProtocol_Serial           // OM_SERIAL
-// #define SUPPORT_OutputProtocol_TM1814           // OM_SERIAL
-// #define SUPPORT_OutputProtocol_UCS1903          // OM_SERIAL
-// #define SUPPORT_OutputProtocol_UCS8903          // OM_SERIAL
-// #define SUPPORT_OutputProtocol_WS2801           // OM_SPI
+#define SUPPORT_OutputProtocol_TLS3001          // OM_SERIAL
+#define SUPPORT_OutputProtocol_APA102           // OM_SPI
+#define SUPPORT_OutputProtocol_DMX              // OM_SERIAL
+#define SUPPORT_OutputProtocol_GECE             // OM_SERIAL
+#define SUPPORT_OutputProtocol_GS8208           // OM_SERIAL
+#define SUPPORT_OutputProtocol_Renard           // OM_SERIAL
+#define SUPPORT_OutputProtocol_Serial           // OM_SERIAL
+#define SUPPORT_OutputProtocol_TM1814           // OM_SERIAL
+#define SUPPORT_OutputProtocol_UCS1903          // OM_SERIAL
+#define SUPPORT_OutputProtocol_UCS8903          // OM_SERIAL
+#define SUPPORT_OutputProtocol_WS2801           // OM_SPI
 #define SUPPORT_OutputProtocol_WS2811           // OM_SERIAL
-// #define SUPPORT_OutputProtocol_Relay            // OM_RELAY
-// #define SUPPORT_OutputProtocol_Servo_PCA9685    // OM_I2C
-// #define SUPPORT_OutputProtocol_FireGod          // OM_SERIAL
-// #define SUPPORT_OutputProtocol_GRINCH           // OM_SPI
+#define SUPPORT_OutputProtocol_Relay            // OM_RELAY
+#define SUPPORT_OutputProtocol_Servo_PCA9685    // OM_I2C
+#define SUPPORT_OutputProtocol_FireGod          // OM_SERIAL
+#define SUPPORT_OutputProtocol_GRINCH           // OM_SPI
diff --git a/platformio.ini b/platformio.ini
index 56bad432b..6d3691f69 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -147,6 +147,11 @@ build_flags =
     ; -D SUPPORT_UART=1
     ; -D SUPPORT_I2S=1
     -D SUPPORT_RMT=1
+    -D PIN_I2S_SD_IN=-1
+    -D PIN_I2S_SD_OUT=-1
+    -D PIN_I2S_SD=-1
+    -D PIN_I2S_FS=-1
+    -D PIN_I2S_SCK=-1
     ;----------------------
     -I ./include/service
 
@@ -163,6 +168,7 @@ lib_deps =
     mathieucarbou/OneWire @ ^2.3.9
     https://github.com/MartinMueller2003/DS18B20
     https://github.com/bitbank2/unzipLIB
+    https://github.com/MartinMueller2003/esp_i2s_parallel
 
 lib_ignore =
     ${env.lib_ignore}
diff --git a/src/FileMgr.cpp b/src/FileMgr.cpp
index 06da79939..531b54b61 100644
--- a/src/FileMgr.cpp
+++ b/src/FileMgr.cpp
@@ -1625,7 +1625,7 @@ void c_FileMgr::CloseSdFile (FileId& FileHandle)
 
         if (nullptr != FileList[FileListIndex].buffer.DataBuffer)
         {
-            if(FileList[FileListIndex].buffer.DataBuffer != OutputMgr.GetBufferAddress())
+            if(FileList[FileListIndex].buffer.DataBuffer != OutputMgr.ISR_GetBufferAddress())
             {
                 // only free the buffer if it is not malloc'd
                 free(FileList[FileListIndex].buffer.DataBuffer);
@@ -2368,7 +2368,7 @@ void c_FileMgr::handleFileUploadNewFile (const String & filename)
         // DEBUG_V("Use the output buffer as a data buffer");
         FileList[FileListIndex].buffer.offset = 0;
         FileList[FileListIndex].buffer.size = min(uint32_t(OutputMgr.GetBufferSize() & ~(SD_BLOCK_SIZE - 1)), uint32_t(MAX_SD_BUFFER_SIZE));
-        FileList[FileListIndex].buffer.DataBuffer = OutputMgr.GetBufferAddress();
+        FileList[FileListIndex].buffer.DataBuffer = OutputMgr.ISR_GetBufferAddress();
         OutputMgr.PauseOutputs(true);
         InputMgr.SetOperationalState(false);
         OutputMgr.ClearBuffer();
diff --git a/src/WebMgr.cpp b/src/WebMgr.cpp
index be0347db8..ae99c1fae 100644
--- a/src/WebMgr.cpp
+++ b/src/WebMgr.cpp
@@ -319,7 +319,7 @@ void c_WebMgr::init ()
                             // DEBUG_V(String("NumBytesAvailableToSend: ") + String(NumBytesAvailableToSend));
                             if(0 != NumBytesAvailableToSend)
                             {
-                                memcpy(buffer, OutputMgr.GetBufferAddress () + index, NumBytesAvailableToSend);
+                                memcpy(buffer, OutputMgr.ISR_GetBufferAddress () + index, NumBytesAvailableToSend);
                             }
                             return NumBytesAvailableToSend;
                         });
diff --git a/src/output/OutputAPA102Spi.cpp b/src/output/OutputAPA102Spi.cpp
index 8b93db44e..db9693f6e 100644
--- a/src/output/OutputAPA102Spi.cpp
+++ b/src/output/OutputAPA102Spi.cpp
@@ -97,7 +97,7 @@ uint32_t c_OutputAPA102Spi::Poll ()
     {
         if (Spi.Poll ())
         {
-            ReportNewFrame ();
+            ISR_ReportNewFrame ();
         }
     }
     else
diff --git a/src/output/OutputCommon.cpp b/src/output/OutputCommon.cpp
index dd6169ff8..d37a8738f 100644
--- a/src/output/OutputCommon.cpp
+++ b/src/output/OutputCommon.cpp
@@ -32,7 +32,7 @@ c_OutputCommon::c_OutputCommon (OM_OutputPortDefinition_t & _OutputPortDefinitio
 	HasBeenInitialized       = false;
 	OutputPortDefinition     = _OutputPortDefinition;
     OutputType               = outputProtocol;
-    pOutputBuffer            = OutputMgr.GetBufferAddress ();
+    pOutputBuffer            = OutputMgr.ISR_GetBufferAddress ();
     FrameStartTimeInMicroSec = 0;
 
 	// logcon (String ("UartId:          '") + UartId + "'");
@@ -72,7 +72,7 @@ void IRAM_ATTR c_OutputCommon::ISR_ReportNewFrame ()
 
     // DEBUG_END;
 
-} // ReportNewFrame
+} // ISR_ReportNewFrame
 
 //----------------------------------------------------------------------------
 bool c_OutputCommon::SetConfig (JsonObject & jsonConfig)
diff --git a/src/output/OutputGECERmt.cpp b/src/output/OutputGECERmt.cpp
index a0c6542da..6cecee4c2 100644
--- a/src/output/OutputGECERmt.cpp
+++ b/src/output/OutputGECERmt.cpp
@@ -30,7 +30,7 @@ static bool IRAM_ATTR ISR_GetNextBitToSendBase (void * arg, rmt_item32_t & DataT
 //----------------------------------------------------------------------------
 static void StartNewDataFrameBase(void * arg)
 {
-    return reinterpret_cast<c_OutputGECERmt*>(arg)->StartNewDataFrame();
+    return reinterpret_cast<c_OutputGECERmt*>(arg)->ISR_StartNewDataFrame();
 }
 
 //----------------------------------------------------------------------------
@@ -87,7 +87,7 @@ bool c_OutputGECERmt::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     OutputRmtConfig.arg                     = this;
     OutputRmtConfig.ISR_GetNextIntensityBit = ISR_GetNextBitToSendBase;
     OutputRmtConfig.StartNewDataFrame       = StartNewDataFrameBase;
-    OutputRmtConfig.BufferStart             = GetBufferAddress();
+    OutputRmtConfig.BufferStart             = ISR_GetBufferAddress();
     OutputRmtConfig.NumBytesInFrame         = OM_MAX_NUM_CHANNELS;
 
     Rmt.Begin(OutputRmtConfig, this);
@@ -170,13 +170,13 @@ bool c_OutputGECERmt::RmtPoll ()
 } // Poll
 
 //----------------------------------------------------------------------------
-void c_OutputGECERmt::StartNewDataFrame()
+void IRAM_ATTR c_OutputGECERmt::ISR_StartNewDataFrame()
 {
     // DEBUG_START;
     // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
     INC_GECE_RMT_DEBUG_COUNTERS(FrameStarts);
     StartBitCount = 1;
-    StartNewFrame();
+    ISR_StartNewFrame();
 
     // DEBUG_END;
 } // StartNewDataFrame
diff --git a/src/output/OutputGS8208Rmt.cpp b/src/output/OutputGS8208Rmt.cpp
index e9b21d8d5..18079a79b 100644
--- a/src/output/OutputGS8208Rmt.cpp
+++ b/src/output/OutputGS8208Rmt.cpp
@@ -31,7 +31,7 @@ static bool IRAM_ATTR ISR_GetNextBitToSendBase (void * arg, rmt_item32_t & DataT
 //----------------------------------------------------------------------------
 static void StartNewDataFrameBase(void * arg)
 {
-    return reinterpret_cast<c_OutputGS8208Rmt*>(arg)->StartNewDataFrame();
+    return reinterpret_cast<c_OutputGS8208Rmt*>(arg)->ISR_StartNewDataFrame();
 }
 
 //----------------------------------------------------------------------------
@@ -96,7 +96,7 @@ bool c_OutputGS8208Rmt::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     OutputRmtConfig.arg                     = this;
     OutputRmtConfig.ISR_GetNextIntensityBit = ISR_GetNextBitToSendBase;
     OutputRmtConfig.StartNewDataFrame       = StartNewDataFrameBase;
-    OutputRmtConfig.BufferStart             = GetBufferAddress();
+    OutputRmtConfig.BufferStart             = ISR_GetBufferAddress();
     OutputRmtConfig.NumBytesInFrame         = OM_MAX_NUM_CHANNELS;
 
     Rmt.Begin(OutputRmtConfig, this);
@@ -179,13 +179,13 @@ bool c_OutputGS8208Rmt::RmtPoll ()
 } // Poll
 
 //----------------------------------------------------------------------------
-void c_OutputGS8208Rmt::StartNewDataFrame()
+void IRAM_ATTR c_OutputGS8208Rmt::ISR_StartNewDataFrame()
 {
     // DEBUG_START;
     // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
     INC_GS8208_RMT_DEBUG_COUNTERS(FrameStarts);
     ifgBitCurrentCount = ifgBitCount;
-    StartNewFrame();
+    ISR_StartNewFrame();
 
     // DEBUG_END;
 } // StartNewDataFrame
diff --git a/src/output/OutputGrinch.cpp b/src/output/OutputGrinch.cpp
index f71c5d94c..3b67c4c5d 100644
--- a/src/output/OutputGrinch.cpp
+++ b/src/output/OutputGrinch.cpp
@@ -129,7 +129,7 @@ void c_OutputGrinch::StartNewFrame()
 
     // build the data frame
     uint32_t    NumChannelsToProcess = GetNumOutputBufferBytesNeeded();
-    uint8_t     * pInputData = GetBufferAddress();
+    uint8_t     * pInputData = ISR_GetBufferAddress();
     uint8_t     OutputData = 0;
     uint8_t     OutputDataByteIndex = 0;
     uint8_t     bitCounter = 0;
@@ -156,7 +156,7 @@ void c_OutputGrinch::StartNewFrame()
     }
 
     SpiOutputDataByteIndex = NumberOfGrinchDataBytes;
-    ReportNewFrame();
+    ISR_ReportNewFrame();
 
     // DEBUG_END;
 } // StartNewFrame
diff --git a/src/output/OutputGrinchSpi.cpp b/src/output/OutputGrinchSpi.cpp
index 3ba25524f..4d005d094 100644
--- a/src/output/OutputGrinchSpi.cpp
+++ b/src/output/OutputGrinchSpi.cpp
@@ -93,7 +93,7 @@ uint32_t c_OutputGrinchSpi::Poll ()
     {
         if (Spi.Poll ())
         {
-            ReportNewFrame ();
+            ISR_ReportNewFrame ();
         }
     }
     else
diff --git a/src/output/OutputMgr.cpp b/src/output/OutputMgr.cpp
index 362c09d53..b495ebda2 100644
--- a/src/output/OutputMgr.cpp
+++ b/src/output/OutputMgr.cpp
@@ -1822,7 +1822,7 @@ void c_OutputMgr::ClearBuffer()
 {
     // DEBUG_START;
 
-    memset(GetBufferAddress(), 0x00, OutputMgr.GetBufferSize());
+    memset(ISR_GetBufferAddress(), 0x00, OutputMgr.GetBufferSize());
 
     // DEBUG_END;
 
diff --git a/src/output/OutputPixel.cpp b/src/output/OutputPixel.cpp
index ddc364b03..4c0605ce4 100644
--- a/src/output/OutputPixel.cpp
+++ b/src/output/OutputPixel.cpp
@@ -808,7 +808,7 @@ void c_OutputPixel::WriteChannelData(uint32_t StartChannelId, uint32_t ChannelCo
                 break;
             }
 
-            if(uint32_t(pBuffer) >= uint32_t(&(OutputMgr.GetBufferAddress()[OutputMgr.GetBufferSize()])))
+            if(uint32_t(pBuffer) >= uint32_t(&(OutputMgr.ISR_GetBufferAddress()[OutputMgr.GetBufferSize()])))
             {
                 // DEBUG_V("This write is beyond the end of the Global Output buffer");
                 // DEBUG_V(String("      CalculatedChannelId: ") + String(CalculatedChannelId));
diff --git a/src/output/OutputRelay.cpp b/src/output/OutputRelay.cpp
index abfb4deae..fb313ef22 100644
--- a/src/output/OutputRelay.cpp
+++ b/src/output/OutputRelay.cpp
@@ -329,7 +329,7 @@ uint32_t c_OutputRelay::Poll ()
         OutputValue(pOutputBuffer[0]);
     }
 
-    ReportNewFrame ();
+    ISR_ReportNewFrame ();
 
     // DEBUG_END;
     return 0;
diff --git a/src/output/OutputSerial.cpp b/src/output/OutputSerial.cpp
index afe7b59c4..2b51aefb7 100644
--- a/src/output/OutputSerial.cpp
+++ b/src/output/OutputSerial.cpp
@@ -334,7 +334,7 @@ void c_OutputSerial::StartNewFrame ()
     FrameStartCounter++;
 #endif // def USE_SERIAL_DEBUG_COUNTERS
 
-    NextIntensityToSend = GetBufferAddress();
+    NextIntensityToSend = ISR_GetBufferAddress();
     intensity_count     = Num_Channels;
     SentIntensityCount  = 0;
     SerialHeaderIndex   = 0;
@@ -385,7 +385,7 @@ void c_OutputSerial::StartNewFrame ()
 
     } // end switch (OutputType)
 
-    ReportNewFrame();
+    ISR_ReportNewFrame();
 
     // DEBUG_END;
 
diff --git a/src/output/OutputSerialRmt.cpp b/src/output/OutputSerialRmt.cpp
index 9044feab2..1a7684c8e 100644
--- a/src/output/OutputSerialRmt.cpp
+++ b/src/output/OutputSerialRmt.cpp
@@ -81,7 +81,7 @@ bool c_OutputSerialRmt::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     OutputRmtConfig.arg                     = this;
     OutputRmtConfig.ISR_GetNextIntensityBit = ISR_GetNextBitToSendBase;
     OutputRmtConfig.StartNewDataFrame       = StartNewDataFrameBase;
-    OutputRmtConfig.BufferStart             = GetBufferAddress();
+    OutputRmtConfig.BufferStart             = ISR_GetBufferAddress();
     OutputRmtConfig.NumBytesInFrame         = OM_MAX_NUM_CHANNELS;
 
     Rmt.Begin(OutputRmtConfig, this);
diff --git a/src/output/OutputServoPCA9685.cpp b/src/output/OutputServoPCA9685.cpp
index 9b4d507b8..c1b98cc62 100644
--- a/src/output/OutputServoPCA9685.cpp
+++ b/src/output/OutputServoPCA9685.cpp
@@ -84,7 +84,7 @@ void c_OutputServoPCA9685::ClearBuffer ()
     // memset(GetBufferAddress(), 0x00, GetBufferUsedSize());
     for (ServoPCA9685Channel_t & currentServoPCA9685Channel : OutputList)
     {
-        GetBufferAddress()[currentServoPCA9685Channel.Id] =
+        ISR_GetBufferAddress()[currentServoPCA9685Channel.Id] =
             currentServoPCA9685Channel.HomeValue;
     }
 
@@ -233,7 +233,7 @@ uint32_t c_OutputServoPCA9685::Poll ()
         yield();
     }
 */
-    ReportNewFrame ();
+    ISR_ReportNewFrame ();
 
     for (ServoPCA9685Channel_t & currentServoPCA9685 : OutputList)
     {
diff --git a/src/output/OutputTLS3001Rmt.cpp b/src/output/OutputTLS3001Rmt.cpp
index a67389b52..7e15048c7 100644
--- a/src/output/OutputTLS3001Rmt.cpp
+++ b/src/output/OutputTLS3001Rmt.cpp
@@ -97,7 +97,7 @@ bool c_OutputTLS3001Rmt::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     OutputRmtConfig.arg                     = this;
     OutputRmtConfig.ISR_GetNextIntensityBit = ISR_GetNextBitToSendBase;
     OutputRmtConfig.StartNewDataFrame       = StartNewDataFrameBase;
-    OutputRmtConfig.BufferStart             = GetBufferAddress();
+    OutputRmtConfig.BufferStart             = ISR_GetBufferAddress();
     OutputRmtConfig.NumBytesInFrame         = OM_MAX_NUM_CHANNELS;
 
     // DEBUG_V();
@@ -226,7 +226,7 @@ uint32_t c_OutputTLS3001Rmt::Poll ()
 } // Poll
 
 //----------------------------------------------------------------------------
-void c_OutputTLS3001Rmt::StartNewDataFrame()
+void IRAM_ATTR c_OutputTLS3001Rmt::StartNewDataFrame()
 {
     // DEBUG_START;
     // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
@@ -240,7 +240,7 @@ void c_OutputTLS3001Rmt::StartNewDataFrame()
     {
         fsm_RMT_state_SendDataStart_imp.Init();
     }
-    c_OutputTLS3001::StartNewFrame();
+    c_OutputTLS3001::ISR_StartNewFrame();
 
     // DEBUG_END;
 } // StartNewDataFrame
diff --git a/src/output/OutputTM1814Rmt.cpp b/src/output/OutputTM1814Rmt.cpp
index e27719fec..dc8009687 100644
--- a/src/output/OutputTM1814Rmt.cpp
+++ b/src/output/OutputTM1814Rmt.cpp
@@ -31,7 +31,7 @@ static bool IRAM_ATTR ISR_GetNextBitToSendBase (void * arg, rmt_item32_t & DataT
 //----------------------------------------------------------------------------
 static void StartNewDataFrameBase(void * arg)
 {
-    return reinterpret_cast<c_OutputTM1814Rmt*>(arg)->StartNewDataFrame();
+    return reinterpret_cast<c_OutputTM1814Rmt*>(arg)->ISR_StartNewDataFrame();
 }
 
 //----------------------------------------------------------------------------
@@ -96,7 +96,7 @@ bool c_OutputTM1814Rmt::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     OutputRmtConfig.arg                     = this;
     OutputRmtConfig.ISR_GetNextIntensityBit = ISR_GetNextBitToSendBase;
     OutputRmtConfig.StartNewDataFrame       = StartNewDataFrameBase;
-    OutputRmtConfig.BufferStart             = GetBufferAddress();
+    OutputRmtConfig.BufferStart             = ISR_GetBufferAddress();
     OutputRmtConfig.NumBytesInFrame         = OM_MAX_NUM_CHANNELS;
 
     Rmt.Begin(OutputRmtConfig, this);
@@ -182,13 +182,13 @@ bool c_OutputTM1814Rmt::RmtPoll ()
 } // Poll
 
 //----------------------------------------------------------------------------
-void c_OutputTM1814Rmt::StartNewDataFrame()
+void IRAM_ATTR c_OutputTM1814Rmt::ISR_StartNewDataFrame()
 {
     // DEBUG_START;
     // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
     INC_TM1814_RMT_DEBUG_COUNTERS(FrameStarts);
     IfgBitCurrentCount = IfgBitCount;
-    StartNewFrame();
+    ISR_StartNewFrame();
 
     // DEBUG_END;
 } // StartNewDataFrame
diff --git a/src/output/OutputUCS1903Rmt.cpp b/src/output/OutputUCS1903Rmt.cpp
index a780a52df..aa3d0f6ae 100644
--- a/src/output/OutputUCS1903Rmt.cpp
+++ b/src/output/OutputUCS1903Rmt.cpp
@@ -95,7 +95,7 @@ bool c_OutputUCS1903Rmt::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     OutputRmtConfig.arg                     = this;
     OutputRmtConfig.ISR_GetNextIntensityBit = ISR_GetNextBitToSendBase;
     OutputRmtConfig.StartNewDataFrame       = StartNewDataFrameBase;
-    OutputRmtConfig.BufferStart             = GetBufferAddress();
+    OutputRmtConfig.BufferStart             = ISR_GetBufferAddress();
     OutputRmtConfig.NumBytesInFrame         = OM_MAX_NUM_CHANNELS;
 
     Rmt.Begin(OutputRmtConfig, this);
@@ -177,13 +177,13 @@ bool c_OutputUCS1903Rmt::RmtPoll ()
 } // Poll
 
 //----------------------------------------------------------------------------
-void c_OutputUCS1903Rmt::StartNewDataFrame()
+void IRAM_ATTR c_OutputUCS1903Rmt::StartNewDataFrame()
 {
     // DEBUG_START;
     // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
     INC_UCS1903_RMT_DEBUG_COUNTERS(FrameStarts);
     IfgBitCurrentCount = IfgBitCount;
-    StartNewFrame();
+    ISR_StartNewFrame();
 
     // DEBUG_END;
 } // StartNewDataFrame
diff --git a/src/output/OutputUCS8903Rmt.cpp b/src/output/OutputUCS8903Rmt.cpp
index c0c3b0ed6..997c1eeba 100644
--- a/src/output/OutputUCS8903Rmt.cpp
+++ b/src/output/OutputUCS8903Rmt.cpp
@@ -31,7 +31,7 @@ static bool IRAM_ATTR ISR_GetNextBitToSendBase (void * arg, rmt_item32_t & DataT
 //----------------------------------------------------------------------------
 static void StartNewDataFrameBase(void * arg)
 {
-    return reinterpret_cast<c_OutputUCS8903Rmt*>(arg)->StartNewDataFrame();
+    return reinterpret_cast<c_OutputUCS8903Rmt*>(arg)->ISR_StartNewDataFrame();
 } // StartNewDataFrameBase
 
 //----------------------------------------------------------------------------
@@ -96,7 +96,7 @@ bool c_OutputUCS8903Rmt::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     OutputRmtConfig.arg                     = this;
     OutputRmtConfig.ISR_GetNextIntensityBit = ISR_GetNextBitToSendBase;
     OutputRmtConfig.StartNewDataFrame       = StartNewDataFrameBase;
-    OutputRmtConfig.BufferStart             = GetBufferAddress();
+    OutputRmtConfig.BufferStart             = ISR_GetBufferAddress();
     OutputRmtConfig.NumBytesInFrame         = OM_MAX_NUM_CHANNELS;
 
     Rmt.Begin(OutputRmtConfig, this);
@@ -178,13 +178,13 @@ bool c_OutputUCS8903Rmt::RmtPoll ()
 } // Poll
 
 //----------------------------------------------------------------------------
-void c_OutputUCS8903Rmt::StartNewDataFrame()
+void IRAM_ATTR c_OutputUCS8903Rmt::ISR_StartNewDataFrame()
 {
     // DEBUG_START;
     // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
     INC_UCS8903_RMT_DEBUG_COUNTERS(FrameStarts);
     IfgBitCurrentCount = IfgBitCount;
-    StartNewFrame();
+    ISR_StartNewFrame();
 
     // DEBUG_END;
 } // StartNewDataFrame
diff --git a/src/output/OutputWS2801Spi.cpp b/src/output/OutputWS2801Spi.cpp
index 096102c33..1e380e2ad 100644
--- a/src/output/OutputWS2801Spi.cpp
+++ b/src/output/OutputWS2801Spi.cpp
@@ -94,7 +94,7 @@ uint32_t c_OutputWS2801Spi::Poll ()
     {
         if (Spi.Poll ())
             {
-            ReportNewFrame ();
+            ISR_ReportNewFrame ();
             }
     }
     else
diff --git a/src/output/OutputWS2811Rmt.cpp b/src/output/OutputWS2811Rmt.cpp
index 3bd64a69d..ac75741e9 100644
--- a/src/output/OutputWS2811Rmt.cpp
+++ b/src/output/OutputWS2811Rmt.cpp
@@ -95,7 +95,7 @@ bool c_OutputWS2811Rmt::SetConfig (ArduinoJson::JsonObject& jsonConfig)
     OutputRmtConfig.arg                     = this;
     OutputRmtConfig.ISR_GetNextIntensityBit = ISR_GetNextBitToSendBase;
     OutputRmtConfig.StartNewDataFrame       = StartNewDataFrameBase;
-    OutputRmtConfig.BufferStart             = GetBufferAddress();
+    OutputRmtConfig.BufferStart             = ISR_GetBufferAddress();
     OutputRmtConfig.NumBytesInFrame         = OM_MAX_NUM_CHANNELS;
 
     // DEBUG_V();
@@ -195,7 +195,7 @@ void c_OutputWS2811Rmt::StartNewDataFrame()
 {
     // DEBUG_START;
 
-    StartNewFrame();
+    ISR_StartNewFrame();
 
     // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
     INC_WS2811_RMT_DEBUG_COUNTERS(FrameStarts);

From 20f41d7a2fb5c306f664b5af1bd4dd13389e3887 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 31 Aug 2026 22:28:56 -0400
Subject: [PATCH 23/34] Moving UART bits into IRAM

---
 include/output/OutputSerial.hpp | 6 +++---
 src/output/OutputSerial.cpp     | 2 +-
 src/output/OutputUart.cpp       | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/output/OutputSerial.hpp b/include/output/OutputSerial.hpp
index 79a1b5111..a066838c4 100644
--- a/include/output/OutputSerial.hpp
+++ b/include/output/OutputSerial.hpp
@@ -43,10 +43,10 @@ class c_OutputSerial : public c_OutputCommon
             uint32_t    GetNumOutputBufferChannelsServiced () { return OutputBufferSize; };
             void        SetOutputBufferSize (uint32_t NumChannelsAvailable);
             uint32_t    Poll = 0;
-            void        StartNewFrame();
+            void        ISR_StartNewFrame();
 
-    bool IRAM_ATTR   ISR_GetNextIntensityToSend(uint32_t &DataToSend);
-    bool IRAM_ATTR   ISR_MoreDataToSend() { return (SerialFrameState_t::SerialIdle != SerialFrameState); }
+            bool        ISR_GetNextIntensityToSend(uint32_t &DataToSend);
+    IRAM_ATTR bool      ISR_MoreDataToSend() { return (SerialFrameState_t::SerialIdle != SerialFrameState); }
 
 protected:
     void SetFrameDurration();
diff --git a/src/output/OutputSerial.cpp b/src/output/OutputSerial.cpp
index 2b51aefb7..06a9d5cc6 100644
--- a/src/output/OutputSerial.cpp
+++ b/src/output/OutputSerial.cpp
@@ -322,7 +322,7 @@ void c_OutputSerial::SetFrameDurration ()
 } // SetFrameDurration
 
 //----------------------------------------------------------------------------
-void c_OutputSerial::StartNewFrame ()
+void IRAM_ATTR c_OutputSerial::ISR_StartNewFrame ()
 {
     // DEBUG_START;
 
diff --git a/src/output/OutputUart.cpp b/src/output/OutputUart.cpp
index 0814f124b..77469c009 100644
--- a/src/output/OutputUart.cpp
+++ b/src/output/OutputUart.cpp
@@ -585,12 +585,12 @@ void IRAM_ATTR c_OutputUart::ISR_StartNewDataFrame()
 {
     if (nullptr != OutputUartConfig.pPixelDataSource)
     {
-        OutputUartConfig.pPixelDataSource->StartNewFrame();
+        OutputUartConfig.pPixelDataSource->ISR_StartNewFrame();
     }
     #if defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)
     else
     {
-        OutputUartConfig.pSerialDataSource->StartNewFrame();
+        OutputUartConfig.pSerialDataSource->ISR_StartNewFrame();
     }
     #endif // defined(SUPPORT_OutputProtocol_FireGod) || defined(SUPPORT_OutputProtocol_DMX) || defined(SUPPORT_OutputProtocol_Serial) || defined(SUPPORT_OutputProtocol_Renard)
 } // StartNewDataFrame

From 12cb479de9ff62fb46b556f703210fde29d86a67 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 31 Aug 2026 22:33:57 -0400
Subject: [PATCH 24/34] Moving methods to IRAM

---
 include/output/OutputSerialRmt.hpp | 2 +-
 src/output/OutputSerialRmt.cpp     | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/output/OutputSerialRmt.hpp b/include/output/OutputSerialRmt.hpp
index 768a4684f..eee21f36a 100644
--- a/include/output/OutputSerialRmt.hpp
+++ b/include/output/OutputSerialRmt.hpp
@@ -43,7 +43,7 @@ class c_OutputSerialRmt : public c_OutputSerial
     void    GetStatus (ArduinoJson::JsonObject& jsonStatus);
     void    SetOutputBufferSize (uint32_t NumChannelsAvailable);
     void    PauseOutput(bool State);
-    void    StartNewDataFrame();
+    void    ISR_StartNewDataFrame();
     bool    ISR_GetNextBitToSend(rmt_item32_t & DataToSend);
 
 private:
diff --git a/src/output/OutputSerialRmt.cpp b/src/output/OutputSerialRmt.cpp
index 1a7684c8e..3fb5ad2ab 100644
--- a/src/output/OutputSerialRmt.cpp
+++ b/src/output/OutputSerialRmt.cpp
@@ -30,7 +30,7 @@ static bool IRAM_ATTR ISR_GetNextBitToSendBase (void * arg, rmt_item32_t & DataT
 //----------------------------------------------------------------------------
 static void StartNewDataFrameBase(void * arg)
 {
-    return reinterpret_cast<c_OutputSerialRmt*>(arg)->StartNewDataFrame();
+    return reinterpret_cast<c_OutputSerialRmt*>(arg)->ISR_StartNewDataFrame();
 }
 
 //----------------------------------------------------------------------------
@@ -231,7 +231,7 @@ bool c_OutputSerialRmt::RmtPoll ()
 } // Poll
 
 //----------------------------------------------------------------------------
-void c_OutputSerialRmt::StartNewDataFrame()
+void IRAM_ATTR c_OutputSerialRmt::ISR_StartNewDataFrame()
 {
     // DEBUG_START;
     // DEBUG_V(String("frame started on ") + String(OutputPortDefinition.gpios.data));
@@ -243,7 +243,7 @@ void c_OutputSerialRmt::StartNewDataFrame()
     }
     #endif //  defined(SUPPORT_OutputProtocol_DMX)
     StartBitCount = 1;
-    StartNewFrame();
+    ISR_StartNewFrame();
 
     // DEBUG_END;
 } // StartNewDataFrame

From 9da1239d5560e82e37dde1469dc4c4efcd35eea2 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Mon, 31 Aug 2026 22:40:43 -0400
Subject: [PATCH 25/34] Dont load I2S driver.

---
 platformio.ini | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/platformio.ini b/platformio.ini
index 6d3691f69..90a51897a 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -168,7 +168,7 @@ lib_deps =
     mathieucarbou/OneWire @ ^2.3.9
     https://github.com/MartinMueller2003/DS18B20
     https://github.com/bitbank2/unzipLIB
-    https://github.com/MartinMueller2003/esp_i2s_parallel
+    ; https://github.com/MartinMueller2003/esp_i2s_parallel
 
 lib_ignore =
     ${env.lib_ignore}

From 93a181ee62d2b36d71b079152172d6d987ec979d Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 4 Sep 2026 16:58:03 -0400
Subject: [PATCH 26/34] Remove unneeded IRAM_ATTR flag.

---
 include/output/OutputPixel.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/output/OutputPixel.hpp b/include/output/OutputPixel.hpp
index 2bdeb397c..33975f4b5 100644
--- a/include/output/OutputPixel.hpp
+++ b/include/output/OutputPixel.hpp
@@ -168,7 +168,7 @@ class c_OutputPixel : public c_OutputCommon
     inline   void         SetIntensityBitTimeInUS (float value) { IntensityBitTimeInUs = value; }
              void         SetIntensityDataWidth(uint32_t value);
              void         ISR_StartNewFrame();
-    inline   bool IRAM_ATTR ISR_MoreDataToSend () {return (&c_OutputPixel::ISR_FrameDone != FrameStateFuncPtr);}
+    inline   bool         ISR_MoreDataToSend () {return (&c_OutputPixel::ISR_FrameDone != FrameStateFuncPtr);}
              bool         ISR_GetNextIntensityToSend (uint32_t &DataToSend);
              void         SetPixelCount(uint32_t value) {pixel_count = value;}
     inline   uint32_t     GetPixelCount() {return pixel_count;}

From ada0132a77ea208c210410546e473afe420f5882 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 4 Sep 2026 16:58:45 -0400
Subject: [PATCH 27/34] Rename functions

---
 include/output/OutputWS2811I2S.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/output/OutputWS2811I2S.hpp b/include/output/OutputWS2811I2S.hpp
index 0f5428212..569b84e97 100644
--- a/include/output/OutputWS2811I2S.hpp
+++ b/include/output/OutputWS2811I2S.hpp
@@ -42,7 +42,7 @@ class c_OutputWS2811I2S : public c_OutputWS2811
     void    GetStatus (ArduinoJson::JsonObject& jsonStatus);
     void    SetOutputBufferSize (uint32_t NumChannelsAvailable);
     void    PauseOutput(bool State);
-    void    ISR_GetNextBitsToSend (c_OutputI2S::I2S_Item_t * DataToSend, uint32_t numSlices);
+    void    ISR_GetNextDataSlicesToSend (c_OutputI2S::I2S_Item_t * DataToSend, uint32_t numSlices);
     void    ISR_StartNewDataFrame();
 
     // to be removed when the I2S driver is fully implemented
@@ -66,8 +66,8 @@ class c_OutputWS2811I2S : public c_OutputWS2811
     uint32_t        HighBitCurrentSliceCount;
     uint32_t        LowBitCurrentSliceCount;
 
-    uint32_t        IfgSliceCount;
-    uint32_t        IfgCurrentSliceCount;
+    uint32_t        FrameResetSliceCount;
+    uint32_t        FrameResetCurrentSliceCount;
 
     uint32_t        IdleSliceCount;
     uint32_t        IdleCurrentSliceCount;
@@ -80,11 +80,11 @@ class c_OutputWS2811I2S : public c_OutputWS2811
     #define INC_WS2811_I2S_DEBUG_COUNTERS(c) (++I2SDebugCounters.c)
     struct
     {
-        uint32_t GetNextBit;
+        uint32_t GetDataSlices;
         uint32_t FrameStarts;
         uint32_t FrameEnds;
         uint32_t IdleBitSlices;
-        uint32_t IfgBitSlices;
+        uint32_t FrameResetBitSlices;
         uint32_t DataBitSlices;
         uint32_t DataBytes;
         uint32_t BitSliceHigh;

From 0118a5444fe04687f8ec698ba058dcd1cac67922 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 4 Sep 2026 16:59:30 -0400
Subject: [PATCH 28/34] Removed FrameStartTimeInMicroSec from the I2S builds.

---
 src/output/OutputCommon.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/output/OutputCommon.cpp b/src/output/OutputCommon.cpp
index d37a8738f..58ab0de2d 100644
--- a/src/output/OutputCommon.cpp
+++ b/src/output/OutputCommon.cpp
@@ -33,7 +33,9 @@ c_OutputCommon::c_OutputCommon (OM_OutputPortDefinition_t & _OutputPortDefinitio
 	OutputPortDefinition     = _OutputPortDefinition;
     OutputType               = outputProtocol;
     pOutputBuffer            = OutputMgr.ISR_GetBufferAddress ();
+    #ifndef SUPPORT_I2S
     FrameStartTimeInMicroSec = 0;
+    #endif // ndef SUPPORT_I2S
 
 	// logcon (String ("UartId:          '") + UartId + "'");
     // logcon (String ("OutputPortId: '") + OutputPortId + "'");
@@ -67,7 +69,9 @@ void IRAM_ATTR c_OutputCommon::ISR_ReportNewFrame ()
 {
     // DEBUG_START;
 
+    #ifndef SUPPORT_I2S
     FrameStartTimeInMicroSec = micros ();
+    #endif // ndef SUPPORT_I2S
     FrameCount++;
 
     // DEBUG_END;

From aee040e9061942433b34e1afa7cfdeac5a9d83d8 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 4 Sep 2026 17:02:46 -0400
Subject: [PATCH 29/34] Formatting changes

---
 src/output/OutputI2S.cpp | 40 +++++++++++++++++++---------------------
 1 file changed, 19 insertions(+), 21 deletions(-)

diff --git a/src/output/OutputI2S.cpp b/src/output/OutputI2S.cpp
index 3ca87f3a2..7d489bcfd 100644
--- a/src/output/OutputI2S.cpp
+++ b/src/output/OutputI2S.cpp
@@ -32,13 +32,13 @@ static c_OutputI2S::TransmitDmaBuffer_t TransmitDmaBuffers[I2S_NumSendBuffers] D
 //----------------------------------------------------------------------------
 static void IRAM_ATTR IRQ_Handler (void * arg, void * buffer)
 {
-    static_cast<c_OutputI2S*>(arg)->ISR_Handler(buffer);
+    static_cast<c_OutputI2S*> (arg)->ISR_Handler (buffer);
 } // IRQ_Handler
 
 //----------------------------------------------------------------------------
 void IRAM_ATTR c_OutputI2S::ISR_Handler (void * _TransmitDmaBuffer)
 {
-    I2S_DEBUG_INC_COUNTER(ISR_handler_count);
+    I2S_DEBUG_INC_COUNTER (ISR_handler_count);
 
     TransmitDmaBuffer_t * TransmitDmaBuffer = (TransmitDmaBuffer_t*)_TransmitDmaBuffer;
 
@@ -48,11 +48,11 @@ void IRAM_ATTR c_OutputI2S::ISR_Handler (void * _TransmitDmaBuffer)
 
     if (TransmitDmaBuffer->header.owner == I2sParallelDmaBufferOwnerDMA)
     {
-        I2S_DEBUG_INC_COUNTER(BufferOwnerFlagError);
+        I2S_DEBUG_INC_COUNTER (BufferOwnerFlagError);
     }
     #endif // def USE_I2S_DEBUG_COUNTERS
 
-    I2S_DEBUG_INC_COUNTER(ISR_FillBuffer);
+    I2S_DEBUG_INC_COUNTER (ISR_FillBuffer);
 
     // reset the buffer management fields
     TransmitDmaBuffer->header.length = TransmitDmaBuffer->header.size;
@@ -172,16 +172,15 @@ void c_OutputI2S::GetStatus (ArduinoJson::JsonObject& jsonStatus)
     // // DEBUG_START;
 
     #ifdef USE_I2S_DEBUG_COUNTERS
-    jsonStatus[F ("ISR_handler_count")]     = I2S_DEBUG_COUNTER(ISR_handler_count);
-    jsonStatus[F ("ISR_NullBufferPointer")] = String (I2S_DEBUG_COUNTER(ISR_NullBufferPointer));
-    jsonStatus[F ("BufferOwnerFlagError")]  = I2S_DEBUG_COUNTER(BufferOwnerFlagError);
-    jsonStatus[F ("ISR_NextBuffer")]        = I2S_DEBUG_COUNTER(ISR_FillBuffer);
-
     JsonObject debugStatus = jsonStatus["I2S Debug"].to<JsonObject> ();
 
-    debugStatus["IntensityBitsSent"]            = I2S_DEBUG_COUNTER (IntensityBitsSent);
-    debugStatus["I2SEntriesTransfered"]         = I2S_DEBUG_COUNTER (I2SEntriesTransfered);
-    debugStatus["I2SXmtFills"]                  = I2S_DEBUG_COUNTER (I2SXmtFills);
+    debugStatus["ISR_handler_count"]     = I2S_DEBUG_COUNTER (ISR_handler_count);
+    debugStatus["ISR_NullBufferPointer"] = String (I2S_DEBUG_COUNTER (ISR_NullBufferPointer));
+    debugStatus["BufferOwnerFlagError"]  = I2S_DEBUG_COUNTER (BufferOwnerFlagError);
+    debugStatus["ISR_FillBuffer"]        = I2S_DEBUG_COUNTER (ISR_FillBuffer);
+    debugStatus["IntensityBitsSent"]     = I2S_DEBUG_COUNTER (IntensityBitsSent);
+    debugStatus["I2SEntriesTransfered"]  = I2S_DEBUG_COUNTER (I2SEntriesTransfered);
+    debugStatus["I2SXmtFills"]           = I2S_DEBUG_COUNTER (I2SXmtFills);
     #endif // def USE_I2S_DEBUG_COUNTERS
     // // DEBUG_END;
 } // GetStatus
@@ -212,9 +211,6 @@ void c_OutputI2S::RegisterSlotDevice  (OutputI2SChannelConfig_t config, uint32_t
         *DataBitMask = ~(1 << config.I2SChannelId);
         // DEBUG_V (String ("DataBit: 0x") + String (*DataBit, HEX));
         SetGpio (config.I2SChannelId, config.DataPin);
-
-        // must be last
-        currentConfig.IsActive = config.IsActive;
     } while (false);
 
     // DEBUG_END;
@@ -239,7 +235,7 @@ void c_OutputI2S::RemoveSlotDevice  (uint32_t I2SChannelId)
         currentConfig.arg = nullptr;
         currentConfig.GetNextIntensityBitSlices = nullptr;
 
-        SetGpio (I2SChannelId, gpio_num_t(I2S_PIN_NO_CHANGE));
+        SetGpio (I2SChannelId, gpio_num_t (I2S_PIN_NO_CHANGE));
 
     } while (false);
 
@@ -289,13 +285,15 @@ void c_OutputI2S::SetOutputState (uint32_t I2SChannelId, bool NewState)
 {
     // DEBUG_START;
 
+    // DEBUG_V (String ("I2SChannelId: ") + String (I2SChannelId));
+    // DEBUG_V (String ("    NewState: ") + String (NewState));
     OutputI2SSlotConfigs[I2SChannelId].IsActive = NewState;
 
     // DEBUG_END;
 } // SetOutputState
 
 //----------------------------------------------------------------------------
-uint32_t c_OutputI2S::GetBitTimeSlices (uint32_t TargetBitTimeInNanoSec)
+uint32_t c_OutputI2S::GetNumTimeSlicesForTargetTimeNS (uint32_t TargetTimeInNanoSec)
 {
     // DEBUG_START;
 
@@ -303,12 +301,12 @@ uint32_t c_OutputI2S::GetBitTimeSlices (uint32_t TargetBitTimeInNanoSec)
     double I2S_TickTimeInNS = i2sParallel.get_clockNS ();
 
     // round up
-    Result = ( (TargetBitTimeInNanoSec + int (I2S_TickTimeInNS)) - 1) / int (I2S_TickTimeInNS);
+    Result = ( (TargetTimeInNanoSec + int (I2S_TickTimeInNS)) - 1) / int (I2S_TickTimeInNS);
     if (0 == Result) Result = 1;
 
-    // DEBUG_V (String ("TargetBitTimeInNanoSec: ") + String (TargetBitTimeInNanoSec));
-    // DEBUG_V (String ("      I2S_TickTimeInNS: ") + String (I2S_TickTimeInNS));
-    // DEBUG_V (String ("                Result: ") + String (Result));
+    // DEBUG_V (String ("TargetTimeInNanoSec: ") + String (TargetTimeInNanoSec));
+    // DEBUG_V (String ("   I2S_TickTimeInNS: ") + String (I2S_TickTimeInNS));
+    // DEBUG_V (String ("             Result: ") + String (Result));
     
     // DEBUG_END;
     return Result;

From 01d8534d31582caad83c9a85951651c14742c258 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 4 Sep 2026 17:06:23 -0400
Subject: [PATCH 30/34] Functional name changes

---
 src/output/OutputWS2811I2S.cpp | 168 ++++++++++++++++++++-------------
 1 file changed, 100 insertions(+), 68 deletions(-)

diff --git a/src/output/OutputWS2811I2S.cpp b/src/output/OutputWS2811I2S.cpp
index f4abfea12..26a3aeeac 100644
--- a/src/output/OutputWS2811I2S.cpp
+++ b/src/output/OutputWS2811I2S.cpp
@@ -23,9 +23,9 @@
 #include "output/OutputMgr.hpp"
 
 //----------------------------------------------------------------------------
-static void IRAM_ATTR GetNextBitToSendBase (void * arg, c_OutputI2S::I2S_Item_t * DataToSend, uint32_t numSlices)
+static void IRAM_ATTR GetDataSlicesToSendBase (void * arg, c_OutputI2S::I2S_Item_t * DataToSend, uint32_t numSlices)
 {
-    reinterpret_cast<c_OutputWS2811I2S*> (arg)->ISR_GetNextBitsToSend (DataToSend, numSlices);
+    reinterpret_cast<c_OutputWS2811I2S*> (arg)->ISR_GetNextDataSlicesToSend (DataToSend, numSlices);
 } // ISR_GetNextBitToSend
 
 //----------------------------------------------------------------------------
@@ -59,41 +59,39 @@ void c_OutputWS2811I2S::Begin ()
 {
     // DEBUG_START;
 
-    I2Sdriver = static_cast<c_OutputI2S*> (OutputMgr.GetI2sDriver ());
+    I2Sdriver = OutputMgr.GetI2sDriver ();
 
     c_OutputWS2811::Begin ();
 
     // DEBUG_V (String ("DataPin: ") + String (DataPin));
 
-    ZeroHighBitSliceCount = I2Sdriver->GetBitTimeSlices (WS2811_PIXEL_NS_BIT_0_HIGH);
-    ZeroLowBitSliceCount  = I2Sdriver->GetBitTimeSlices (WS2811_PIXEL_NS_BIT_0_LOW);
-    OneHighBitSliceCount  = I2Sdriver->GetBitTimeSlices (WS2811_PIXEL_NS_BIT_1_HIGH);
-    OneLowBitSliceCount   = I2Sdriver->GetBitTimeSlices (WS2811_PIXEL_NS_BIT_1_LOW);
+    ZeroHighBitSliceCount = I2Sdriver->GetNumTimeSlicesForTargetTimeNS (WS2811_PIXEL_NS_BIT_0_HIGH);
+    ZeroLowBitSliceCount  = I2Sdriver->GetNumTimeSlicesForTargetTimeNS (WS2811_PIXEL_NS_BIT_0_LOW);
+    OneHighBitSliceCount  = I2Sdriver->GetNumTimeSlicesForTargetTimeNS (WS2811_PIXEL_NS_BIT_1_HIGH);
+    OneLowBitSliceCount   = I2Sdriver->GetNumTimeSlicesForTargetTimeNS (WS2811_PIXEL_NS_BIT_1_LOW);
 
-    // DEBUG_V (String ("ZeroHighBitCount: ") + String (ZeroHighBitCount));
-    // DEBUG_V (String (" ZeroLowBitCount: ") + String (ZeroLowBitCount));
-    // DEBUG_V (String (" OneHighBitCount: ") + String (OneHighBitCount));
-    // DEBUG_V (String ("  OneLowBitCount: ") + String (OneLowBitCount));
+    // DEBUG_V (String ("ZeroHighBitSliceCount: ") + String (ZeroHighBitSliceCount));
+    // DEBUG_V (String (" ZeroLowBitSliceCount: ") + String (ZeroLowBitSliceCount));
+    // DEBUG_V (String (" OneHighBitSliceCount: ") + String (OneHighBitSliceCount));
+    // DEBUG_V (String ("  OneLowBitSliceCount: ") + String (OneLowBitSliceCount));
 
-    IfgSliceCount            = 0;
-    IfgCurrentSliceCount     = 0;
-    HighBitCurrentSliceCount = 0;
-    LowBitCurrentSliceCount  = 0;
-    IdleSliceCount           = 0;
-    IdleCurrentSliceCount    = 0;
+    FrameResetSliceCount        = 0;
+    FrameResetCurrentSliceCount = 0;
+    HighBitCurrentSliceCount    = 0;
+    LowBitCurrentSliceCount     = 0;
+    IdleSliceCount              = 0;
+    IdleCurrentSliceCount       = 0;
 
     DataBit = 0; // no data bit assigned yet
     DataBitMask = ~DataBit;
 
     c_OutputI2S::OutputI2SChannelConfig_t OutputI2SConfig;
-    OutputI2SConfig.I2SChannelId            = uint32_t (OutputPortDefinition.PortId);
-    OutputI2SConfig.DataPin                 = gpio_num_t (OutputPortDefinition.gpios.data);
-    OutputI2SConfig.arg                     = this;
-    OutputI2SConfig.GetNextIntensityBitSlices = GetNextBitToSendBase;
-    OutputI2SConfig.IsActive                = false; // do not output data
-
-    // prime the bit counters
-    ISR_StartNewDataFrame();
+    OutputI2SConfig.I2SChannelId              = uint32_t (OutputPortDefinition.PortId);
+    OutputI2SConfig.DataPin                   = gpio_num_t (OutputPortDefinition.gpios.data);
+    OutputI2SConfig.arg                       = this;
+    OutputI2SConfig.GetNextIntensityBitSlices = GetDataSlicesToSendBase;
+    OutputI2SConfig.IsActive                  = false; // do not output data
+
     I2Sdriver->RegisterSlotDevice (OutputI2SConfig, &DataBit, &DataBitMask);
 
     // DEBUG_V (String ("    DataBit: 0x") + String (DataBit, HEX));
@@ -108,29 +106,26 @@ void c_OutputWS2811I2S::Begin ()
 //----------------------------------------------------------------------------
 void c_OutputWS2811I2S::CalculateFrameBitSlices ()
 {
-    // DEBUG_START;
+    DEBUG_START;
 
     uint32_t MinFrameLenNS = 25 * NanoSecondsInAMilliSecond;
     uint32_t FrameDurationInNanoSec = ActualFrameDurationMicroSec * NanoSecondsInAMicroSecond;
     // DEBUG_V (String (" ActualFrameDurationMicroSec: ") + String (ActualFrameDurationMicroSec));
     // DEBUG_V (String ("      FrameDurationInNanoSec: ") + String (FrameDurationInNanoSec));
     // DEBUG_V (String ("     InterFrameGapInMicroSec: ") + String (InterFrameGapInMicroSec));
+
     FrameDurationInNanoSec -= (InterFrameGapInMicroSec * NanoSecondsInAMicroSecond);
     // DEBUG_V (String ("  new FrameDurationInNanoSec: ") + String (FrameDurationInNanoSec));
     // DEBUG_V (String ("               MinFrameLenNS: ") + String (MinFrameLenNS));
+    
     uint32_t IdleLenNS = (MinFrameLenNS > FrameDurationInNanoSec) ? MinFrameLenNS - FrameDurationInNanoSec : NanoSecondsInAMicroSecond; 
     // DEBUG_V (String ("                   IdleLenNS: ") + String (IdleLenNS));
-    IdleSliceCount = I2Sdriver->GetBitTimeSlices (IdleLenNS);
-    // DEBUG_V (String ("                   IdleCount: ") + String (IdleCount));
+    
+    IdleSliceCount = I2Sdriver->GetNumTimeSlicesForTargetTimeNS (IdleLenNS);
+    // DEBUG_V (String ("              IdleSliceCount: ") + String (IdleSliceCount));
 
-    IfgSliceCount = I2Sdriver->GetBitTimeSlices (InterFrameGapInMicroSec * NanoSecondsInAMicroSecond);
-    // DEBUG_V (String ("                 IfgBitCount: ") + String (IfgBitCount));
-
-    // update the output GPIO
-    I2Sdriver->SetGpio (OutputPortDefinition.PortId, OutputPortDefinition.gpios.data);
-
-    // start the transmiter
-    I2Sdriver->SetOutputState (OutputPortDefinition.PortId, true);
+    FrameResetSliceCount = I2Sdriver->GetNumTimeSlicesForTargetTimeNS (InterFrameGapInMicroSec * NanoSecondsInAMicroSecond);
+    // DEBUG_V (String ("        FrameResetSliceCount: ") + String (FrameResetSliceCount));
 
     // DEBUG_END;
 
@@ -141,14 +136,25 @@ bool c_OutputWS2811I2S::SetConfig (ArduinoJson::JsonObject& jsonConfig)
 {
     // DEBUG_START;
 
+    PauseOutput(true);
+
     bool response = c_OutputWS2811::SetConfig (jsonConfig);
-    CalculateFrameBitSlices ();
 
     // update the output GPIO
     I2Sdriver->SetGpio (OutputPortDefinition.PortId, OutputPortDefinition.gpios.data);
 
-    // start the transmiter
-    I2Sdriver->SetOutputState (OutputPortDefinition.PortId, true);
+    if(OutputBufferSize)
+    {
+        // DEBUG_V("start the transmiter");
+        CalculateFrameBitSlices ();
+        ISR_StartNewDataFrame ();
+        PauseOutput (false);
+    }
+    else
+    {
+        // DEBUG_V("stop the transmiter");
+        PauseOutput (true);
+    }
 
     // DEBUG_END;
     return response;
@@ -156,12 +162,25 @@ bool c_OutputWS2811I2S::SetConfig (ArduinoJson::JsonObject& jsonConfig)
 } // SetConfig
 
 //----------------------------------------------------------------------------
-void c_OutputWS2811I2S::SetOutputBufferSize (uint32_t NumChannelsAvailable)
+void c_OutputWS2811I2S::SetOutputBufferSize (uint32_t NumChannelsToOutput)
 {
     // DEBUG_START;
 
-    c_OutputWS2811::SetOutputBufferSize (NumChannelsAvailable);
-    CalculateFrameBitSlices ();
+    // DEBUG_V (String ("NumChannelsToOutput: ") + String (NumChannelsToOutput));
+    c_OutputWS2811::SetOutputBufferSize (NumChannelsToOutput);
+
+    if(OutputBufferSize)
+    {
+        // DEBUG_V("start the transmiter");
+        CalculateFrameBitSlices ();
+        ISR_StartNewDataFrame ();
+        PauseOutput (false);
+    }
+    else
+    {
+        // DEBUG_V("stop the transmiter");
+        PauseOutput (true);
+    }
 
     // DEBUG_END;
 
@@ -175,28 +194,38 @@ void c_OutputWS2811I2S::GetStatus (ArduinoJson::JsonObject& jsonStatus)
 
     #ifdef USE_I2S_DEBUG_COUNTERS
     jsonStatus[F ("FrameDurationInMicroSec")] = FrameDurationInMicroSec;
-    jsonStatus[F ("FrameStartTimeInMicroSec")] = GetFrameStartTimeInMicroSec ();
-    uint32_t now = micros ();
-    jsonStatus[F ("Now")] = now;
-    jsonStatus[F ("FrameStartDelta")] = now - GetFrameStartTimeInMicroSec ();
     #endif // def USE_I2S_DEBUG_COUNTERS
 
     #ifdef WS2811_I2S_DEBUG_COUNTERS
     JsonObject JsonCounters = jsonStatus["JsonCounters"].to<JsonObject> ();
-    JsonWrite (JsonCounters, "GetNextBit",      I2SDebugCounters.GetNextBit);
-    JsonWrite (JsonCounters, "FrameStarts",     I2SDebugCounters.FrameStarts);
-    JsonWrite (JsonCounters, "FrameEnds",       I2SDebugCounters.FrameEnds);
-    JsonWrite (JsonCounters, "IfgBitSlices",    I2SDebugCounters.IfgBitSlices);
-    JsonWrite (JsonCounters, "IdleBitSlices",   I2SDebugCounters.IdleBitSlices);
-    JsonWrite (JsonCounters, "DataBitSlices",   I2SDebugCounters.DataBitSlices);
-    JsonWrite (JsonCounters, "DataBits",        I2SDebugCounters.DataBits);
-    JsonWrite (JsonCounters, "DataBytes",       I2SDebugCounters.DataBytes);
-    JsonWrite (JsonCounters, "BitSliceHigh",    I2SDebugCounters.BitSliceHigh);
-    JsonWrite (JsonCounters, "BitSliceLow",     I2SDebugCounters.BitSliceLow);
-    JsonWrite (JsonCounters, "DataBitEnd",      I2SDebugCounters.DataBitEnd);
-    JsonWrite (JsonCounters, "DataByteEnd",     I2SDebugCounters.DataByteEnd);
-    JsonWrite (JsonCounters, "IdleCount",       IdleSliceCount);
-    JsonWrite (JsonCounters, "IfgBitCount",     IfgSliceCount);
+    JsonWrite (JsonCounters, "GetDataSlices",                  I2SDebugCounters.GetDataSlices);
+    JsonWrite (JsonCounters, "FrameStarts",                 I2SDebugCounters.FrameStarts);
+    JsonWrite (JsonCounters, "FrameEnds",                   I2SDebugCounters.FrameEnds);
+    JsonWrite (JsonCounters, "FrameResetBitSlices",         I2SDebugCounters.FrameResetBitSlices);
+    JsonWrite (JsonCounters, "IdleBitSlices",               I2SDebugCounters.IdleBitSlices);
+    JsonWrite (JsonCounters, "DataBitSlices",               I2SDebugCounters.DataBitSlices);
+    JsonWrite (JsonCounters, "DataBits",                    I2SDebugCounters.DataBits);
+    JsonWrite (JsonCounters, "DataBytes",                   I2SDebugCounters.DataBytes);
+    JsonWrite (JsonCounters, "BitSliceHigh",                I2SDebugCounters.BitSliceHigh);
+    JsonWrite (JsonCounters, "BitSliceLow",                 I2SDebugCounters.BitSliceLow);
+    JsonWrite (JsonCounters, "DataBitEnd",                  I2SDebugCounters.DataBitEnd);
+    JsonWrite (JsonCounters, "DataByteEnd",                 I2SDebugCounters.DataByteEnd);
+    JsonWrite (JsonCounters, "IdleSliceCount",              IdleSliceCount);
+
+    JsonWrite (JsonCounters, "DataBitMask",                 String(DataBitMask,HEX));
+    JsonWrite (JsonCounters, "DataBit",                     String(DataBit,HEX));
+    JsonWrite (JsonCounters, "ZeroHighBitSliceCount",       ZeroHighBitSliceCount);
+    JsonWrite (JsonCounters, "ZeroLowBitSliceCount",        ZeroLowBitSliceCount);
+    JsonWrite (JsonCounters, "OneHighBitSliceCount",        OneHighBitSliceCount);
+    JsonWrite (JsonCounters, "OneLowBitSliceCount",         OneLowBitSliceCount);
+    JsonWrite (JsonCounters, "HighBitCurrentSliceCount",    HighBitCurrentSliceCount);
+    JsonWrite (JsonCounters, "LowBitCurrentSliceCount",     LowBitCurrentSliceCount);
+    JsonWrite (JsonCounters, "FrameResetSliceCount",        FrameResetSliceCount);
+    JsonWrite (JsonCounters, "FrameResetCurrentSliceCount", FrameResetCurrentSliceCount);
+    JsonWrite (JsonCounters, "IdleSliceCount",              IdleSliceCount);
+    JsonWrite (JsonCounters, "IdleCurrentSliceCount",       IdleCurrentSliceCount);
+    JsonWrite (JsonCounters, "DataPattern",                 String(DataPattern, HEX));
+    JsonWrite (JsonCounters, "DataPatternMask",             String(DataPatternMask, HEX));
 
     #endif // def WS2811_I2S_DEBUG_COUNTERS
 
@@ -214,7 +243,7 @@ void IRAM_ATTR c_OutputWS2811I2S::ISR_StartNewDataFrame ()
     INC_WS2811_I2S_DEBUG_COUNTERS (FrameStarts);
 
     IdleCurrentSliceCount = IdleSliceCount;
-    IfgCurrentSliceCount  = IfgSliceCount;
+    FrameResetCurrentSliceCount  = FrameResetSliceCount;
 
     // set up for the next data byte
     INC_WS2811_I2S_DEBUG_COUNTERS (DataBytes);
@@ -238,9 +267,9 @@ void IRAM_ATTR c_OutputWS2811I2S::ISR_StartNewDataFrame ()
 } // StartNewDataFrame
 
 //----------------------------------------------------------------------------
-void IRAM_ATTR c_OutputWS2811I2S::ISR_GetNextBitsToSend (c_OutputI2S::I2S_Item_t * pDataToSend, uint32_t numSlices)
+void IRAM_ATTR c_OutputWS2811I2S::ISR_GetNextDataSlicesToSend (c_OutputI2S::I2S_Item_t * pDataToSend, uint32_t numSlices)
 {
-    INC_WS2811_I2S_DEBUG_COUNTERS (GetNextBit);
+    INC_WS2811_I2S_DEBUG_COUNTERS (GetDataSlices);
 
     for (int CurrentSliceId = 0; CurrentSliceId < numSlices; ++CurrentSliceId, ++pDataToSend)
     {
@@ -252,11 +281,11 @@ void IRAM_ATTR c_OutputWS2811I2S::ISR_GetNextBitsToSend (c_OutputI2S::I2S_Item_t
             continue;
         }
 
-        if (IfgCurrentSliceCount)
+        if (FrameResetCurrentSliceCount)
         {
-            INC_WS2811_I2S_DEBUG_COUNTERS (IfgBitSlices);
+            INC_WS2811_I2S_DEBUG_COUNTERS (FrameResetBitSlices);
             *pDataToSend &= uint8_t(DataBitMask); // output low
-            --IfgCurrentSliceCount;
+            --FrameResetCurrentSliceCount;
             continue;
         }
 
@@ -295,7 +324,7 @@ void IRAM_ATTR c_OutputWS2811I2S::ISR_GetNextBitsToSend (c_OutputI2S::I2S_Item_t
             INC_WS2811_I2S_DEBUG_COUNTERS (DataByteEnd);
 
             // is there another data byte to send?
-            if (!c_OutputPixel::ISR_MoreDataToSend ())
+            if (c_OutputPixel::ISR_MoreDataToSend ())
             {
                 INC_WS2811_I2S_DEBUG_COUNTERS (FrameEnds);
 
@@ -338,8 +367,11 @@ void c_OutputWS2811I2S::PauseOutput (bool State)
 {
     // DEBUG_START;
 
-    I2Sdriver->SetOutputState (OutputPortDefinition.PortId, State);
+    // DEBUG_V (String ("PortId: ") + String (OutputPortDefinition.PortId));
+    // DEBUG_V (String (" State: ") + String (State));
+
     c_OutputWS2811::PauseOutput (State);
+    I2Sdriver->SetOutputState (OutputPortDefinition.PortId, !State);
 
     // DEBUG_END;
 } // PauseOutput

From 1679242b2f458f836db1655295e35f20379218eb Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 4 Sep 2026 17:07:49 -0400
Subject: [PATCH 31/34] Fixed compiler warning

---
 include/output/OutputMgr.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/output/OutputMgr.hpp b/include/output/OutputMgr.hpp
index 1d2f4fb90..ee589b443 100644
--- a/include/output/OutputMgr.hpp
+++ b/include/output/OutputMgr.hpp
@@ -78,9 +78,9 @@ class c_OutputMgr
     void      RelayUpdate       (uint8_t RelayId, String & NewValue, String & Response);
     void      ClearStatistics   (void);
     uint8_t   GetNumPorts       () {return NumOutputPorts;}
-#ifdef SUPPORT_I2S
-    void *    GetI2sDriver      () {return &OutputI2S;}
-#endif // def SUPPORT_I2S
+	#ifdef SUPPORT_I2S
+	c_OutputI2S * GetI2sDriver  () {return &OutputI2S;}
+	#endif // def SUPPORT_I2S
 
 // do NOT insert into the middle of this list. Always add new types to the end of the list
     enum e_OutputProtocolType

From 7014a014928f740f6bcc0d03528ca8aaaad25546 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 4 Sep 2026 17:08:45 -0400
Subject: [PATCH 32/34] Refactored function name.

---
 include/output/OutputI2S.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/output/OutputI2S.hpp b/include/output/OutputI2S.hpp
index 5d5ef8302..e4e54aab4 100644
--- a/include/output/OutputI2S.hpp
+++ b/include/output/OutputI2S.hpp
@@ -74,7 +74,7 @@ class c_OutputI2S
     void        RemoveSlotDevice    (uint32_t I2SChannelId);
     void        GetStatus           (ArduinoJson::JsonObject& jsonStatus);
     void        GetDriverName       (String &value)  { value = F("I2S"); }
-    uint32_t    GetBitTimeSlices    (uint32_t BitTimeInNanoSec);
+    uint32_t    GetNumTimeSlicesForTargetTimeNS    (uint32_t BitTimeInNanoSec);
     void        SetOutputState      (uint32_t I2SChannelId, bool NewState);
     void        SetGpio             (uint32_t I2SChannelId, gpio_num_t NewGpio);
     void        ISR_Handler         (void * _TransmitDmaBuffer);

From 9b1c6b56fe9c5e88a0d5578fae764aa66f4815c2 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Fri, 4 Sep 2026 17:09:47 -0400
Subject: [PATCH 33/34] Fixed functions called in the ISR.

---
 include/output/OutputCommon.hpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/include/output/OutputCommon.hpp b/include/output/OutputCommon.hpp
index f1af328c3..9b871ea4e 100644
--- a/include/output/OutputCommon.hpp
+++ b/include/output/OutputCommon.hpp
@@ -46,11 +46,11 @@ class c_OutputCommon
     virtual bool         RmtPoll () = 0;                                        ///< Call from loop(),  renders output data
 #endif // def ARDUINO_ARCH_ESP32
     virtual void         GetDriverName (String & sDriverName) = 0;             ///< get the name for the instantiated driver
-            OM_PortId_t  GetOutputPortId ()    { return OutputPortDefinition.PortId; }     ///< return the output channel number
-    IRAM_ATTR uint8_t  * ISR_GetBufferAddress(){ return pOutputBuffer;}        ///< Get the address of the buffer into which the E1.31 handler will stuff data
-            uint32_t     GetBufferUsedSize ()  { return OutputBufferSize;}     ///< Get the address of the buffer into which the E1.31 handler will stuff data
-            OM_GPIOS_t   GetOutputGpio ()      { return OutputPortDefinition.gpios; }
-            OTYPE_t      GetOutputType ()      { return OutputType; }          ///< Have the instance report its type.
+    inline  OM_PortId_t  GetOutputPortId ()    { return OutputPortDefinition.PortId; }     ///< return the output channel number
+    inline  uint8_t    * ISR_GetBufferAddress(){ return pOutputBuffer;}        ///< Get the address of the buffer into which the E1.31 handler will stuff data
+    inline  uint32_t     GetBufferUsedSize ()  { return OutputBufferSize;}     ///< Get the address of the buffer into which the E1.31 handler will stuff data
+    inline  OM_GPIOS_t   GetOutputGpio ()      { return OutputPortDefinition.gpios; }
+    inline  OTYPE_t      GetOutputType ()      { return OutputType; }          ///< Have the instance report its type.
     virtual void         GetStatus (ArduinoJson::JsonObject & jsonStatus) = 0;
     virtual void         BaseGetStatus (ArduinoJson::JsonObject & jsonStatus);
             void         SetOutputBufferAddress (uint8_t* pNewOutputBuffer) { pOutputBuffer = pNewOutputBuffer; }
@@ -62,7 +62,7 @@ class c_OutputCommon
     virtual void         ReadChannelData (uint32_t StartChannelId, uint32_t ChannelCount, byte *pTargetData);
     virtual bool         ValidateGpio (gpio_num_t ConsoleTxGpio, gpio_num_t ConsoleRxGpio);
     virtual uint32_t     GetFrameTimeMs() {return 1 + (ActualFrameDurationMicroSec / 1000); }
-            bool         IsPaused() {return Paused;}
+    inline  bool         IsPaused() {return Paused;}
     virtual void         ClearStatistics (void);
 
 protected:
@@ -78,7 +78,7 @@ class c_OutputCommon
     bool        Paused = false;
 
     void ISR_ReportNewFrame ();
-
+#ifndef SUPPORT_I2S
     inline bool canRefresh ()
     {
         uint32_t Now = micros ();
@@ -95,4 +95,5 @@ class c_OutputCommon
 
     private:   uint32_t FrameStartTimeInMicroSec = 0;
     public:    uint32_t GetFrameStartTimeInMicroSec() {return FrameStartTimeInMicroSec;}
+#endif // ndef SUPPORT_I2S
 }; // c_OutputCommon

From 9fedabea21498cc2fcdd0782f05de200700971a5 Mon Sep 17 00:00:00 2001
From: Martin Mueller <MartinMueller2003@yahoo.com>
Date: Thu, 10 Sep 2026 22:20:05 -0400
Subject: [PATCH 34/34] Fixed issue that failed to rename the unziped file from
 xLights

---
 src/UnzipFiles.cpp | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/UnzipFiles.cpp b/src/UnzipFiles.cpp
index 8f288921a..c8bda5034 100644
--- a/src/UnzipFiles.cpp
+++ b/src/UnzipFiles.cpp
@@ -117,6 +117,8 @@ void UnzipFiles::ProcessZipFile(String & ArchiveFileName)
     if (returnCode == UNZ_OK)
     {
         bool IsSpecialxLightsZipFile = (-1 != ArchiveFileName.indexOf(".xlz"));
+        // DEBUG_V(String("IsSpecialxLightsZipFile: ") + String(IsSpecialxLightsZipFile));
+
         // logcon(String("Opened zip file: '") + FileName + "'");
 
         // Display the global comment and all of the FileNames within
@@ -140,15 +142,19 @@ void UnzipFiles::ProcessZipFile(String & ArchiveFileName)
                     // DEBUG_V("Modifying File Name");
                     String Temp = ArchiveFileName;
                     Temp.replace(".xlz", ".fseq");
-                    // DEBUG_V(String("              Temp: ") + Temp);
+                    // DEBUG_V(String("                   Temp: ") + Temp);
                     if(FinalFileName.equals(Temp))
                     {
                         IsSpecialxLightsZipFile = false;
                     }
+                    else
+                    {
+                        FinalFileName = Temp;
+                    }
                 }
                 // DEBUG_V(String("IsSpecialxLightsZipFile: ") + String(IsSpecialxLightsZipFile));
-                // DEBUG_V(String("ArchiveSubFileName: ") + ArchiveSubFileName);
-                // DEBUG_V(String("     FinalFileName: ") + FinalFileName);
+                // DEBUG_V(String("     ArchiveSubFileName: ") + ArchiveSubFileName);
+                // DEBUG_V(String("          FinalFileName: ") + FinalFileName);
 
                 c_FileMgr::SdInfo info;
                 FileMgr.GetSdInfo(info);