fit the memory usage for esp32c3

main/audio_codecs/audio_codec.cc

@@ -9,34 +9,48 @@
 #define TAG "AudioCodec"
 
 AudioCodec::AudioCodec() {
-    audio_event_group_ = xEventGroupCreate();
 }
 
 AudioCodec::~AudioCodec() {
-    if (audio_input_task_ != nullptr) {
-        vTaskDelete(audio_input_task_);
-    }
-    if (audio_output_task_ != nullptr) {
-        vTaskDelete(audio_output_task_);
-    }
-    if (audio_event_group_ != nullptr) {
-        vEventGroupDelete(audio_event_group_);
-    }
 }
 
-void AudioCodec::OnInputData(std::function<void(std::vector<int16_t>&& data)> callback) {
-    on_input_data_ = callback;
+void AudioCodec::OnInputReady(std::function<bool()> callback) {
+    on_input_ready_ = callback;
+}
+
+void AudioCodec::OnOutputReady(std::function<bool()> callback) {
+    on_output_ready_ = callback;
 }
 
 void AudioCodec::OutputData(std::vector<int16_t>& data) {
-    std::lock_guard<std::mutex> lock(audio_output_queue_mutex_);
-    audio_output_queue_.emplace_back(std::move(data));
-    audio_output_queue_cv_.notify_one();
+    Write(data.data(), data.size());
+}
+
+bool AudioCodec::InputData(std::vector<int16_t>& data) {
+    int duration = 30;
+    int input_frame_size = input_sample_rate_ / 1000 * duration * input_channels_;
+
+    data.resize(input_frame_size);
+    int samples = Read(data.data(), data.size());
+    if (samples > 0) {
+        return true;
+    }
+    return false;
 }
 
 IRAM_ATTR bool AudioCodec::on_sent(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx) {
     auto audio_codec = (AudioCodec*)user_ctx;
-    xEventGroupSetBits(audio_codec->audio_event_group_, AUDIO_EVENT_OUTPUT_DONE);
+    if (audio_codec->output_enabled_ && audio_codec->on_output_ready_) {
+        return audio_codec->on_output_ready_();
+    }
+    return false;
+}
+
+IRAM_ATTR bool AudioCodec::on_recv(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx) {
+    auto audio_codec = (AudioCodec*)user_ctx;
+    if (audio_codec->input_enabled_ && audio_codec->on_input_ready_) {
+        return audio_codec->on_input_ready_();
+    }
     return false;
 }
 
@@ -44,85 +58,20 @@ void AudioCodec::Start() {
     Settings settings("audio", false);
     output_volume_ = settings.GetInt("output_volume", output_volume_);
 
-    // 注册音频输出回调
-    i2s_event_callbacks_t callbacks = {};
-    callbacks.on_sent = on_sent;
-    i2s_channel_register_event_callback(tx_handle_, &callbacks, this);
+    // 注册音频数据回调
+    i2s_event_callbacks_t rx_callbacks = {};
+    rx_callbacks.on_recv = on_recv;
+    i2s_channel_register_event_callback(rx_handle_, &rx_callbacks, this);
+
+    i2s_event_callbacks_t tx_callbacks = {};
+    tx_callbacks.on_sent = on_sent;
+    i2s_channel_register_event_callback(tx_handle_, &tx_callbacks, this);
 
     ESP_ERROR_CHECK(i2s_channel_enable(tx_handle_));
     ESP_ERROR_CHECK(i2s_channel_enable(rx_handle_));
 
     EnableInput(true);
     EnableOutput(true);
-
-    // 创建音频输入任务
-    if (audio_input_task_ == nullptr) {
-        xTaskCreate([](void* arg) {
-            auto audio_device = (AudioCodec*)arg;
-            audio_device->InputTask();
-        }, "audio_input", 4096 * 2, this, 3, &audio_input_task_);
-    }
-    // 创建音频输出任务
-    if (audio_output_task_ == nullptr) {
-        xTaskCreate([](void* arg) {
-            auto audio_device = (AudioCodec*)arg;
-            audio_device->OutputTask();
-        }, "audio_output", 4096 * 2, this, 3, &audio_output_task_);
-    }
-}
-
-void AudioCodec::InputTask() {
-    int duration = 30;
-    int input_frame_size = input_sample_rate_ / 1000 * duration * input_channels_;
-
-    while (true) {
-        std::vector<int16_t> input_data(input_frame_size);
-        int samples = Read(input_data.data(), input_data.size());
-        if (samples > 0) {
-            if (on_input_data_) {
-                on_input_data_(std::move(input_data));
-            }
-        }
-    }
-}
-
-void AudioCodec::OutputTask() {
-    while (true) {
-        std::unique_lock<std::mutex> lock(audio_output_queue_mutex_);
-        if (!audio_output_queue_cv_.wait_for(lock, std::chrono::seconds(30), [this]() {
-                return !audio_output_queue_.empty();
-            })) {
-            // If timeout, disable output
-            EnableOutput(false);
-            continue;
-        }
-        auto data = std::move(audio_output_queue_.front());
-        audio_output_queue_.pop_front();
-        lock.unlock();
-
-        if (!output_enabled_) {
-            EnableOutput(true);
-        }
-
-        xEventGroupClearBits(audio_event_group_, AUDIO_EVENT_OUTPUT_DONE);
-        Write(data.data(), data.size());
-        audio_output_queue_cv_.notify_all();
-    }
-}
-
-void AudioCodec::WaitForOutputDone() {
-    // Wait for the output queue to be empty and the output is done
-    std::unique_lock<std::mutex> lock(audio_output_queue_mutex_);
-    audio_output_queue_cv_.wait(lock, [this]() {
-        return audio_output_queue_.empty();
-    });
-    lock.unlock();
-    xEventGroupWaitBits(audio_event_group_, AUDIO_EVENT_OUTPUT_DONE, pdFALSE, pdFALSE, portMAX_DELAY);
-}
-
-void AudioCodec::ClearOutputQueue() {
-    std::lock_guard<std::mutex> lock(audio_output_queue_mutex_);
-    audio_output_queue_.clear();
 }
 
 void AudioCodec::SetOutputVolume(int volume) {