#include "system.h"
|
#include "app_task.h"
|
|
#include "audio_codec.h"
|
#include "board.h"
|
#include "application.h"
|
|
#include <esp_log.h>
|
#include <esp_heap_caps.h>
|
#include <freertos/FreeRTOS.h>
|
#include <freertos/semphr.h>
|
#include <freertos/task.h>
|
|
#include <esp_audio_simple_dec.h>
|
#include <esp_audio_simple_dec_default.h>
|
#include <esp_audio_dec_default.h>
|
#include <esp_ae_rate_cvt.h>
|
|
#include <algorithm>
|
#include <cstdio>
|
#include <cstdlib>
|
#include <cstring>
|
|
#define TAG "sdcard_mp3"
|
#define MP3_READ_BUFFER_SIZE 512
|
#define MP3_OUTPUT_BUFFER_SIZE 4096
|
#define MP3_PLAYER_STACK_SIZE 8192
|
#define MP3_PLAYER_PRIORITY 2
|
#define MP3_PSRAM_CACHE_MAX (768 * 1024)
|
|
typedef struct {
|
int count;
|
sdcard_mp3_playlist_item_t items[SDCARD_MP3_PLAYLIST_MAX];
|
} mp3_player_task_arg_t;
|
|
static TaskHandle_t mp3_player_task_handle;
|
static StackType_t *mp3_player_stack;
|
static StaticTask_t *mp3_player_tcb;
|
static volatile bool mp3_stop_requested;
|
static volatile bool mp3_pause_requested;
|
static volatile int mp3_repeat_left;
|
static TickType_t s_mp3_audible_started;
|
static SemaphoreHandle_t s_shadowing_listen_closed;
|
|
static int16_t *s_pcm_a = nullptr;
|
static int16_t *s_pcm_b = nullptr;
|
static size_t s_pcm_a_cap = 0;
|
static size_t s_pcm_b_cap = 0;
|
|
static int16_t *ensure_psram_samples(int16_t **buf, size_t *cap, size_t samples)
|
{
|
if (samples == 0) {
|
return *buf;
|
}
|
if (*buf && *cap >= samples) {
|
return *buf;
|
}
|
int16_t *p = static_cast<int16_t *>(
|
heap_caps_realloc(*buf, samples * sizeof(int16_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
|
if (!p) {
|
return nullptr;
|
}
|
*buf = p;
|
*cap = samples;
|
return p;
|
}
|
|
static bool convert_channels(const int16_t *input, size_t frame_count, uint8_t src_channels, uint8_t dst_channels,
|
int16_t *output)
|
{
|
if (!input || !output || frame_count == 0 || src_channels == 0 || dst_channels == 0) {
|
return false;
|
}
|
if (src_channels == dst_channels) {
|
std::memcpy(output, input, frame_count * dst_channels * sizeof(int16_t));
|
return true;
|
}
|
|
for (size_t frame = 0; frame < frame_count; ++frame) {
|
if (dst_channels == 1) {
|
int32_t mixed = 0;
|
for (uint8_t ch = 0; ch < src_channels; ++ch) {
|
mixed += input[frame * src_channels + ch];
|
}
|
output[frame] = static_cast<int16_t>(mixed / src_channels);
|
} else if (src_channels == 1) {
|
for (uint8_t ch = 0; ch < dst_channels; ++ch) {
|
output[frame * dst_channels + ch] = input[frame];
|
}
|
} else {
|
for (uint8_t ch = 0; ch < dst_channels; ++ch) {
|
output[frame * dst_channels + ch] = input[frame * src_channels + std::min<uint8_t>(ch, src_channels - 1)];
|
}
|
}
|
}
|
return true;
|
}
|
|
static size_t stretch_for_speed(const int16_t *input, size_t in_frames, uint8_t channels, float speed,
|
int16_t *output, size_t out_cap_frames)
|
{
|
if (!input || !output || channels == 0 || in_frames == 0) {
|
return 0;
|
}
|
if (speed >= 0.999f && speed <= 1.001f) {
|
size_t n = in_frames * channels;
|
std::memcpy(output, input, n * sizeof(int16_t));
|
return in_frames;
|
}
|
size_t out_frames = static_cast<size_t>(static_cast<double>(in_frames) / static_cast<double>(speed) + 0.5);
|
if (out_frames < 1) {
|
out_frames = 1;
|
}
|
if (out_frames > out_cap_frames) {
|
out_frames = out_cap_frames;
|
}
|
for (size_t i = 0; i < out_frames; ++i) {
|
const double src = static_cast<double>(i) * static_cast<double>(speed);
|
size_t i0 = static_cast<size_t>(src);
|
size_t i1 = i0 + 1;
|
if (i0 >= in_frames) {
|
i0 = in_frames - 1;
|
}
|
if (i1 >= in_frames) {
|
i1 = in_frames - 1;
|
}
|
const float t = static_cast<float>(src - static_cast<double>(i0));
|
for (uint8_t c = 0; c < channels; ++c) {
|
const float a = input[i0 * channels + c];
|
const float b = input[i1 * channels + c];
|
output[i * channels + c] = static_cast<int16_t>(a + (b - a) * t);
|
}
|
}
|
return out_frames;
|
}
|
|
|
static bool wait_if_paused()
|
{
|
while (mp3_pause_requested && !mp3_stop_requested) {
|
vTaskDelay(pdMS_TO_TICKS(20));
|
}
|
return !mp3_stop_requested;
|
}
|
|
static void wait_for_sd_dma(void)
|
{
|
for (int i = 0; i < 20; ++i) {
|
size_t largest = heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
|
if (largest >= 4096) {
|
return;
|
}
|
ESP_LOGW(TAG, "wait SD DMA largest=%u try=%d", (unsigned)largest, i);
|
vTaskDelay(pdMS_TO_TICKS(40));
|
}
|
}
|
|
static uint8_t *load_mp3_to_psram(const char *path, size_t *out_len)
|
{
|
*out_len = 0;
|
wait_for_sd_dma();
|
FILE *fp = fopen(path, "rb");
|
if (!fp) {
|
return nullptr;
|
}
|
size_t cap = 32 * 1024;
|
uint8_t *buf = static_cast<uint8_t *>(
|
heap_caps_malloc(cap, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
|
if (!buf) {
|
fclose(fp);
|
return nullptr;
|
}
|
size_t n = 0;
|
while (n < MP3_PSRAM_CACHE_MAX) {
|
if (n == cap) {
|
size_t ncap = cap * 2;
|
if (ncap > MP3_PSRAM_CACHE_MAX) {
|
ncap = MP3_PSRAM_CACHE_MAX;
|
}
|
uint8_t *grown = static_cast<uint8_t *>(
|
heap_caps_realloc(buf, ncap, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
|
if (!grown) {
|
break;
|
}
|
buf = grown;
|
cap = ncap;
|
}
|
size_t got = fread(buf + n, 1, cap - n, fp);
|
if (got == 0) {
|
break;
|
}
|
n += got;
|
}
|
const bool at_eof = feof(fp) != 0;
|
fclose(fp);
|
if (n == 0 || !at_eof) {
|
ESP_LOGW(TAG, "MP3 PSRAM cache miss n=%u eof=%d: %s", (unsigned)n, at_eof ? 1 : 0, path);
|
heap_caps_free(buf);
|
return nullptr;
|
}
|
*out_len = n;
|
ESP_LOGI(TAG, "cached MP3 in PSRAM %u bytes: %s", (unsigned)n, path);
|
return buf;
|
}
|
|
static bool output_pcm(AudioCodec *codec, esp_ae_rate_cvt_handle_t rate_cvt_handle, const uint8_t *buffer,
|
uint32_t size, uint8_t src_channels, uint32_t src_rate, float speed)
|
{
|
uint8_t dst_channels = codec->output_channels();
|
uint32_t dst_rate = codec->output_sample_rate();
|
size_t frame_count = size / (sizeof(int16_t) * src_channels);
|
if (frame_count == 0) {
|
return true;
|
}
|
|
int16_t *converted = ensure_psram_samples(&s_pcm_a, &s_pcm_a_cap, frame_count * dst_channels);
|
if (!converted) {
|
ESP_LOGE(TAG, "mp3 pcm alloc failed");
|
return false;
|
}
|
if (!convert_channels(reinterpret_cast<const int16_t *>(buffer), frame_count, src_channels, dst_channels, converted)) {
|
return false;
|
}
|
|
const int16_t *play = converted;
|
size_t play_frames = frame_count;
|
if (speed < 0.999f || speed > 1.001f) {
|
size_t out_frames = static_cast<size_t>(static_cast<double>(frame_count) / static_cast<double>(speed) + 0.5);
|
if (out_frames < 1) {
|
out_frames = 1;
|
}
|
int16_t *stretched = ensure_psram_samples(&s_pcm_b, &s_pcm_b_cap, out_frames * dst_channels);
|
if (!stretched) {
|
ESP_LOGE(TAG, "mp3 stretch alloc failed");
|
return false;
|
}
|
play_frames = stretch_for_speed(converted, frame_count, dst_channels, speed, stretched, out_frames);
|
play = stretched;
|
}
|
if (play_frames == 0) {
|
return true;
|
}
|
|
if (src_rate == dst_rate || !rate_cvt_handle) {
|
codec->OutputPcm(play, static_cast<int>(play_frames * dst_channels));
|
if (s_mp3_audible_started == 0) {
|
s_mp3_audible_started = xTaskGetTickCount();
|
}
|
return true;
|
}
|
|
uint32_t max_out_frames = 0;
|
if (esp_ae_rate_cvt_get_max_out_sample_num(rate_cvt_handle, play_frames, &max_out_frames) != ESP_AE_ERR_OK) {
|
ESP_LOGE(TAG, "get resample output size failed");
|
return false;
|
}
|
int16_t **out_slot = (play == s_pcm_b) ? &s_pcm_a : &s_pcm_b;
|
size_t *out_cap = (play == s_pcm_b) ? &s_pcm_a_cap : &s_pcm_b_cap;
|
int16_t *resampled = ensure_psram_samples(out_slot, out_cap, max_out_frames * dst_channels);
|
if (!resampled) {
|
ESP_LOGE(TAG, "mp3 resample alloc failed");
|
return false;
|
}
|
uint32_t actual_out_frames = max_out_frames;
|
if (esp_ae_rate_cvt_process(rate_cvt_handle, reinterpret_cast<esp_ae_sample_t>(const_cast<int16_t *>(play)), play_frames,
|
reinterpret_cast<esp_ae_sample_t>(resampled), &actual_out_frames) != ESP_AE_ERR_OK) {
|
ESP_LOGE(TAG, "resample MP3 PCM failed");
|
return false;
|
}
|
codec->OutputPcm(resampled, static_cast<int>(actual_out_frames * dst_channels));
|
if (s_mp3_audible_started == 0) {
|
s_mp3_audible_started = xTaskGetTickCount();
|
}
|
return true;
|
}
|
|
static void pause_wake_for_sd(void)
|
{
|
Application::GetInstance().Schedule([]() {
|
auto &audio = Application::GetInstance().GetAudioService();
|
audio.EnableVoiceProcessing(false);
|
audio.EnableWakeWordDetection(false);
|
});
|
vTaskDelay(pdMS_TO_TICKS(40));
|
}
|
|
static void wait_shadowing_listen(unsigned duration_ms)
|
{
|
unsigned wait_ms = Board_ShadowingListenWindowMs(duration_ms);
|
// Server 听窗与设备同为 1.2×。多等 200ms，避免下一句课文开头被上一句 ASR 吃掉。
|
wait_ms += 200;
|
ESP_LOGI(TAG, "shadowing listen window %ums after clip %ums", wait_ms, duration_ms);
|
unsigned waited = 0;
|
while (waited < wait_ms && !mp3_stop_requested) {
|
unsigned slice = wait_ms - waited;
|
if (slice > 50) {
|
slice = 50;
|
}
|
vTaskDelay(pdMS_TO_TICKS(slice));
|
waited += slice;
|
}
|
}
|
|
static void ensure_shadowing_listen_sem(void)
|
{
|
if (s_shadowing_listen_closed == nullptr) {
|
s_shadowing_listen_closed = xSemaphoreCreateBinary();
|
}
|
}
|
|
static void wait_shadowing_mic_off(void)
|
{
|
ensure_shadowing_listen_sem();
|
xSemaphoreTake(s_shadowing_listen_closed, 0);
|
Application::GetInstance().Schedule([]() {
|
Application::GetInstance().CloseShadowingListenWindow();
|
if (s_shadowing_listen_closed != nullptr) {
|
xSemaphoreGive(s_shadowing_listen_closed);
|
}
|
});
|
// 必须等 AFE 真正关掉再解码下一句。只 delay 80ms 会和录音重叠，内部 SRAM 会被打满。
|
if (xSemaphoreTake(s_shadowing_listen_closed, pdMS_TO_TICKS(2500)) != pdTRUE) {
|
ESP_LOGW(TAG, "shadowing wait mic off timeout, force AFE stop");
|
Application::GetInstance().GetAudioService().EnableVoiceProcessing(false);
|
}
|
}
|
|
static void mp3_player_task(void *arg)
|
{
|
mp3_player_task_handle = xTaskGetCurrentTaskHandle();
|
mp3_player_task_arg_t *task_arg = static_cast<mp3_player_task_arg_t *>(arg);
|
sdcard_mp3_playlist_item_t items[SDCARD_MP3_PLAYLIST_MAX];
|
int count = task_arg->count;
|
if (count < 0) {
|
count = 0;
|
}
|
if (count > SDCARD_MP3_PLAYLIST_MAX) {
|
count = SDCARD_MP3_PLAYLIST_MAX;
|
}
|
if (count > 0) {
|
memcpy(items, task_arg->items, sizeof(items[0]) * static_cast<size_t>(count));
|
}
|
bool power_off_after = count > 0 ? items[count - 1].power_off_after : false;
|
heap_caps_free(task_arg);
|
|
auto codec = Board::GetInstance().GetAudioCodec();
|
if (!codec || count < 1) {
|
ESP_LOGE(TAG, "audio codec unavailable or empty playlist");
|
mp3_player_task_handle = nullptr;
|
mp3_stop_requested = false;
|
mp3_repeat_left = 0;
|
Board_OnSkillPlaybackFinished(true, false, 0);
|
vTaskDelete(nullptr);
|
return;
|
}
|
|
esp_audio_dec_register_default();
|
esp_audio_simple_dec_register_default();
|
uint8_t *in_buf = static_cast<uint8_t *>(
|
heap_caps_malloc(MP3_READ_BUFFER_SIZE, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
|
uint8_t *out_buf = static_cast<uint8_t *>(
|
heap_caps_malloc(MP3_OUTPUT_BUFFER_SIZE, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
|
uint32_t out_buf_size = MP3_OUTPUT_BUFFER_SIZE;
|
bool output_enabled_before = codec->output_enabled();
|
TickType_t play_started = xTaskGetTickCount();
|
s_mp3_audible_started = 0;
|
const bool shadowing = Board_IsShadowingTask();
|
char path[SDCARD_PATH_MAX_LEN] = {0};
|
|
if (!in_buf || !out_buf) {
|
ESP_LOGE(TAG, "no memory for MP3 playback");
|
}
|
|
for (int item_i = 0; in_buf && out_buf && item_i < count && !mp3_stop_requested; ++item_i) {
|
strlcpy(path, items[item_i].path, sizeof(path));
|
float speed = SDCard_Clamp_MP3_Speed(items[item_i].speed);
|
int repeat = items[item_i].repeat < 1 ? 1 : items[item_i].repeat;
|
if (item_i > 0) {
|
pause_wake_for_sd();
|
}
|
|
size_t file_len = 0;
|
uint8_t *file_buf = load_mp3_to_psram(path, &file_len);
|
FILE *fp = nullptr;
|
if (!file_buf) {
|
wait_for_sd_dma();
|
fp = fopen(path, "rb");
|
}
|
if (!file_buf && !fp) {
|
ESP_LOGE(TAG, "open MP3 failed: %s", path);
|
continue;
|
}
|
|
if (!mp3_pause_requested) {
|
Application::GetInstance().Schedule([]() {
|
Application::GetInstance().ApplyMp3CommandOnlyMic();
|
});
|
}
|
|
esp_audio_simple_dec_handle_t decoder = nullptr;
|
esp_audio_simple_dec_cfg_t dec_cfg = {
|
.dec_type = ESP_AUDIO_SIMPLE_DEC_TYPE_MP3,
|
.dec_cfg = nullptr,
|
.cfg_size = 0,
|
.use_frame_dec = false,
|
};
|
|
esp_audio_err_t ret = esp_audio_simple_dec_open(&dec_cfg, &decoder);
|
if (ret != ESP_AUDIO_ERR_OK) {
|
ESP_LOGE(TAG, "open MP3 decoder failed: %d", ret);
|
if (fp) {
|
fclose(fp);
|
fp = nullptr;
|
}
|
if (file_buf) {
|
heap_caps_free(file_buf);
|
file_buf = nullptr;
|
}
|
continue;
|
}
|
|
bool audio_info_checked = false;
|
uint32_t mp3_sample_rate = 0;
|
uint8_t mp3_channels = 0;
|
esp_ae_rate_cvt_handle_t rate_cvt_handle = nullptr;
|
|
ESP_LOGI(TAG, "play MP3: %s, speed: %.2fx, repeat: %d, item=%d/%d",
|
path, speed, repeat, item_i + 1, count);
|
|
if (wait_if_paused()) {
|
codec->EnableOutput(true);
|
}
|
|
for (int pass = 0; pass < repeat && ret == ESP_AUDIO_ERR_OK && !mp3_stop_requested; ++pass) {
|
mp3_repeat_left = repeat - pass;
|
s_mp3_audible_started = 0;
|
size_t mem_off = 0;
|
if (pass > 0) {
|
if (!file_buf) {
|
if (fp) {
|
fclose(fp);
|
fp = nullptr;
|
}
|
vTaskDelay(pdMS_TO_TICKS(30));
|
wait_for_sd_dma();
|
fp = fopen(path, "rb");
|
if (!fp) {
|
ESP_LOGE(TAG, "reopen MP3 failed: %s", path);
|
break;
|
}
|
}
|
if (decoder) {
|
esp_audio_simple_dec_close(decoder);
|
decoder = nullptr;
|
}
|
ret = esp_audio_simple_dec_open(&dec_cfg, &decoder);
|
if (ret != ESP_AUDIO_ERR_OK || !decoder) {
|
ESP_LOGE(TAG, "reopen MP3 decoder failed: %d", ret);
|
break;
|
}
|
}
|
|
while (ret == ESP_AUDIO_ERR_OK && !mp3_stop_requested) {
|
if (!wait_if_paused()) {
|
break;
|
}
|
|
int read_size = 0;
|
if (file_buf) {
|
if (mem_off >= file_len) {
|
break;
|
}
|
size_t chunk = file_len - mem_off;
|
if (chunk > MP3_READ_BUFFER_SIZE) {
|
chunk = MP3_READ_BUFFER_SIZE;
|
}
|
std::memcpy(in_buf, file_buf + mem_off, chunk);
|
mem_off += chunk;
|
read_size = static_cast<int>(chunk);
|
} else {
|
read_size = fread(in_buf, 1, MP3_READ_BUFFER_SIZE, fp);
|
}
|
if (read_size <= 0) {
|
break;
|
}
|
|
esp_audio_simple_dec_raw_t raw = {
|
.buffer = in_buf,
|
.len = static_cast<uint32_t>(read_size),
|
.eos = file_buf ? (mem_off >= file_len) : (read_size < MP3_READ_BUFFER_SIZE),
|
.consumed = 0,
|
.frame_recover = ESP_AUDIO_SIMPLE_DEC_RECOVERY_NONE,
|
};
|
|
while (raw.len > 0 && !mp3_stop_requested) {
|
if (!wait_if_paused()) {
|
break;
|
}
|
|
esp_audio_simple_dec_out_t out_frame = {
|
.buffer = out_buf,
|
.len = out_buf_size,
|
.needed_size = 0,
|
.decoded_size = 0,
|
};
|
|
ret = esp_audio_simple_dec_process(decoder, &raw, &out_frame);
|
if (ret == ESP_AUDIO_ERR_BUFF_NOT_ENOUGH) {
|
uint8_t *new_buf = static_cast<uint8_t *>(
|
heap_caps_realloc(out_buf, out_frame.needed_size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
|
if (!new_buf) {
|
ESP_LOGE(TAG, "resize MP3 output buffer failed");
|
ret = ESP_AUDIO_ERR_MEM_LACK;
|
break;
|
}
|
out_buf = new_buf;
|
out_buf_size = out_frame.needed_size;
|
continue;
|
}
|
|
if (ret != ESP_AUDIO_ERR_OK) {
|
ESP_LOGE(TAG, "decode MP3 failed: %d", ret);
|
break;
|
}
|
|
if (out_frame.decoded_size > 0) {
|
if (!audio_info_checked) {
|
esp_audio_simple_dec_info_t info = {};
|
if (esp_audio_simple_dec_get_info(decoder, &info) == ESP_AUDIO_ERR_OK) {
|
ESP_LOGI(TAG, "MP3 info: %lu Hz, %u bits, %u ch", info.sample_rate, info.bits_per_sample, info.channel);
|
if (info.bits_per_sample != 16 || info.channel == 0 || codec->output_channels() == 0) {
|
ESP_LOGE(TAG, "MP3 format unsupported: %lu Hz, %u bits, %u ch", info.sample_rate, info.bits_per_sample, info.channel);
|
ret = ESP_AUDIO_ERR_NOT_SUPPORT;
|
break;
|
}
|
mp3_sample_rate = info.sample_rate;
|
mp3_channels = info.channel;
|
if (mp3_sample_rate != static_cast<uint32_t>(codec->output_sample_rate())) {
|
esp_ae_rate_cvt_cfg_t rate_cvt_cfg = {
|
.src_rate = mp3_sample_rate,
|
.dest_rate = static_cast<uint32_t>(codec->output_sample_rate()),
|
.channel = static_cast<uint8_t>(codec->output_channels()),
|
.bits_per_sample = 16,
|
.complexity = 2,
|
.perf_type = ESP_AE_RATE_CVT_PERF_TYPE_SPEED,
|
};
|
if (esp_ae_rate_cvt_open(&rate_cvt_cfg, &rate_cvt_handle) != ESP_AE_ERR_OK || !rate_cvt_handle) {
|
ESP_LOGE(TAG, "open MP3 resampler failed");
|
ret = ESP_AUDIO_ERR_NOT_SUPPORT;
|
break;
|
}
|
}
|
}
|
audio_info_checked = true;
|
}
|
|
if (!output_pcm(codec, rate_cvt_handle, out_frame.buffer, out_frame.decoded_size, mp3_channels, mp3_sample_rate, speed)) {
|
ret = ESP_AUDIO_ERR_FAIL;
|
break;
|
}
|
taskYIELD();
|
}
|
|
if (raw.consumed == 0) {
|
break;
|
}
|
raw.len -= raw.consumed;
|
raw.buffer += raw.consumed;
|
raw.consumed = 0;
|
}
|
|
if (raw.eos || ret != ESP_AUDIO_ERR_OK) {
|
break;
|
}
|
}
|
|
if (shadowing && !mp3_stop_requested && ret == ESP_AUDIO_ERR_OK) {
|
unsigned duration_ms = s_mp3_audible_started
|
? pdTICKS_TO_MS(xTaskGetTickCount() - s_mp3_audible_started)
|
: 0;
|
Board_OnShadowingClipFinished(duration_ms);
|
wait_shadowing_listen(duration_ms);
|
wait_shadowing_mic_off();
|
s_mp3_audible_started = 0;
|
}
|
}
|
|
if (rate_cvt_handle) {
|
esp_ae_rate_cvt_close(rate_cvt_handle);
|
rate_cvt_handle = nullptr;
|
}
|
if (decoder) {
|
esp_audio_simple_dec_close(decoder);
|
decoder = nullptr;
|
}
|
if (fp) {
|
fclose(fp);
|
fp = nullptr;
|
}
|
if (file_buf) {
|
heap_caps_free(file_buf);
|
file_buf = nullptr;
|
}
|
ESP_LOGI(TAG, "MP3 item %s: %s", mp3_stop_requested ? "stopped" : "finished", path);
|
}
|
|
if (!output_enabled_before) {
|
codec->EnableOutput(false);
|
}
|
if (in_buf) {
|
heap_caps_free(in_buf);
|
}
|
if (out_buf) {
|
heap_caps_free(out_buf);
|
}
|
esp_audio_simple_dec_unregister_default();
|
esp_audio_dec_unregister_default();
|
|
ESP_LOGI(TAG, "MP3 playlist %s items=%d", mp3_stop_requested ? "stopped" : "finished", count);
|
bool stopped = mp3_stop_requested;
|
bool should_power_off = power_off_after && !stopped;
|
unsigned duration_ms = s_mp3_audible_started
|
? pdTICKS_TO_MS(xTaskGetTickCount() - s_mp3_audible_started)
|
: pdTICKS_TO_MS(xTaskGetTickCount() - play_started);
|
mp3_player_task_handle = nullptr;
|
mp3_stop_requested = false;
|
mp3_pause_requested = false;
|
mp3_repeat_left = 0;
|
if (should_power_off) {
|
Application::GetInstance().RequestPowerOffStandby();
|
}
|
if (shadowing && !stopped) {
|
Board_OnShadowingPlaylistFinished();
|
} else {
|
Board_OnSkillPlaybackFinished(stopped, power_off_after, duration_ms);
|
}
|
vTaskDelete(nullptr);
|
}
|
|
extern "C" esp_err_t SDCard_Play_MP3_File(const char *path)
|
{
|
return SDCard_Play_MP3_File_With_Speed_Repeat(path, 1.0f, 1, false);
|
}
|
|
extern "C" esp_err_t SDCard_Play_MP3_File_With_Speed(const char *path, float speed)
|
{
|
return SDCard_Play_MP3_File_With_Speed_Repeat(path, speed, 1, false);
|
}
|
|
extern "C" esp_err_t SDCard_Play_MP3_File_With_Speed_Repeat(const char *path, float speed, int repeat, bool power_off_after)
|
{
|
if (!path || path[0] == '\0') {
|
return ESP_ERR_INVALID_ARG;
|
}
|
sdcard_mp3_playlist_item_t item = {};
|
strlcpy(item.path, path, sizeof(item.path));
|
item.speed = speed;
|
item.repeat = repeat;
|
item.power_off_after = power_off_after;
|
return SDCard_Play_MP3_File_Playlist(&item, 1);
|
}
|
|
extern "C" esp_err_t SDCard_Play_MP3_File_Playlist(const sdcard_mp3_playlist_item_t *items, int count)
|
{
|
if (!items || count < 1) {
|
return ESP_ERR_INVALID_ARG;
|
}
|
if (count > SDCARD_MP3_PLAYLIST_MAX) {
|
count = SDCARD_MP3_PLAYLIST_MAX;
|
}
|
|
bool start_paused = mp3_pause_requested;
|
if (mp3_player_task_handle) {
|
mp3_stop_requested = true;
|
mp3_pause_requested = false;
|
while (mp3_player_task_handle) {
|
vTaskDelay(pdMS_TO_TICKS(20));
|
}
|
}
|
|
mp3_player_task_arg_t *arg = static_cast<mp3_player_task_arg_t *>(
|
heap_caps_calloc(1, sizeof(mp3_player_task_arg_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
|
if (!arg) {
|
return ESP_ERR_NO_MEM;
|
}
|
arg->count = count;
|
for (int i = 0; i < count; ++i) {
|
strlcpy(arg->items[i].path, items[i].path, sizeof(arg->items[i].path));
|
arg->items[i].speed = SDCard_Clamp_MP3_Speed(items[i].speed);
|
arg->items[i].repeat = items[i].repeat < 1 ? 1 : items[i].repeat;
|
arg->items[i].power_off_after = items[i].power_off_after;
|
}
|
mp3_stop_requested = false;
|
mp3_pause_requested = start_paused;
|
mp3_repeat_left = arg->items[0].repeat;
|
|
if (mp3_player_stack == nullptr) {
|
mp3_player_stack = static_cast<StackType_t *>(
|
heap_caps_malloc(MP3_PLAYER_STACK_SIZE, MALLOC_CAP_SPIRAM));
|
}
|
if (mp3_player_tcb == nullptr) {
|
mp3_player_tcb = static_cast<StaticTask_t *>(
|
heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL));
|
}
|
if (mp3_player_stack == nullptr || mp3_player_tcb == nullptr) {
|
ESP_LOGE(TAG, "mp3 task alloc failed internal=%u psram=%u",
|
(unsigned)heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
|
(unsigned)heap_caps_get_free_size(MALLOC_CAP_SPIRAM));
|
heap_caps_free(arg);
|
mp3_repeat_left = 0;
|
return ESP_ERR_NO_MEM;
|
}
|
|
mp3_player_task_handle = xTaskCreateStatic(
|
mp3_player_task, "mp3_player", MP3_PLAYER_STACK_SIZE, arg,
|
MP3_PLAYER_PRIORITY, mp3_player_stack, mp3_player_tcb);
|
if (mp3_player_task_handle == nullptr) {
|
ESP_LOGE(TAG, "mp3 xTaskCreateStatic failed internal=%u",
|
(unsigned)heap_caps_get_free_size(MALLOC_CAP_INTERNAL));
|
heap_caps_free(arg);
|
mp3_repeat_left = 0;
|
return ESP_FAIL;
|
}
|
|
return ESP_OK;
|
}
|
|
extern "C" void SDCard_Stop_Play(void)
|
{
|
mp3_pause_requested = false;
|
if (!mp3_player_task_handle) {
|
return;
|
}
|
|
mp3_stop_requested = true;
|
}
|
|
extern "C" void SDCard_Pause_Play(void)
|
{
|
mp3_pause_requested = true;
|
}
|
|
extern "C" void SDCard_Resume_Play(void)
|
{
|
mp3_pause_requested = false;
|
Application::GetInstance().Schedule([]() {
|
Application::GetInstance().ApplyMp3CommandOnlyMic();
|
});
|
}
|
|
extern "C" bool SDCard_Is_Playing(void)
|
{
|
return mp3_player_task_handle != nullptr;
|
}
|
|
extern "C" bool SDCard_Is_Paused(void)
|
{
|
return mp3_player_task_handle != nullptr && mp3_pause_requested;
|
}
|
|
extern "C" int SDCard_Get_Repeat_Left(void)
|
{
|
return mp3_repeat_left;
|
}
|
