579 lines
16 KiB
C++
579 lines
16 KiB
C++
/**
|
||
****************************************************************************************************
|
||
* @file flac_dec.cpp
|
||
* @author HiFi Player Project
|
||
* @version V1.5
|
||
* @date 2026-01-01
|
||
* @brief FLAC 解码器的 C++ 实现（对外暴露纯 C 接口，见 flac_dec.h）
|
||
*
|
||
* 数据流：
|
||
* FATFS 文件 ──f_read──▶ 8KB 码流缓冲 ──decode()──▶ 原生位深交错 PCM
|
||
* │
|
||
* 单声道复制 / 多声道取前两声道
|
||
* ▼
|
||
* 立体声 + 原生位深（左对齐）→ I2S
|
||
*
|
||
* 位的处理：
|
||
* 库的 uint8_t 输出重载是“原生字节打包 + 左对齐”：
|
||
* 16bit → 2 字节、24bit → 3 字节、32bit → 4 字节，
|
||
* 20bit 这类非整字节位深则占 3 字节并填满其高 20 位。
|
||
* 正好等价于 I2S 的 16/24/32bit 数据格式，所以这里不做任何降位，
|
||
* 上层按 out_bytes 配置 I2S 位宽即可获得无损通路。
|
||
*
|
||
* 码流缓冲策略：未消费数据前移 + 追加读取，保证 NEED_MORE_DATA 时不丢数据，
|
||
* 并带“无进展”保护，坏文件不会死循环。
|
||
****************************************************************************************************
|
||
*/
|
||
|
||
#include "flac_dec.h"
|
||
|
||
#include <cstdlib>
|
||
#include <cstring>
|
||
#include <new>
|
||
|
||
#include "esp_heap_caps.h"
|
||
#include "esp_log.h"
|
||
|
||
#include "micro_flac/flac_decoder.h"
|
||
|
||
#include "ff.h"
|
||
|
||
#define TAG "flac_dec"
|
||
|
||
#define IN_BUF_SIZE (8 * 1024) /* 码流缓冲（压缩数据） */
|
||
#define MAX_STALL 8 /* 连续无进展的容忍次数 */
|
||
|
||
struct flac_dec {
|
||
FIL fp; /* FATFS 文件对象 */
|
||
bool fp_open;
|
||
|
||
micro_flac::FLACDecoder *decoder;
|
||
|
||
uint8_t *in_buf; /* 压缩码流缓冲 */
|
||
size_t in_len; /* 缓冲内有效字节数 */
|
||
size_t in_pos; /* 已消费位置 */
|
||
bool in_eof; /* 文件已读完 */
|
||
|
||
uint8_t *pcm; /* 解码输出（源声道数 × 原生位深，交错） */
|
||
size_t pcm_capacity; /* 缓冲字节数 */
|
||
size_t pcm_bytes; /* 本帧有效字节数 */
|
||
size_t pcm_pos; /* 已消费字节位置 */
|
||
|
||
uint8_t bps; /* 源每采样字节数 */
|
||
uint8_t out_bytes; /* 输出每采样字节数（2/3/4） */
|
||
|
||
flac_info_t info;
|
||
bool header_ready;
|
||
bool stream_end;
|
||
bool failed;
|
||
};
|
||
|
||
/* ================================================================================================
|
||
* 内部工具
|
||
* ============================================================================================== */
|
||
|
||
/**
|
||
* @brief 按 STREAMINFO 的块大小分配解码输出缓冲（字节数）
|
||
* @retval true 成功
|
||
*/
|
||
static bool ensure_pcm_buffer(flac_dec_t *d, size_t bytes)
|
||
{
|
||
if (bytes <= d->pcm_capacity)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
/* 优先放 PSRAM，失败再退回内部 RAM */
|
||
void *p = heap_caps_malloc(bytes, MALLOC_CAP_SPIRAM);
|
||
|
||
if (p == NULL)
|
||
{
|
||
ESP_LOGW(TAG, "psram alloc failed (%u bytes), try internal", (unsigned)bytes);
|
||
p = malloc(bytes);
|
||
}
|
||
|
||
if (p == NULL)
|
||
{
|
||
ESP_LOGE(TAG, "no memory for pcm buffer (%u bytes)", (unsigned)bytes);
|
||
return false;
|
||
}
|
||
|
||
free(d->pcm); /* heap_caps_malloc 的指针可以用 free 释放 */
|
||
d->pcm = (uint8_t *)p;
|
||
d->pcm_capacity = bytes;
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 把未消费的码流前移，并从文件追加新数据
|
||
* @retval true 操作成功（不代表一定有新数据；看 in_len 是否增长）
|
||
* false 读文件失败
|
||
*/
|
||
static bool feed_more(flac_dec_t *d)
|
||
{
|
||
size_t remain = d->in_len - d->in_pos;
|
||
|
||
if ((d->in_pos > 0) && (remain > 0))
|
||
{
|
||
memmove(d->in_buf, d->in_buf + d->in_pos, remain);
|
||
}
|
||
|
||
d->in_len = remain;
|
||
d->in_pos = 0;
|
||
|
||
if (d->in_eof || (d->in_len >= IN_BUF_SIZE))
|
||
{
|
||
return true; /* 文件读完或缓冲已满，只能靠现有数据 */
|
||
}
|
||
|
||
UINT br = 0;
|
||
FRESULT fr = f_read(&d->fp, d->in_buf + d->in_len, (UINT)(IN_BUF_SIZE - d->in_len), &br);
|
||
|
||
if (fr != FR_OK)
|
||
{
|
||
ESP_LOGE(TAG, "f_read failed (%d)", (int)fr);
|
||
return false;
|
||
}
|
||
|
||
d->in_len += br;
|
||
|
||
if (br == 0)
|
||
{
|
||
d->in_eof = true;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/** @brief 是否还有可交给解码器的数据 */
|
||
static inline bool has_input(const flac_dec_t *d)
|
||
{
|
||
return d->in_pos < d->in_len;
|
||
}
|
||
|
||
/**
|
||
* @brief 按源位深推导输出每采样字节数
|
||
* @note 1 字节（8bit 及以下）统一扩展成 2 字节（左对齐），
|
||
* 其余直接沿用源字节数（2/3/4），这样 I2S 用 16/24/32bit 都能直接接收
|
||
*/
|
||
static inline uint8_t pick_out_bytes(uint8_t bps)
|
||
{
|
||
if (bps < 2)
|
||
{
|
||
return 2;
|
||
}
|
||
|
||
if (bps > 4)
|
||
{
|
||
return 4;
|
||
}
|
||
|
||
return bps;
|
||
}
|
||
|
||
/**
|
||
* @brief 写一个输出采样（把源采样按需要补齐/复制）
|
||
* @param dst 输出位置（out_bytes 字节，小端，左对齐）
|
||
* @param src 源采样起点（bps 字节，小端，左对齐）
|
||
*/
|
||
static inline void write_sample(uint8_t *dst, const uint8_t *src, uint8_t bps, uint8_t out_bytes)
|
||
{
|
||
if (bps == out_bytes)
|
||
{
|
||
memcpy(dst, src, out_bytes);
|
||
return;
|
||
}
|
||
|
||
if (bps == 1)
|
||
{
|
||
/* 8bit 及以下：左对齐扩成 16bit（低字节补 0，高字节就是原样本） */
|
||
dst[0] = 0;
|
||
dst[1] = src[0];
|
||
|
||
for (uint8_t i = 2; i < out_bytes; i++)
|
||
{
|
||
dst[i] = (src[0] & 0x80) ? 0xFF : 0x00; /* 符号扩展到更高的字节 */
|
||
}
|
||
return;
|
||
}
|
||
|
||
/* 理论上不会走到这里；保守处理为左对齐拷贝 */
|
||
uint8_t n = (bps < out_bytes) ? bps : out_bytes;
|
||
|
||
memset(dst, 0, out_bytes);
|
||
memcpy(dst + (out_bytes - n), src, n);
|
||
}
|
||
|
||
/**
|
||
* @brief 把解码结果（源声道数）规整成 2 声道，写入调用者缓冲
|
||
* @param frames 本次要输出的帧数
|
||
* @retval 无
|
||
*/
|
||
static void expand_frames(flac_dec_t *d, const uint8_t *src, uint8_t *dst, size_t frames)
|
||
{
|
||
const size_t ch = d->info.channels;
|
||
const size_t bps = d->bps;
|
||
const size_t ob = d->out_bytes;
|
||
|
||
if ((ch == 2) && (bps == ob))
|
||
{
|
||
memcpy(dst, src, frames * 2 * ob); /* 最常见路径：立体声原生位深 */
|
||
return;
|
||
}
|
||
|
||
for (size_t i = 0; i < frames; i++)
|
||
{
|
||
const uint8_t *s = src + i * ch * bps;
|
||
uint8_t *o = dst + i * 2 * ob;
|
||
|
||
write_sample(o, s, (uint8_t)bps, (uint8_t)ob); /* 左声道 = 声道 0 */
|
||
|
||
if (ch >= 2)
|
||
{
|
||
write_sample(o + ob, s + bps, (uint8_t)bps, (uint8_t)ob); /* 右声道 = 声道 1 */
|
||
}
|
||
else
|
||
{
|
||
memcpy(o + ob, o, ob); /* 单声道复制 */
|
||
}
|
||
}
|
||
}
|
||
|
||
/* ================================================================================================
|
||
* 对外接口
|
||
* ============================================================================================== */
|
||
|
||
flac_dec_t *flac_dec_open(const char *path)
|
||
{
|
||
if (path == NULL)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
flac_dec_t *d = new (std::nothrow) flac_dec();
|
||
|
||
if (d == NULL)
|
||
{
|
||
ESP_LOGE(TAG, "no memory for decoder");
|
||
return NULL;
|
||
}
|
||
|
||
memset(d, 0, sizeof(*d));
|
||
|
||
if (f_open(&d->fp, path, FA_READ) != FR_OK)
|
||
{
|
||
ESP_LOGE(TAG, "open %s failed", path);
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
d->fp_open = true;
|
||
|
||
d->decoder = new (std::nothrow) micro_flac::FLACDecoder();
|
||
|
||
if (d->decoder == NULL)
|
||
{
|
||
ESP_LOGE(TAG, "no memory for FLACDecoder");
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
|
||
d->in_buf = (uint8_t *)malloc(IN_BUF_SIZE);
|
||
|
||
if (d->in_buf == NULL)
|
||
{
|
||
ESP_LOGE(TAG, "no memory for input buffer");
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
|
||
/* ---------------- 解析头部（STREAMINFO） ---------------- */
|
||
int stall = 0;
|
||
|
||
while (!d->header_ready)
|
||
{
|
||
if (!has_input(d) && !feed_more(d))
|
||
{
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
|
||
if (!has_input(d))
|
||
{
|
||
ESP_LOGE(TAG, "empty or truncated stream");
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
|
||
size_t consumed = 0;
|
||
size_t samples = 0;
|
||
|
||
/* 头部解析阶段不需要输出缓冲 */
|
||
micro_flac::FLACDecoderResult res =
|
||
d->decoder->decode(d->in_buf + d->in_pos, d->in_len - d->in_pos,
|
||
(uint8_t *)NULL, 0, consumed, samples);
|
||
|
||
d->in_pos += consumed;
|
||
|
||
if (res == micro_flac::FLAC_DECODER_HEADER_READY)
|
||
{
|
||
const micro_flac::FLACStreamInfo &si = d->decoder->get_stream_info();
|
||
|
||
if (!si.is_valid() || (si.num_channels() < 1) || (si.num_channels() > 8) ||
|
||
(si.max_block_size() == 0) || (si.bytes_per_sample() == 0) ||
|
||
(si.bytes_per_sample() > 4))
|
||
{
|
||
ESP_LOGE(TAG, "invalid stream info");
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
|
||
d->info.sample_rate = si.sample_rate();
|
||
d->info.channels = (uint8_t)si.num_channels();
|
||
d->info.bits = (uint8_t)si.bits_per_sample();
|
||
d->info.max_block_size = si.max_block_size();
|
||
d->info.total_samples = si.total_samples_per_channel();
|
||
|
||
d->bps = (uint8_t)si.bytes_per_sample();
|
||
d->out_bytes = pick_out_bytes(d->bps);
|
||
d->info.out_bytes = d->out_bytes;
|
||
|
||
/* 解码输出缓冲按「最大块 × 声道数 × 源字节数」分配 */
|
||
if (!ensure_pcm_buffer(d, (size_t)d->info.max_block_size *
|
||
d->info.channels * d->bps))
|
||
{
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
|
||
d->header_ready = true;
|
||
stall = 0;
|
||
}
|
||
else if (res == micro_flac::FLAC_DECODER_NEED_MORE_DATA)
|
||
{
|
||
size_t before = d->in_len - d->in_pos; /* feed 之前的待解析字节数 */
|
||
|
||
if (!feed_more(d))
|
||
{
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
|
||
/* 没有新数据可加（文件读完 / 缓冲已满）→ 头部不完整 */
|
||
if ((d->in_len <= before) && d->in_eof)
|
||
{
|
||
ESP_LOGE(TAG, "truncated header");
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
|
||
if (consumed == 0)
|
||
{
|
||
if (++stall > MAX_STALL)
|
||
{
|
||
ESP_LOGE(TAG, "header parse stalled");
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
stall = 0;
|
||
}
|
||
}
|
||
else if (res == micro_flac::FLAC_DECODER_END_OF_STREAM)
|
||
{
|
||
ESP_LOGE(TAG, "no audio in stream");
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
else
|
||
{
|
||
ESP_LOGE(TAG, "header parse failed (%d)", (int)res);
|
||
flac_dec_close(d);
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
ESP_LOGI(TAG, "%s: %u Hz, %u bit (out %u byte, %u bit slot), %u ch, block=%u",
|
||
path, (unsigned)d->info.sample_rate, d->info.bits,
|
||
d->out_bytes, (unsigned)d->out_bytes * 8,
|
||
d->info.channels, (unsigned)d->info.max_block_size);
|
||
|
||
return d;
|
||
}
|
||
|
||
int flac_dec_get_info(flac_dec_t *dec, flac_info_t *info)
|
||
{
|
||
if ((dec == NULL) || (info == NULL) || !dec->header_ready)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
*info = dec->info;
|
||
return 0;
|
||
}
|
||
|
||
int flac_dec_read(flac_dec_t *d, void *out, int max_frames)
|
||
{
|
||
if ((d == NULL) || (out == NULL) || (max_frames <= 0))
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if (d->failed || !d->header_ready)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
const size_t ch = d->info.channels;
|
||
const size_t bps = d->bps;
|
||
const size_t ob = d->out_bytes;
|
||
const size_t src_frame = ch * bps; /* 源每帧字节数 */
|
||
|
||
uint8_t *dst_base = (uint8_t *)out;
|
||
int written = 0;
|
||
int stall = 0;
|
||
|
||
while (written < max_frames)
|
||
{
|
||
/* ---- 1. 先把已解码但没送出的帧搬走 ---- */
|
||
if (d->pcm_pos < d->pcm_bytes)
|
||
{
|
||
size_t avail = (d->pcm_bytes - d->pcm_pos) / src_frame; /* 剩余帧数 */
|
||
size_t need = (size_t)(max_frames - written);
|
||
size_t n = (avail < need) ? avail : need;
|
||
|
||
if (n == 0)
|
||
{
|
||
d->pcm_pos = d->pcm_bytes; /* 丢弃不足一帧的残料 */
|
||
continue;
|
||
}
|
||
|
||
expand_frames(d, d->pcm + d->pcm_pos, dst_base + (size_t)written * 2 * ob, n);
|
||
|
||
d->pcm_pos += n * src_frame;
|
||
written += (int)n;
|
||
continue;
|
||
}
|
||
|
||
if (d->stream_end)
|
||
{
|
||
break;
|
||
}
|
||
|
||
/* ---- 2. 码流用尽则补充 ---- */
|
||
if (!has_input(d) && !feed_more(d))
|
||
{
|
||
d->failed = true;
|
||
return (written > 0) ? written : -1;
|
||
}
|
||
|
||
if (!has_input(d))
|
||
{
|
||
d->stream_end = true; /* 文件读完且没有待解码数据 */
|
||
break;
|
||
}
|
||
|
||
/* ---- 3. 解一帧 ---- */
|
||
size_t consumed = 0;
|
||
size_t samples = 0;
|
||
|
||
micro_flac::FLACDecoderResult res =
|
||
d->decoder->decode(d->in_buf + d->in_pos, d->in_len - d->in_pos,
|
||
d->pcm, d->pcm_capacity, consumed, samples);
|
||
|
||
d->in_pos += consumed;
|
||
|
||
if (res == micro_flac::FLAC_DECODER_SUCCESS)
|
||
{
|
||
size_t bytes = samples * bps;
|
||
|
||
if (bytes > d->pcm_capacity)
|
||
{
|
||
ESP_LOGE(TAG, "decoder overflow (%u > %u)",
|
||
(unsigned)bytes, (unsigned)d->pcm_capacity);
|
||
d->failed = true;
|
||
return (written > 0) ? written : -1;
|
||
}
|
||
|
||
d->pcm_bytes = bytes;
|
||
d->pcm_pos = 0;
|
||
|
||
/* 无进展保护：空帧且未消费数据 */
|
||
if ((bytes == 0) && (consumed == 0))
|
||
{
|
||
if (++stall > MAX_STALL)
|
||
{
|
||
ESP_LOGW(TAG, "decode stalled, stop stream");
|
||
d->stream_end = true;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
stall = 0;
|
||
}
|
||
}
|
||
else if (res == micro_flac::FLAC_DECODER_HEADER_READY)
|
||
{
|
||
/* 正常不会二次出现；出现时忽略即可 */
|
||
continue;
|
||
}
|
||
else if (res == micro_flac::FLAC_DECODER_NEED_MORE_DATA)
|
||
{
|
||
size_t before = d->in_len - d->in_pos; /* feed 之前的待解码字节数 */
|
||
|
||
if (!feed_more(d))
|
||
{
|
||
d->failed = true;
|
||
return (written > 0) ? written : -1;
|
||
}
|
||
|
||
/* 文件结束且没有新数据可加 → 剩余数据不足以解出完整帧，正常收尾 */
|
||
if ((d->in_len <= before) && d->in_eof)
|
||
{
|
||
d->stream_end = true;
|
||
break;
|
||
}
|
||
}
|
||
else if (res == micro_flac::FLAC_DECODER_END_OF_STREAM)
|
||
{
|
||
d->stream_end = true;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
ESP_LOGE(TAG, "decode error (%d)", (int)res);
|
||
d->failed = true;
|
||
return (written > 0) ? written : -1;
|
||
}
|
||
}
|
||
|
||
return written;
|
||
}
|
||
|
||
void flac_dec_close(flac_dec_t *d)
|
||
{
|
||
if (d == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (d->fp_open)
|
||
{
|
||
f_close(&d->fp);
|
||
d->fp_open = false;
|
||
}
|
||
|
||
delete d->decoder;
|
||
d->decoder = NULL;
|
||
|
||
free(d->in_buf);
|
||
free(d->pcm);
|
||
d->in_buf = NULL;
|
||
d->pcm = NULL;
|
||
|
||
delete d;
|
||
}
|