加入中文UI

main/audio_codecs/audio_codec.cc

@@ -0,0 +1,150 @@
+#include "audio_codec.h"
+#include "board.h"
+#include "settings.h"
+
+#include <esp_log.h>
+#include <cstring>
+#include <driver/i2s_common.h>
+
+#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::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();
+}
+
+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);
+    return false;
+}
+
+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);
+
+    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) {
+    output_volume_ = volume;
+    ESP_LOGI(TAG, "Set output volume to %d", output_volume_);
+    
+    Settings settings("audio", true);
+    settings.SetInt("output_volume", output_volume_);
+}
+
+void AudioCodec::EnableInput(bool enable) {
+    if (enable == input_enabled_) {
+        return;
+    }
+    input_enabled_ = enable;
+    ESP_LOGI(TAG, "Set input enable to %s", enable ? "true" : "false");
+}
+
+void AudioCodec::EnableOutput(bool enable) {
+    if (enable == output_enabled_) {
+        return;
+    }
+    output_enabled_ = enable;
+    ESP_LOGI(TAG, "Set output enable to %s", enable ? "true" : "false");
+}

main/audio_codecs/audio_codec.h

@@ -0,0 +1,74 @@
+#ifndef _AUDIO_CODEC_H
+#define _AUDIO_CODEC_H
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+#include <freertos/event_groups.h>
+#include <driver/i2s_std.h>
+
+#include <vector>
+#include <string>
+#include <functional>
+#include <list>
+#include <mutex>
+#include <condition_variable>
+
+#include "board.h"
+
+#define AUDIO_EVENT_OUTPUT_DONE (1 << 0)
+
+class AudioCodec {
+public:
+    AudioCodec();
+    virtual ~AudioCodec();
+    
+    virtual void SetOutputVolume(int volume);
+    virtual void EnableInput(bool enable);
+    virtual void EnableOutput(bool enable);
+
+    void Start();
+    void OnInputData(std::function<void(std::vector<int16_t>&& data)> callback);
+    void OutputData(std::vector<int16_t>& data);
+    void WaitForOutputDone();
+    void ClearOutputQueue();
+
+    inline bool duplex() const { return duplex_; }
+    inline bool input_reference() const { return input_reference_; }
+    inline int input_sample_rate() const { return input_sample_rate_; }
+    inline int output_sample_rate() const { return output_sample_rate_; }
+    inline int input_channels() const { return input_channels_; }
+    inline int output_channels() const { return output_channels_; }
+    inline int output_volume() const { return output_volume_; }
+
+private:
+    TaskHandle_t audio_input_task_ = nullptr;
+    TaskHandle_t audio_output_task_ = nullptr;
+    std::function<void(std::vector<int16_t>&& data)> on_input_data_; 
+    std::list<std::vector<int16_t>> audio_output_queue_;
+    std::mutex audio_output_queue_mutex_;
+    std::condition_variable audio_output_queue_cv_;
+    EventGroupHandle_t audio_event_group_ = nullptr;
+    IRAM_ATTR static bool on_sent(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx);
+
+    void InputTask();
+    void OutputTask();
+
+protected:
+    i2s_chan_handle_t tx_handle_ = nullptr;
+    i2s_chan_handle_t rx_handle_ = nullptr;
+
+    bool duplex_ = false;
+    bool input_reference_ = false;
+    bool input_enabled_ = false;
+    bool output_enabled_ = false;
+    int input_sample_rate_ = 0;
+    int output_sample_rate_ = 0;
+    int input_channels_ = 1;
+    int output_channels_ = 1;
+    int output_volume_ = 70;
+
+    virtual int Read(int16_t* dest, int samples) = 0;
+    virtual int Write(const int16_t* data, int samples) = 0;
+};
+
+#endif // _AUDIO_CODEC_H

main/audio_codecs/box_audio_codec.h

@@ -22,8 +22,6 @@ private:
 
     virtual int Read(int16_t* dest, int samples) override;
     virtual int Write(const int16_t* data, int samples) override;
-    virtual void EnableInput(bool enable) override;
-    virtual void EnableOutput(bool enable) override;
 
 public:
     BoxAudioCodec(void* i2c_master_handle, int input_sample_rate, int output_sample_rate,
@@ -32,6 +30,8 @@ public:
     virtual ~BoxAudioCodec();
 
     virtual void SetOutputVolume(int volume) override;
+    virtual void EnableInput(bool enable) override;
+    virtual void EnableOutput(bool enable) override;
 };
 
 #endif // _BOX_AUDIO_CODEC_H