Merge remote-tracking branch 'origin/feature/musicQuan' into feat/musicIoT-Bluetooth

Author: MinhQuan7

main/application.cc

@@ -63,6 +63,10 @@ class Application {
     AecMode GetAecMode() const { return aec_mode_; }
     void PlaySound(const std::string_view& sound);
     AudioService& GetAudioService() { return audio_service_; }
+    void StartMusicStreaming(const std::string& url);
+    void StopMusicStreaming();
+    // New: Receive external audio data (such as music playback)
+    void AddAudioData(AudioStreamPacket&& packet);
 
 private:
     Application();

main/application.h

@@ -34,6 +34,12 @@ void AudioCodec::Start() {
         output_volume_ = 10;
     }
 
+    // 保存原始输出采样率
+    if (original_output_sample_rate_ == 0) {
+        original_output_sample_rate_ = output_sample_rate_;
+        ESP_LOGI(TAG, "Saved original output sample rate: %d Hz", original_output_sample_rate_);
+    }
+
     if (tx_handle_ != nullptr) {
         ESP_ERROR_CHECK(i2s_channel_enable(tx_handle_));
     }
@@ -75,3 +81,74 @@ void AudioCodec::EnableOutput(bool enable) {
     output_enabled_ = enable;
     ESP_LOGI(TAG, "Set output enable to %s", enable ? "true" : "false");
 }
+
+bool AudioCodec::SetOutputSampleRate(int sample_rate) {
+    // 特殊处理：如果传入 -1，表示重置到原始采样率
+    if (sample_rate == -1) {
+        if (original_output_sample_rate_ > 0) {
+            sample_rate = original_output_sample_rate_;
+            ESP_LOGI(TAG, "Resetting to original output sample rate: %d Hz", sample_rate);
+        } else {
+            ESP_LOGW(TAG, "Original sample rate not available, cannot reset");
+            return false;
+        }
+    }
+
+    if (sample_rate <= 0 || sample_rate > 192000) {
+        ESP_LOGE(TAG, "Invalid sample rate: %d", sample_rate);
+        return false;
+    }
+
+    if (output_sample_rate_ == sample_rate) {
+        ESP_LOGI(TAG, "Sample rate already set to %d Hz", sample_rate);
+        return true;
+    }
+
+    if (tx_handle_ == nullptr) {
+        ESP_LOGW(TAG, "TX handle is null, only updating sample rate variable");
+        output_sample_rate_ = sample_rate;
+        return true;
+    }
+
+    ESP_LOGI(TAG, "Changing output sample rate from %d to %d Hz", output_sample_rate_, sample_rate);
+
+    // 先尝试禁用 I2S 通道（如果已启用的话）
+    esp_err_t disable_ret = i2s_channel_disable(tx_handle_);
+    if (disable_ret == ESP_OK) {
+        ESP_LOGI(TAG, "Disabled I2S TX channel for reconfiguration");
+    } else if (disable_ret == ESP_ERR_INVALID_STATE) {
+        // 通道可能已经是禁用状态，这是正常的
+        ESP_LOGI(TAG, "I2S TX channel was already disabled");
+    } else {
+        ESP_LOGW(TAG, "Failed to disable I2S TX channel: %s", esp_err_to_name(disable_ret));
+    }
+
+    // 重新配置 I2S 时钟
+    i2s_std_clk_config_t clk_cfg = {
+        .sample_rate_hz = (uint32_t)sample_rate,
+        .clk_src = I2S_CLK_SRC_DEFAULT,
+        .mclk_multiple = I2S_MCLK_MULTIPLE_256,
+#ifdef I2S_HW_VERSION_2
+        .ext_clk_freq_hz = 0,
+#endif
+    };
+
+    esp_err_t ret = i2s_channel_reconfig_std_clock(tx_handle_, &clk_cfg);
+
+    // 重新启用通道（无论之前是什么状态，现在都需要启用以便播放音频）
+    esp_err_t enable_ret = i2s_channel_enable(tx_handle_);
+    if (enable_ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to enable I2S TX channel: %s", esp_err_to_name(enable_ret));
+    } else {
+        ESP_LOGI(TAG, "Enabled I2S TX channel");
+    }
+
+    if (ret == ESP_OK) {
+        output_sample_rate_ = sample_rate;
+        ESP_LOGI(TAG, "Successfully changed output sample rate to %d Hz", sample_rate);
+        return true;
+    } else {
+        ESP_LOGE(TAG, "Failed to change sample rate to %d Hz: %s", sample_rate, esp_err_to_name(ret));
+        return false;
+    }
+}

main/audio/audio_codec.cc

@@ -23,6 +23,7 @@ class AudioCodec {
     virtual void SetInputGain(float gain);
     virtual void EnableInput(bool enable);
     virtual void EnableOutput(bool enable);
+    virtual bool SetOutputSampleRate(int sample_rate);
 
     virtual void OutputData(std::vector<int16_t>& data);
     virtual bool InputData(std::vector<int16_t>& data);
@@ -32,6 +33,7 @@ class AudioCodec {
     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 original_output_sample_rate() const { return original_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_; }
@@ -49,6 +51,7 @@ class AudioCodec {
     bool output_enabled_ = false;
     int input_sample_rate_ = 0;
     int output_sample_rate_ = 0;
+    int original_output_sample_rate_ = 0;
     int input_channels_ = 1;
     int output_channels_ = 1;
     int output_volume_ = 70;

main/audio/audio_codec.h

@@ -634,6 +634,15 @@ void AudioService::ResetDecoder() {
     audio_queue_cv_.notify_all();
 }
 
+void AudioService::UpdateOutputTimestamp() {
+    last_output_time_ = std::chrono::steady_clock::now();
+    // Debug: Log timestamp updates during music playback (reduce frequency)
+    static int update_count = 0;
+    if (update_count++ % 50 == 0) {  // Log every 50 updates
+        ESP_LOGD(TAG, "Updated output timestamp (update #%d)", update_count);
+    }
+}
+
 void AudioService::CheckAndUpdateAudioPowerState() {
     auto now = std::chrono::steady_clock::now();
     auto input_elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - last_input_time_).count();

main/audio/audio_service.cc

@@ -108,6 +108,7 @@ class AudioService {
     void PlaySound(const std::string_view& sound);
     bool ReadAudioData(std::vector<int16_t>& data, int sample_rate, int samples);
     void ResetDecoder();
+    void UpdateOutputTimestamp();
     void SetModelsList(srmodel_list_t* models_list);
 
 private:
@@ -158,4 +159,4 @@ class AudioService {
     void CheckAndUpdateAudioPowerState();
 };
 
-#endif
+#endif

main/audio/audio_service.h

@@ -13,33 +13,34 @@
 #include "audio_processor.h"
 #include "audio_codec.h"
 
-class AfeAudioProcessor : public AudioProcessor {
+class AfeAudioProcessor : public AudioProcessor
+{
 public:
     AfeAudioProcessor();
     ~AfeAudioProcessor();
 
-    void Initialize(AudioCodec* codec, int frame_duration_ms, srmodel_list_t* models_list) override;
-    void Feed(std::vector<int16_t>&& data) override;
+    void Initialize(AudioCodec *codec, int frame_duration_ms, srmodel_list_t *models_list) override;
+    void Feed(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 OnOutput(std::function<void(std::vector<int16_t> &&data)> callback) override;
     void OnVadStateChange(std::function<void(bool speaking)> callback) override;
     size_t GetFeedSize() override;
     void EnableDeviceAec(bool enable) 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_;
+    const 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;
+    AudioCodec *codec_ = nullptr;
     int frame_samples_ = 0;
     bool is_speaking_ = false;
     std::vector<int16_t> output_buffer_;
 
     void AudioProcessorTask();
 };
 
-#endif 
+#endif

main/audio/processors/afe_audio_processor.h

@@ -2,6 +2,8 @@
 #include "audio_service.h"
 
 #include <esp_log.h>
+#include <esp_heap_caps.h>
+#include <cstring>
 #include <sstream>
 
 #define DETECTION_RUNNING_EVENT 1
@@ -106,10 +108,30 @@ void AfeWakeWord::Stop() {
 }
 
 void AfeWakeWord::Feed(const std::vector<int16_t>& data) {
-    if (afe_data_ == nullptr) {
+    if (afe_data_ == nullptr || data.empty()) {
+        return;
+    }
+    
+    // Always ensure 4-byte alignment for AFE ring buffer
+    // std::vector doesn't guarantee alignment, so we always copy to aligned buffer
+    size_t data_size_bytes = data.size() * sizeof(int16_t);
+    
+    // Allocate aligned buffer (4-byte alignment, round up to multiple of 4)
+    size_t aligned_size = (data_size_bytes + 3) & ~3;  // Round up to multiple of 4
+    int16_t* aligned_data = static_cast<int16_t*>(heap_caps_aligned_alloc(4, aligned_size, MALLOC_CAP_INTERNAL));
+    if (aligned_data == nullptr) {
+        ESP_LOGE(TAG, "Failed to allocate aligned buffer for AFE feed (size: %zu)", aligned_size);
         return;
     }
-    afe_iface_->feed(afe_data_, data.data());
+    
+    // Copy data to aligned buffer
+    memcpy(aligned_data, data.data(), data_size_bytes);
+    
+    // Feed aligned data to AFE
+    afe_iface_->feed(afe_data_, aligned_data);
+    
+    // Free aligned buffer
+    heap_caps_free(aligned_data);
 }
 
 size_t AfeWakeWord::GetFeedSize() {

main/audio/wake_words/afe_wake_word.cc

@@ -19,41 +19,42 @@
 #include "audio_codec.h"
 #include "wake_word.h"
 
-class AfeWakeWord : public WakeWord {
+class AfeWakeWord : public WakeWord
+{
 public:
     AfeWakeWord();
     ~AfeWakeWord();
 
-    bool Initialize(AudioCodec* codec, srmodel_list_t* models_list);
-    void Feed(const std::vector<int16_t>& data);
-    void OnWakeWordDetected(std::function<void(const std::string& wake_word)> callback);
+    bool Initialize(AudioCodec *codec, srmodel_list_t *models_list);
+    void Feed(const std::vector<int16_t> &data);
+    void OnWakeWordDetected(std::function<void(const std::string &wake_word)> callback);
     void Start();
     void Stop();
     size_t GetFeedSize();
     void EncodeWakeWordData();
-    bool GetWakeWordOpus(std::vector<uint8_t>& opus);
-    const std::string& GetLastDetectedWakeWord() const { return last_detected_wake_word_; }
+    bool GetWakeWordOpus(std::vector<uint8_t> &opus);
+    const std::string &GetLastDetectedWakeWord() const { return last_detected_wake_word_; }
 
 private:
     srmodel_list_t *models_ = nullptr;
-    esp_afe_sr_iface_t* afe_iface_ = nullptr;
-    esp_afe_sr_data_t* afe_data_ = nullptr;
-    char* wakenet_model_ = NULL;
+    const esp_afe_sr_iface_t *afe_iface_ = nullptr;
+    esp_afe_sr_data_t *afe_data_ = nullptr;
+    char *wakenet_model_ = NULL;
     std::vector<std::string> wake_words_;
     EventGroupHandle_t event_group_;
-    std::function<void(const std::string& wake_word)> wake_word_detected_callback_;
-    AudioCodec* codec_ = nullptr;
+    std::function<void(const std::string &wake_word)> wake_word_detected_callback_;
+    AudioCodec *codec_ = nullptr;
     std::string last_detected_wake_word_;
 
     TaskHandle_t wake_word_encode_task_ = nullptr;
-    StaticTask_t* wake_word_encode_task_buffer_ = nullptr;
-    StackType_t* wake_word_encode_task_stack_ = nullptr;
+    StaticTask_t *wake_word_encode_task_buffer_ = nullptr;
+    StackType_t *wake_word_encode_task_stack_ = nullptr;
     std::deque<std::vector<int16_t>> wake_word_pcm_;
     std::deque<std::vector<uint8_t>> wake_word_opus_;
     std::mutex wake_word_mutex_;
     std::condition_variable wake_word_cv_;
 
-    void StoreWakeWordData(const int16_t* data, size_t size);
+    void StoreWakeWordData(const int16_t *data, size_t size);
     void AudioDetectionTask();
 };
 

main/audio/wake_words/afe_wake_word.h

@@ -4,6 +4,7 @@
 #include "display/display.h"
 #include "display/oled_display.h"
 #include "assets/lang_config.h"
+#include "boards/common/esp32_music.h"
 
 #include <esp_log.h>
 #include <esp_ota_ops.h>
@@ -20,6 +21,12 @@ Board::Board() {
         settings.SetString("uuid", uuid_);
     }
     ESP_LOGI(TAG, "UUID=%s SKU=%s", uuid_.c_str(), BOARD_NAME);
+    InitializeMusic();
+}
+
+void Board::InitializeMusic() {
+    ESP_LOGI(TAG, "Initialize Music");
+    music_ = new Esp32Music();
 }
 
 std::string Board::GenerateUuid() {
@@ -62,6 +69,10 @@ Camera* Board::GetCamera() {
     return nullptr;
 }
 
+Music* Board::GetMusic() {
+    return music_;
+}
+
 Led* Board::GetLed() {
     static NoLed led;
     return &led;