fix i2s race condition error

78 · 78 · commit f890acfc7cd4 · 2025-08-12T14:54:16.000+08:00
diff --git a/main/audio/codecs/box_audio_codec.cc b/main/audio/codecs/box_audio_codec.cc
@@ -184,6 +184,7 @@ void BoxAudioCodec::SetOutputVolume(int volume) {
 }
 
 void BoxAudioCodec::EnableInput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == input_enabled_) {
         return;
     }
@@ -207,6 +208,7 @@ void BoxAudioCodec::EnableInput(bool enable) {
 }
 
 void BoxAudioCodec::EnableOutput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == output_enabled_) {
         return;
     }
@@ -228,13 +230,15 @@ void BoxAudioCodec::EnableOutput(bool enable) {
 }
 
 int BoxAudioCodec::Read(int16_t* dest, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (input_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void*)dest, samples * sizeof(int16_t)));
     }
     return samples;
 }
 
 int BoxAudioCodec::Write(const int16_t* data, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (output_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void*)data, samples * sizeof(int16_t)));
     }
diff --git a/main/audio/codecs/box_audio_codec.h b/main/audio/codecs/box_audio_codec.h
@@ -5,6 +5,8 @@
 
 #include <esp_codec_dev.h>
 #include <esp_codec_dev_defaults.h>
+#include <mutex>
+
 
 class BoxAudioCodec : public AudioCodec {
 private:
@@ -17,6 +19,7 @@ class BoxAudioCodec : public AudioCodec {
 
     esp_codec_dev_handle_t output_dev_ = nullptr;
     esp_codec_dev_handle_t input_dev_ = nullptr;
+    std::mutex data_if_mutex_;
 
     void CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din);
 
diff --git a/main/audio/codecs/es8311_audio_codec.cc b/main/audio/codecs/es8311_audio_codec.cc
@@ -155,6 +155,7 @@ void Es8311AudioCodec::SetOutputVolume(int volume) {
 }
 
 void Es8311AudioCodec::EnableInput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == input_enabled_) {
         return;
     }
@@ -163,6 +164,7 @@ void Es8311AudioCodec::EnableInput(bool enable) {
 }
 
 void Es8311AudioCodec::EnableOutput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == output_enabled_) {
         return;
     }
@@ -171,13 +173,15 @@ void Es8311AudioCodec::EnableOutput(bool enable) {
 }
 
 int Es8311AudioCodec::Read(int16_t* dest, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (input_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(dev_, (void*)dest, samples * sizeof(int16_t)));
     }
     return samples;
 }
 
 int Es8311AudioCodec::Write(const int16_t* data, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (output_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(dev_, (void*)data, samples * sizeof(int16_t)));
     }
diff --git a/main/audio/codecs/es8311_audio_codec.h b/main/audio/codecs/es8311_audio_codec.h
@@ -7,6 +7,8 @@
 #include <driver/gpio.h>
 #include <esp_codec_dev.h>
 #include <esp_codec_dev_defaults.h>
+#include <mutex>
+
 
 class Es8311AudioCodec : public AudioCodec {
 private:
@@ -18,6 +20,7 @@ class Es8311AudioCodec : public AudioCodec {
     esp_codec_dev_handle_t dev_ = nullptr;
     gpio_num_t pa_pin_ = GPIO_NUM_NC;
     bool pa_inverted_ = false;
+    std::mutex data_if_mutex_;
 
     void CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din);
     void UpdateDeviceState();
diff --git a/main/audio/codecs/es8374_audio_codec.cc b/main/audio/codecs/es8374_audio_codec.cc
@@ -133,6 +133,7 @@ void Es8374AudioCodec::SetOutputVolume(int volume) {
 }
 
 void Es8374AudioCodec::EnableInput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == input_enabled_) {
         return;
     }
@@ -153,6 +154,7 @@ void Es8374AudioCodec::EnableInput(bool enable) {
 }
 
 void Es8374AudioCodec::EnableOutput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == output_enabled_) {
         return;
     }
@@ -180,13 +182,15 @@ void Es8374AudioCodec::EnableOutput(bool enable) {
 }
 
 int Es8374AudioCodec::Read(int16_t* dest, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (input_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void*)dest, samples * sizeof(int16_t)));
     }
     return samples;
 }
 
 int Es8374AudioCodec::Write(const int16_t* data, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (output_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void*)data, samples * sizeof(int16_t)));
     }
