Add dummy audio processor

main/audio_processing/afe_audio_processor.cc

@@ -1,16 +1,16 @@
-#include "audio_processor.h"
+#include "afe_audio_processor.h"
 #include <esp_log.h>
 
 #define PROCESSOR_RUNNING 0x01
 
-static const char* TAG = "AudioProcessor";
+static const char* TAG = "AfeAudioProcessor";
 
-AudioProcessor::AudioProcessor()
+AfeAudioProcessor::AfeAudioProcessor()
     : afe_data_(nullptr) {
     event_group_ = xEventGroupCreate();
 }
 
-void AudioProcessor::Initialize(AudioCodec* codec, bool realtime_chat) {
+void AfeAudioProcessor::Initialize(AudioCodec* codec, bool realtime_chat) {
     codec_ = codec;
     int ref_num = codec_->input_reference() ? 1 : 0;
 
@@ -51,57 +51,57 @@ void AudioProcessor::Initialize(AudioCodec* codec, bool realtime_chat) {
     afe_data_ = afe_iface_->create_from_config(afe_config);
     
     xTaskCreate([](void* arg) {
-        auto this_ = (AudioProcessor*)arg;
+        auto this_ = (AfeAudioProcessor*)arg;
         this_->AudioProcessorTask();
         vTaskDelete(NULL);
     }, "audio_communication", 4096, this, 3, NULL);
 }
 
-AudioProcessor::~AudioProcessor() {
+AfeAudioProcessor::~AfeAudioProcessor() {
     if (afe_data_ != nullptr) {
         afe_iface_->destroy(afe_data_);
     }
     vEventGroupDelete(event_group_);
 }
 
-size_t AudioProcessor::GetFeedSize() {
+size_t AfeAudioProcessor::GetFeedSize() {
     if (afe_data_ == nullptr) {
         return 0;
     }
     return afe_iface_->get_feed_chunksize(afe_data_) * codec_->input_channels();
 }
 
-void AudioProcessor::Feed(const std::vector<int16_t>& data) {
+void AfeAudioProcessor::Feed(const std::vector<int16_t>& data) {
     if (afe_data_ == nullptr) {
         return;
     }
     afe_iface_->feed(afe_data_, data.data());
 }
 
-void AudioProcessor::Start() {
+void AfeAudioProcessor::Start() {
     xEventGroupSetBits(event_group_, PROCESSOR_RUNNING);
 }
 
-void AudioProcessor::Stop() {
+void AfeAudioProcessor::Stop() {
     xEventGroupClearBits(event_group_, PROCESSOR_RUNNING);
     if (afe_data_ != nullptr) {
         afe_iface_->reset_buffer(afe_data_);
     }
 }
 
-bool AudioProcessor::IsRunning() {
+bool AfeAudioProcessor::IsRunning() {
     return xEventGroupGetBits(event_group_) & PROCESSOR_RUNNING;
 }
 
-void AudioProcessor::OnOutput(std::function<void(std::vector<int16_t>&& data)> callback) {
+void AfeAudioProcessor::OnOutput(std::function<void(std::vector<int16_t>&& data)> callback) {
     output_callback_ = callback;
 }
 
-void AudioProcessor::OnVadStateChange(std::function<void(bool speaking)> callback) {
+void AfeAudioProcessor::OnVadStateChange(std::function<void(bool speaking)> callback) {
     vad_state_change_callback_ = callback;
 }
 
-void AudioProcessor::AudioProcessorTask() {
+void AfeAudioProcessor::AudioProcessorTask() {
     auto fetch_size = afe_iface_->get_fetch_chunksize(afe_data_);
     auto feed_size = afe_iface_->get_feed_chunksize(afe_data_);
     ESP_LOGI(TAG, "Audio communication task started, feed size: %d fetch size: %d",
@@ -136,4 +136,4 @@ void AudioProcessor::AudioProcessorTask() {
             output_callback_(std::vector<int16_t>(res->data, res->data + res->data_size / sizeof(int16_t)));
         }
     }
-}
+} 

main/audio_processing/afe_audio_processor.h

@@ -0,0 +1,42 @@
+#ifndef AFE_AUDIO_PROCESSOR_H
+#define AFE_AUDIO_PROCESSOR_H
+
+#include <esp_afe_sr_models.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+#include <freertos/event_groups.h>
+
+#include <string>
+#include <vector>
+#include <functional>
+
+#include "audio_processor.h"
+#include "audio_codec.h"
+
+class AfeAudioProcessor : public AudioProcessor {
+public:
+    AfeAudioProcessor();
+    ~AfeAudioProcessor();
+
+    void Initialize(AudioCodec* codec, bool realtime_chat) override;
+    void Feed(const std::vector<int16_t>& data) override;
+    void Start() override;
+    void Stop() override;
+    bool IsRunning() override;
+    void OnOutput(std::function<void(std::vector<int16_t>&& data)> callback) override;
+    void OnVadStateChange(std::function<void(bool speaking)> callback) override;
+    size_t GetFeedSize() override;
+
+private:
+    EventGroupHandle_t event_group_ = nullptr;
+    esp_afe_sr_iface_t* afe_iface_ = nullptr;
+    esp_afe_sr_data_t* afe_data_ = nullptr;
+    std::function<void(std::vector<int16_t>&& data)> output_callback_;
+    std::function<void(bool speaking)> vad_state_change_callback_;
+    AudioCodec* codec_ = nullptr;
+    bool is_speaking_ = false;
+
+    void AudioProcessorTask();
+};
+
+#endif 

main/audio_processing/audio_processor.h

@@ -1,11 +1,6 @@
 #ifndef AUDIO_PROCESSOR_H
 #define AUDIO_PROCESSOR_H
 
-#include <esp_afe_sr_models.h>
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-#include <freertos/event_groups.h>
-
 #include <string>
 #include <vector>
 #include <functional>
@@ -14,28 +9,16 @@
 
 class AudioProcessor {
 public:
-    AudioProcessor();
-    ~AudioProcessor();
-
-    void Initialize(AudioCodec* codec, bool realtime_chat);
-    void Feed(const std::vector<int16_t>& data);
-    void Start();
-    void Stop();
-    bool IsRunning();
-    void OnOutput(std::function<void(std::vector<int16_t>&& data)> callback);
-    void OnVadStateChange(std::function<void(bool speaking)> callback);
-    size_t GetFeedSize();
-
-private:
-    EventGroupHandle_t event_group_ = nullptr;
-    esp_afe_sr_iface_t* afe_iface_ = nullptr;
-    esp_afe_sr_data_t* afe_data_ = nullptr;
-    std::function<void(std::vector<int16_t>&& data)> output_callback_;
-    std::function<void(bool speaking)> vad_state_change_callback_;
-    AudioCodec* codec_ = nullptr;
-    bool is_speaking_ = false;
-
-    void AudioProcessorTask();
+    virtual ~AudioProcessor() = default;
+    
+    virtual void Initialize(AudioCodec* codec, bool realtime_chat) = 0;
+    virtual void Feed(const std::vector<int16_t>& data) = 0;
+    virtual void Start() = 0;
+    virtual void Stop() = 0;
+    virtual bool IsRunning() = 0;
+    virtual void OnOutput(std::function<void(std::vector<int16_t>&& data)> callback) = 0;
+    virtual void OnVadStateChange(std::function<void(bool speaking)> callback) = 0;
+    virtual size_t GetFeedSize() = 0;
 };
 
 #endif

main/audio_processing/dummy_audio_processor.cc

@@ -0,0 +1,44 @@
+#include "dummy_audio_processor.h"
+#include <esp_log.h>
+
+static const char* TAG = "DummyAudioProcessor";
+
+void DummyAudioProcessor::Initialize(AudioCodec* codec, bool realtime_chat) {
+    codec_ = codec;
+}
+
+void DummyAudioProcessor::Feed(const std::vector<int16_t>& data) {
+    if (!is_running_ || !output_callback_) {
+        return;
+    }
+    // 直接将输入数据传递给输出回调
+    output_callback_(std::vector<int16_t>(data));
+}
+
+void DummyAudioProcessor::Start() {
+    is_running_ = true;
+}
+
+void DummyAudioProcessor::Stop() {
+    is_running_ = false;
+}
+
+bool DummyAudioProcessor::IsRunning() {
+    return is_running_;
+}
+
+void DummyAudioProcessor::OnOutput(std::function<void(std::vector<int16_t>&& data)> callback) {
+    output_callback_ = callback;
+}
+
+void DummyAudioProcessor::OnVadStateChange(std::function<void(bool speaking)> callback) {
+    vad_state_change_callback_ = callback;
+}
+
+size_t DummyAudioProcessor::GetFeedSize() {
+    if (!codec_) {
+        return 0;
+    }
+    // 返回一个固定的帧大小，比如 30ms 的数据
+    return 30 * codec_->input_sample_rate() / 1000;
+}

main/audio_processing/dummy_audio_processor.h

@@ -0,0 +1,31 @@
+#ifndef DUMMY_AUDIO_PROCESSOR_H
+#define DUMMY_AUDIO_PROCESSOR_H
+
+#include <vector>
+#include <functional>
+
+#include "audio_processor.h"
+#include "audio_codec.h"
+
+class DummyAudioProcessor : public AudioProcessor {
+public:
+    DummyAudioProcessor() = default;
+    ~DummyAudioProcessor() = default;
+
+    void Initialize(AudioCodec* codec, bool realtime_chat) override;
+    void Feed(const std::vector<int16_t>& data) override;
+    void Start() override;
+    void Stop() override;
+    bool IsRunning() override;
+    void OnOutput(std::function<void(std::vector<int16_t>&& data)> callback) override;
+    void OnVadStateChange(std::function<void(bool speaking)> callback) override;
+    size_t GetFeedSize() override;
+
+private:
+    AudioCodec* codec_ = nullptr;
+    std::function<void(std::vector<int16_t>&& data)> output_callback_;
+    std::function<void(bool speaking)> vad_state_change_callback_;
+    bool is_running_ = false;
+};
+
+#endif