diff --git a/main/audio/codecs/es8374_audio_codec.h b/main/audio/codecs/es8374_audio_codec.h
@@ -7,6 +7,8 @@
 #include <driver/gpio.h>
 #include <esp_codec_dev.h>
 #include <esp_codec_dev_defaults.h>
+#include <mutex>
+
 
 class Es8374AudioCodec : public AudioCodec {
 private:
@@ -18,6 +20,7 @@ class Es8374AudioCodec : public AudioCodec {
     esp_codec_dev_handle_t output_dev_ = nullptr;
     esp_codec_dev_handle_t input_dev_ = nullptr;
     gpio_num_t pa_pin_ = GPIO_NUM_NC;
+    std::mutex data_if_mutex_;
 
     void CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din);
 
diff --git a/main/audio/codecs/es8388_audio_codec.cc b/main/audio/codecs/es8388_audio_codec.cc
@@ -137,6 +137,7 @@ void Es8388AudioCodec::SetOutputVolume(int volume) {
 }
 
 void Es8388AudioCodec::EnableInput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == input_enabled_) {
         return;
     }
@@ -157,6 +158,7 @@ void Es8388AudioCodec::EnableInput(bool enable) {
 }
 
 void Es8388AudioCodec::EnableOutput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == output_enabled_) {
         return;
     }
@@ -191,13 +193,15 @@ void Es8388AudioCodec::EnableOutput(bool enable) {
 }
 
 int Es8388AudioCodec::Read(int16_t* dest, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (input_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void*)dest, samples * sizeof(int16_t)));
     }
     return samples;
 }
 
 int Es8388AudioCodec::Write(const int16_t* data, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (output_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void*)data, samples * sizeof(int16_t)));
     }
diff --git a/main/audio/codecs/es8388_audio_codec.h b/main/audio/codecs/es8388_audio_codec.h
@@ -6,6 +6,8 @@
 #include <driver/i2c_master.h>
 #include <esp_codec_dev.h>
 #include <esp_codec_dev_defaults.h>
+#include <mutex>
+
 
 class Es8388AudioCodec : public AudioCodec {
 private:
@@ -17,6 +19,7 @@ class Es8388AudioCodec : public AudioCodec {
     esp_codec_dev_handle_t output_dev_ = nullptr;
     esp_codec_dev_handle_t input_dev_ = nullptr;
     gpio_num_t pa_pin_ = GPIO_NUM_NC;
+    std::mutex data_if_mutex_;
 
     void CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din);
 
diff --git a/main/audio/codecs/es8389_audio_codec.cc b/main/audio/codecs/es8389_audio_codec.cc
@@ -140,6 +140,7 @@ void Es8389AudioCodec::SetOutputVolume(int volume) {
 }
 
 void Es8389AudioCodec::EnableInput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == input_enabled_) {
         return;
     }
@@ -160,6 +161,7 @@ void Es8389AudioCodec::EnableInput(bool enable) {
 }
 
 void Es8389AudioCodec::EnableOutput(bool enable) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (enable == output_enabled_) {
         return;
     }
@@ -187,13 +189,15 @@ void Es8389AudioCodec::EnableOutput(bool enable) {
 }
 
 int Es8389AudioCodec::Read(int16_t* dest, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (input_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void*)dest, samples * sizeof(int16_t)));
     }
     return samples;
 }
 
 int Es8389AudioCodec::Write(const int16_t* data, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     if (output_enabled_) {
         ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void*)data, samples * sizeof(int16_t)));
     }
diff --git a/main/audio/codecs/es8389_audio_codec.h b/main/audio/codecs/es8389_audio_codec.h
@@ -7,6 +7,7 @@
 #include <driver/gpio.h>
 #include <esp_codec_dev.h>
 #include <esp_codec_dev_defaults.h>
+#include <mutex>
 
 class Es8389AudioCodec : public AudioCodec {
 private:
@@ -18,6 +19,7 @@ class Es8389AudioCodec : public AudioCodec {
     esp_codec_dev_handle_t output_dev_ = nullptr;
     esp_codec_dev_handle_t input_dev_ = nullptr;
     gpio_num_t pa_pin_ = GPIO_NUM_NC;
+    std::mutex data_if_mutex_;
 
     void CreateDuplexChannels(gpio_num_t mclk, gpio_num_t bclk, gpio_num_t ws, gpio_num_t dout, gpio_num_t din);
 
diff --git a/main/audio/codecs/no_audio_codec.cc b/main/audio/codecs/no_audio_codec.cc
@@ -279,6 +279,7 @@ NoAudioCodecSimplexPdm::NoAudioCodecSimplexPdm(int input_sample_rate, int output
 }
 
 int NoAudioCodec::Write(const int16_t* data, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     std::vector<int32_t> buffer(samples);
 
     // output_volume_: 0-100
@@ -301,6 +302,7 @@ int NoAudioCodec::Write(const int16_t* data, int samples) {
 }
 
 int NoAudioCodec::Read(int16_t* dest, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     size_t bytes_read;
 
     std::vector<int32_t> bit32_buffer(samples);
@@ -318,6 +320,7 @@ int NoAudioCodec::Read(int16_t* dest, int samples) {
 }
 
 int NoAudioCodecSimplexPdm::Read(int16_t* dest, int samples) {
+    std::lock_guard<std::mutex> lock(data_if_mutex_);
     size_t bytes_read;
 
     // PDM 解调后的数据位宽为 16 位，直接读取到目标缓冲区
diff --git a/main/audio/codecs/no_audio_codec.h b/main/audio/codecs/no_audio_codec.h
@@ -5,9 +5,12 @@
 
 #include <driver/gpio.h>
 #include <driver/i2s_pdm.h>
+#include <mutex>
 
 class NoAudioCodec : public AudioCodec {
-private:
+protected:
+    std::mutex data_if_mutex_;
+
     virtual int Write(const int16_t* data, int samples) override;
     virtual int Read(int16_t* dest, int samples) override;
 

Original file line number	Diff line number	Diff line change
`@@ -184,6 +184,7 @@ void BoxAudioCodec::SetOutputVolume(int volume) {`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`void BoxAudioCodec::EnableInput(bool enable) {`
	`187`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`187`	`188`	`if (enable == input_enabled_) {`
`188`	`189`	`return;`
`189`	`190`	`}`
`@@ -207,6 +208,7 @@ void BoxAudioCodec::EnableInput(bool enable) {`
`207`	`208`	`}`
`208`	`209`
`209`	`210`	`void BoxAudioCodec::EnableOutput(bool enable) {`
	`211`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`210`	`212`	`if (enable == output_enabled_) {`
`211`	`213`	`return;`
`212`	`214`	`}`
`@@ -228,13 +230,15 @@ void BoxAudioCodec::EnableOutput(bool enable) {`
`228`	`230`	`}`
`229`	`231`
`230`	`232`	`int BoxAudioCodec::Read(int16_t* dest, int samples) {`
	`233`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`231`	`234`	`if (input_enabled_) {`
`232`	`235`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void)dest, samples sizeof(int16_t)));`
`233`	`236`	`}`
`234`	`237`	`return samples;`
`235`	`238`	`}`
`236`	`239`
`237`	`240`	`int BoxAudioCodec::Write(const int16_t* data, int samples) {`
	`241`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`238`	`242`	`if (output_enabled_) {`
`239`	`243`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void)data, samples sizeof(int16_t)));`
`240`	`244`	`}`
Original file line number	Diff line number	Diff line change
`@@ -155,6 +155,7 @@ void Es8311AudioCodec::SetOutputVolume(int volume) {`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`void Es8311AudioCodec::EnableInput(bool enable) {`
	`158`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`158`	`159`	`if (enable == input_enabled_) {`
`159`	`160`	`return;`
`160`	`161`	`}`
`@@ -163,6 +164,7 @@ void Es8311AudioCodec::EnableInput(bool enable) {`
`163`	`164`	`}`
`164`	`165`
`165`	`166`	`void Es8311AudioCodec::EnableOutput(bool enable) {`
	`167`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`166`	`168`	`if (enable == output_enabled_) {`
`167`	`169`	`return;`
`168`	`170`	`}`
`@@ -171,13 +173,15 @@ void Es8311AudioCodec::EnableOutput(bool enable) {`
`171`	`173`	`}`
`172`	`174`
`173`	`175`	`int Es8311AudioCodec::Read(int16_t* dest, int samples) {`
	`176`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`174`	`177`	`if (input_enabled_) {`
`175`	`178`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(dev_, (void)dest, samples sizeof(int16_t)));`
`176`	`179`	`}`
`177`	`180`	`return samples;`
`178`	`181`	`}`
`179`	`182`
`180`	`183`	`int Es8311AudioCodec::Write(const int16_t* data, int samples) {`
	`184`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`181`	`185`	`if (output_enabled_) {`
`182`	`186`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(dev_, (void)data, samples sizeof(int16_t)));`
`183`	`187`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,6 +133,7 @@ void Es8374AudioCodec::SetOutputVolume(int volume) {`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`void Es8374AudioCodec::EnableInput(bool enable) {`
	`136`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`136`	`137`	`if (enable == input_enabled_) {`
`137`	`138`	`return;`
`138`	`139`	`}`
`@@ -153,6 +154,7 @@ void Es8374AudioCodec::EnableInput(bool enable) {`
`153`	`154`	`}`
`154`	`155`
`155`	`156`	`void Es8374AudioCodec::EnableOutput(bool enable) {`
	`157`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`156`	`158`	`if (enable == output_enabled_) {`
`157`	`159`	`return;`
`158`	`160`	`}`
`@@ -180,13 +182,15 @@ void Es8374AudioCodec::EnableOutput(bool enable) {`
`180`	`182`	`}`
`181`	`183`
`182`	`184`	`int Es8374AudioCodec::Read(int16_t* dest, int samples) {`
	`185`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`183`	`186`	`if (input_enabled_) {`
`184`	`187`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void)dest, samples sizeof(int16_t)));`
`185`	`188`	`}`
`186`	`189`	`return samples;`
`187`	`190`	`}`
`188`	`191`
`189`	`192`	`int Es8374AudioCodec::Write(const int16_t* data, int samples) {`
	`193`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`190`	`194`	`if (output_enabled_) {`
`191`	`195`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void)data, samples sizeof(int16_t)));`
`192`	`196`	`}`
Original file line number	Diff line number	Diff line change
`@@ -137,6 +137,7 @@ void Es8388AudioCodec::SetOutputVolume(int volume) {`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`void Es8388AudioCodec::EnableInput(bool enable) {`
	`140`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`140`	`141`	`if (enable == input_enabled_) {`
`141`	`142`	`return;`
`142`	`143`	`}`
`@@ -157,6 +158,7 @@ void Es8388AudioCodec::EnableInput(bool enable) {`
`157`	`158`	`}`
`158`	`159`
`159`	`160`	`void Es8388AudioCodec::EnableOutput(bool enable) {`
	`161`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`160`	`162`	`if (enable == output_enabled_) {`
`161`	`163`	`return;`
`162`	`164`	`}`
`@@ -191,13 +193,15 @@ void Es8388AudioCodec::EnableOutput(bool enable) {`
`191`	`193`	`}`
`192`	`194`
`193`	`195`	`int Es8388AudioCodec::Read(int16_t* dest, int samples) {`
	`196`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`194`	`197`	`if (input_enabled_) {`
`195`	`198`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void)dest, samples sizeof(int16_t)));`
`196`	`199`	`}`
`197`	`200`	`return samples;`
`198`	`201`	`}`
`199`	`202`
`200`	`203`	`int Es8388AudioCodec::Write(const int16_t* data, int samples) {`
	`204`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`201`	`205`	`if (output_enabled_) {`
`202`	`206`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void)data, samples sizeof(int16_t)));`
`203`	`207`	`}`
Original file line number	Diff line number	Diff line change
`@@ -140,6 +140,7 @@ void Es8389AudioCodec::SetOutputVolume(int volume) {`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`void Es8389AudioCodec::EnableInput(bool enable) {`
	`143`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`143`	`144`	`if (enable == input_enabled_) {`
`144`	`145`	`return;`
`145`	`146`	`}`
`@@ -160,6 +161,7 @@ void Es8389AudioCodec::EnableInput(bool enable) {`
`160`	`161`	`}`
`161`	`162`
`162`	`163`	`void Es8389AudioCodec::EnableOutput(bool enable) {`
	`164`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`163`	`165`	`if (enable == output_enabled_) {`
`164`	`166`	`return;`
`165`	`167`	`}`
`@@ -187,13 +189,15 @@ void Es8389AudioCodec::EnableOutput(bool enable) {`
`187`	`189`	`}`
`188`	`190`
`189`	`191`	`int Es8389AudioCodec::Read(int16_t* dest, int samples) {`
	`192`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`190`	`193`	`if (input_enabled_) {`
`191`	`194`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void)dest, samples sizeof(int16_t)));`
`192`	`195`	`}`
`193`	`196`	`return samples;`
`194`	`197`	`}`
`195`	`198`
`196`	`199`	`int Es8389AudioCodec::Write(const int16_t* data, int samples) {`
	`200`	`+ std::lock_guard<std::mutex> lock(data_if_mutex_);`
`197`	`201`	`if (output_enabled_) {`
`198`	`202`	`ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void)data, samples sizeof(int16_t)));`
`199`	`203`	`}`