AskaEth/MeowOS-For-R3P2
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(ncm §21): 边下边播阶段1+2——stream_src流式源+decoder双路open_cb+下载线程预缓冲/stall联动+P2 HTTP空闲超时+cache fd写者+stream_sim全矩阵PCM金标准(0真实请求,未部署)

Browse Source
This commit is contained in:
MeowOS committed 2026-09-01 18:23:17 +08:00
1 parent dbee37e1d6
commit 9e25db77cc
18 files changed
+1335 -136
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

patch_v2/ncm_app/REPORT.md
+112
View File
@@ -1876,3 +1876,115 @@ ac5b29c40488f34e9220b14105bf63c2 build_ncm_host.sh # +account.c
- vipType（login_status profile.vipType 10/11 口径）未用——BIZ_NOTES §1.2 标注非代码证据， - vipType（login_status profile.vipType 10/11 口径）未用——BIZ_NOTES §1.2 标注非代码证据，
以 vip/info 双端点字段判定为准；真机若 vip/info 全挂可再加 profile.vipType 兜底。 以 vip/info 双端点字段判定为准；真机若 vip/info 全挂可再加 profile.vipType 兜底。
- meow_sheet 无单项置灰（SDK 不在范围）：未解锁档以「·未解锁」标注代替置灰。 - meow_sheet 无单项置灰（SDK 不在范围）：未解锁档以「·未解锁」标注代替置灰。
## 21. 边下边播阶段 1+2：stream_src 流式源 + 全链 PCM 金标准仿真（2026-09-01）
> 范围：仅 `patch_v2/ncm_app/`。按 devdocs/plan/NCM_STREAM_PLAY.md 方案 A 实现
> （F1-F7 实测事实为红线）。阶段 3（.part 断点续传 / LRU 防淘汰 / 失败重试 1 次）
> **本批明确不做**。风控纪律：真实 NCM 请求 **0 次**；**未部署真机**（留主会话）。
### 21.1 stream_src：只读流式字节源（app/play/stream_src.h/.c，新）
- 语义：对**下载中的缓存 .tmp 文件**提供 fread 语义只读视图——只读 fd + `pread`
（不动下载者文件位置），mutex/condvar 同步；状态 = written/final/failed/abort/read_pos。
- `stream_src_read_cb` 严格 fread 语义：**填满才返回**，真 EOF（final 且读到 written）
才短读；100ms timedwait 兜底醒（防 note_written 丢失信号死等）。
- 再缓冲迟滞：单次调用累计等待 >500ms 后，要求前方可用 ≥64KB 才放行（仅本次调用
尚未产出任何字节时下闸），避免慢网 1 字节一放行的抖动空转。
- 统计：underruns（**按「本 read 调用是否发生过等待」计一次**——原 `done==0&&avail==0`
口径被 minimp3 refill 模式绕过，实测 wait=4s 但 underruns=0，已修）/ wait_ms /
stalled（单次等待 >1s 置位，供播放循环联动 audio_out_pause）。
- dr_flac 适配三回调（read/seek/tell）。**SEEK_END 修正**：下载中（!final）按 dr_flac
约定返回 FALSE 跳过元数据总长校验；final 后按 final+offset 应答——此前 origin=2 落进
SEEK_CUR 分支导致 drflac_open 恒失败（/tmp/df_dbg.c 实证，修复后 44.1k/96k flac 均开成功）。
### 21.2 decoder 双路切回调（app/play/decoder.h/.c）
- 新 `ncm_dec_open_src(out, stream_src_t*, ...)`；`ncm_dec_open(path)` 改为包一层
静态 stream_src（src_owned=1，dec_close 连带释放）——本地文件路径零行为变化。
- mp3 = `mp3dec_ex_open_cb`（`MP3D_SEEK_TO_BYTE | MP3D_DO_NOT_SCAN`，io 存 decoder 内）；
flac = `drflac_open(stream_src_drflac_read, dec_flac_seek, dec_flac_tell, src, NULL)`
（枚举与 drflac_int64 签名不兼容 → 静态适配器转换）；格式 sniff 改 `stream_src_peek`。
- mp3 seek **不再关重开**：直接 `mp3dec_ex_seek`（F4：open_cb 下 SEEK_TO_BYTE 直达，
已下载区 seek 零等待）。
### 21.3 播放链（app/play/player_manager.c）
- `song_src_t{src, w, dl_thr, dl_rc, url, maxb, total}`：缓存未命中 → 起 dl_thread 跑
`ncm_http_download`（cb：abort 检查 → `ncm_cache_write` → `stream_src_note_written`）。
- 预缓冲：`stream_src_wait(128KB, 100ms)` 循环（still_current 护栏，切歌即 abort+join+
cache_abort）；出口判据 = aborted 或 (failed 且 written<128KB) 才失败——**断流但已过
门槛 → 放行**（F5：短读即真 EOF，播已下载部分）。
- run_song 走 `ncm_dec_open_src`；解码循环 stalled 沿 → `audio_out_pause(1)`、恢复沿
`pause(0)`（停 PCM 时钟不丢流）；underruns/wait_ms 统计变化才写 g_play。
- 曲尾 `song_src_dispose`：abort+join → dl_rc==OK 则 commit+evict，否则 cache_abort。
- g_play 新增 underruns/underrun_ms/stalled（app/ncm_app_internal.h；play/next 清零）。
### 21.4 HTTP/缓存底座（core/ncm_http.c/.h、core/ncm_cache.c/.h）
- P2：30s 绝对 deadline 拆为两段——连接/握手/请求/响应头维持 **15s 绝对钳**；
hdr_done 后启用 **body 空闲超时 15s**（`NCM_HTTP_BODY_IDLE_MS`，每 ret>0 顺延），
WANT_READ/WRITE 按 hdr_done 二选一——慢速长下载不再被总 deadline 误杀，真挂死仍 15s 断。
- ncm_cache writer 由 FILE* 改 fd（`open(O_WRONLY|O_CREAT|O_TRUNC)` + write(2) 循环
直写；commit = fsync+close+rename 原子落地）；新增 `ncm_cache_writer_tmp_path()`
访问器（stream_src 按 .tmp 路径 pread，无需知道 writer 内部）。
### 21.5 验证记录（0 真实 NCM 请求）
| 项 | 方式 | 结果 |
|---|---|---|
| 边下边播全矩阵 | **bench/stream_sim.c**（新：假网络线程[速率/抖动/cut40/flaky]→真实 ncm_cache→真实 stream_src→真实 decoder→audio_out null sink+PCM 捕获；金标准=同文件离线解码 memcmp）：10MB/s、400kbps、160kbps × normal/seek_dl/seek_wait/cut40/flaky + flac_stream@400kbps = **16 用例** | 宿主 + qemu-mipsel 双平台 **ALL PASS**；正常/断续 PCM 与整首**逐字节一致**，断流与 40% 前缀逐字节一致 |
| 首开声延迟 | 同上矩阵实测 | 10MB/s=0.00s（宿主）/0.13s（qemu）；400kbps=2.60s/2.69s；160kbps=6.54s/6.57s |
| 播放状态机 | player_flow_sim **P1-P8**（适配：ncm_dec_open_src stub、ncm_cache_open 真空 .tmp、commit 移曲尾 dispose → P7 半程先 stop 再等 commit 落地防 stub 污染断言） | **ALL PASS** |
| 解码回归 | test_decode 三样本（flac44=132300f/44.1k/16、flac96=192000f/96k/32、mp3=393984f/48k/16）；另 `git show HEAD:` 取旧 decoder.c 编 test_decode_old，三样本 WAV 新旧**逐字节一致** | **3/3 PASS** + OLD-VS-NEW IDENTICAL |
| qemu-mipsel 解码 | test_decode_mipsel 三样本（重链 +stream_src） | **3/3 PASS**（112×/35.5×/3.2× RT） |
| core 回归 | build_core.sh → test_ncm_core_host + qemu-mipsel test_ncm_core_mipsel | **全 PASS**（含 vip 解析/档位表/缓存命名） |
| 链路回归 | cache_evict_sim / cover_chain_sim / audiod_chain_sim / degrade_sim / window_sim / pagination_sim / toggle_sim（全部重编新 ncm_cache.c/audio_out.c/appstate.c） | **全 PASS**（audiod 14/14 等） |
| mipsel 构建 | build_ncm.sh 自有代码 -Wall -Wextra | **0 warning**；text 969996（+7.1KB vs §20） |
| 宿主离屏 | build_ncm_host.sh + home/player/settings MEOW_UI_DUMP | 全 rc=0，播放页渲染核验正常（sdk meow_ui_vol.c 既有告警除外） |
### 21.6 ⚠️ 断言口径偏差记录（主会话定夺）
- 任务原断言「首开声 <2s@400kbps」与 **F3 红线物理冲突**：mp3 open_cb 强制预读
MINIMP3_IO_SIZE=128KB → 128KB/50KB/s = **2.62s 下限**，<2s 不可达。sim 实测 2.60-2.72s。
本批**未擅自偏离已批准方案**，按可达阈值断言（400kbps <4s，注释写明冲突）。
若要 <2s，选项：MINIMP3_IO_SIZE 减半至 64KB（→~1.31s，重扫 vendor 头文件默认值，
需复测全矩阵）；或预缓冲门槛与 IO_SIZE 解耦（首 64KB 即开声，留给 decoder 内部 refill 等）。
- flaky 用例 underrun>0 由单用例硬断言改**跨速率聚合断言**：单次断续网是否打空缓冲
取决于解码速度（qemu 慢→缓冲消耗慢→宿主 1 次 qemu 0 次，皆正常），PCM 逐字节一致
才是硬判据；聚合断言（宿主=3/qemu=1）仍覆盖统计通路功能。
### 21.7 md5（本批产物 + 改动文件）
```
0dc39a6cf1115fb19644af3cba4c017d ncm # mipsel 静态 App（新；未部署，留主会话）
bd95bbaa0fc2ac3a60bce7bb7cc120ab ncm_host # 宿主离屏调试二进制
1385361ab09bf4c2ec1db0087451e5c2 app/play/stream_src.c # 新
1b803c7f9b70ad3df18689143a1b92a8 app/play/stream_src.h # 新
1b0197c6c4f27675e932024740aaeeab app/play/decoder.c # open_cb 双路 + ncm_dec_open_src
7fd0b09abbb2b75ab4c04e31211bedb2 app/play/decoder.h
fda5d4bb09bb26073b34986aa75cceee app/play/player_manager.c # 下载线程+预缓冲+stall 联动+曲尾 commit
62aeff05b618bc6838b81aadd6c7cebb app/ncm_app_internal.h # g_play underruns/underrun_ms/stalled
15c73a3ee5bc07ff2c26dbd26ff5e321 core/ncm_http.c # P2 空闲超时
b7ed6c165bbc42b36bde43fe634b1cec core/ncm_http.h
422181883426e1289115bb9ec6bae986 core/ncm_cache.c # fd writer + tmp_path 访问器
fe78a119bde44d57c4cae2e5b276c646 core/ncm_cache.h
ce7e1ece2577547d54f6c4cc1cf45bdf bench/stream_sim.c # 新：全矩阵+PCM 金标准
36abe7cdcf4681e18fed595fbc65435d bench/player_flow_sim.c # stub 适配+P7 时序修正
a26350ee298f63e828e06489fee35b92 build_ncm.sh # +stream_src.c
a80ee35f243ac28379cd1adeb61548ed build_ncm_host.sh # +stream_src.c
（test/test_ncm_core_host 重编产物随 build_core.sh 更新）
```
### 21.8 诚实出入 / 遗留
- **真机未部署未验**（留主会话统一）。真机验收点：①缓存未命中歌曲 2-3s 内开声
（400kbps 档约 2.6s）②弱网（限速 160-400kbps）播放不卡死、underrun 后自动恢复、
stalled 时暂停不走时钟 ③播放中切歌/退出：下载线程即 abort、无残留 .tmp ④断网半曲
播已下载部分后自然结束、不重复下载 ⑤完整下完的曲下次命中缓存秒开。
- **阶段 3 未做**（方案明确排除）：.part 断点续传（断流曲下次仍从头下）、LRU 防淘汰
（下载中的 .tmp 可被 evict 边缘情形）、下载失败重试 1 次（现为 0 重试直接失败）。
- flac 大元数据块（大封面 PICTURE 块）open 时可能多等下载（drflac 需扫过元数据链才到
首帧）；实测 44.1k 向量 400kbps 首开声 3.82s（vs mp3 2.60s）即此因。
- UI 菊花/缓冲提示未接 g_play.stalled（字段已备，UI 批再做）。
- 断续网 underrun 聚合断言为时序容忍口径（§21.6），非判据放松——PCM 金标准不变。
patch_v2/ncm_app/app/ncm_app_internal.h
+4
View File
@@ -90,6 +90,10 @@ typedef struct ncm_play_run {
int64_t dl_total; /* 本曲标称大小（song_url 返回；0=未知） */ int64_t dl_total; /* 本曲标称大小（song_url 返回；0=未知） */
int has_track; /* 当前是否有可播曲目（含 url 获取中） */ int has_track; /* 当前是否有可播曲目（含 url 获取中） */
int eff_level; /* 实际生效音质档（§20；≠用户档时播放页标注「已降级至 xx」；-1=未定） */ int eff_level; /* 实际生效音质档（§20；≠用户档时播放页标注「已降级至 xx」；-1=未定） */
/* 边下边播统计（§21，stream_src 搬运，播放线程写/UI 读） */
int underruns; /* 本曲 read_cb 追上下载的等待次数 */
uint64_t underrun_ms; /* 本曲 read_cb 累计等待 ms */
int stalled; /* 1=下载停滞（单次等待>1s，播放线程已对 audiod pause；UI 缓冲菊花） */
/* 播放曲快照（REPORT §17）：run_song 起播时把歌曲对象整体拷入（mu 保护）， /* 播放曲快照（REPORT §17）：run_song 起播时把歌曲对象整体拷入（mu 保护），
* 之后播放/歌词/IPC/UI 全读快照而非窗口——窗口滑出当前播放曲也不影响播放。 */ * 之后播放/歌词/IPC/UI 全读快照而非窗口——窗口滑出当前播放曲也不影响播放。 */
ncm_song_t play_song; ncm_song_t play_song;
patch_v2/ncm_app/app/play/decoder.c
+80 -25
View File
@@ -1,8 +1,19 @@
/* play/decoder.c — 格式分发解码实现（接口见 decoder.h，REPORT §19）。 /* play/decoder.c — 格式分发解码实现（接口见 decoder.h，REPORT §19；§21 切 stream_src 回调模式）。
*
* 两后端都建在 stream_src 上（边下边播 .tmp 与缓存命中静态源同套读回调）：
* mp3 = mp3dec_ex_open_cb(MP3D_SEEK_TO_BYTE | MP3D_DO_NOT_SCAN) —— F3 红线：
* 不带 DO_NOT_SCAN 时 open_cb 对无 Xing tag 的流全扫描建索引，read_cb 阻塞
* 语义下 open 直接卡到整首下完。代价 dec->samples=0，时长走 meta（现状已是）。
* flac = drflac_open(stream_src 回调)。dr_flac 读回调语义「返回实际读到的字节数」，
* stream_src 的严格 fread 实现（填满才返回）是其超集，直接兼容。
* 缓存命中（ncm_dec_open 整文件路径）也走同一 cb 路径——不再 mmap(MAP_POPULATE)
* 整文件（P1 修复：旧 mp3dec_ex_open 在 Linux 预 fault 全部页，RSS ≈ 整文件）。
* *
* mp3 细节：minimp3_ex 的 dec.info（hz/channels）在首次 mp3dec_ex_read 后才保证有效， * mp3 细节：minimp3_ex 的 dec.info（hz/channels）在首次 mp3dec_ex_read 后才保证有效，
* 而调用方开 audio_out 前就要 rate/ch —— open 时先预读一批进 stash，read 先吐 stash。 * 而调用方开 audio_out 前就要 rate/ch —— open 时先预读一批进 stash，read 先吐 stash。
* seek(mp3)：关+重开（MP3D_SEEK_TO_BYTE 索引在 open 时重建）再按字节近似 seek，同旧语义。 * seek(mp3)：MP3D_SEEK_TO_BYTE 下 mp3dec_ex_seek 只是 offset=pos + io->seek(pos)（F4，
* 无需索引、无需关重开），stream_src 的 seek 回调只改 read_pos——目标超已下载区时
* 后续 read 自然阻塞等待数据到达。
*/ */
#include "decoder.h" #include "decoder.h"
#include "minimp3_ex.h" #include "minimp3_ex.h"
@@ -11,6 +22,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sys/stat.h>
#define DEC_STASH_FRAMES 4096 /* open 预读上限（帧），与播放循环单块读同量级 */ #define DEC_STASH_FRAMES 4096 /* open 预读上限（帧），与播放循环单块读同量级 */
@@ -18,11 +30,13 @@ enum { DEC_MP3 = 0, DEC_FLAC = 1 };
struct ncm_decoder { struct ncm_decoder {
int kind; int kind;
char path[512]; stream_src_t *src; /* 读端（ncm_dec_open 自建静态源时 src_owned=1） */
int src_owned;
int rate, ch, bits; int rate, ch, bits;
int64_t total_frames; /* 0=未知 */ int64_t total_frames; /* 0=未知 */
/* mp3 */ /* mp3 */
mp3dec_ex_t mp3; mp3dec_ex_t mp3;
mp3dec_io_t mp3_io; /* 生命周期须覆盖 mp3（minimp3 内部存指针） */
int16_t *stash; /* 预读样本（交织 s16），stash_n 个样本 */ int16_t *stash; /* 预读样本（交织 s16），stash_n 个样本 */
size_t stash_n, stash_off; size_t stash_n, stash_off;
/* flac */ /* flac */
@@ -30,48 +44,74 @@ struct ncm_decoder {
}; };
/* magic 探测：首 4 字节 "fLaC" → flac；其余（ID3 / 0xFF 帧同步 / 未知）→ mp3 /* magic 探测：首 4 字节 "fLaC" → flac；其余（ID3 / 0xFF 帧同步 / 未知）→ mp3
*（未知格式留给 minimp3 在 open 时报错，不在本层加第三种分支）。 */ *（未知格式留给 minimp3 在 open 时报错，不在本层加第三种分支）。
static int sniff_kind(const char *path) * 流模式下 peek 读已落盘前缀（预缓冲门槛 ≥128KB 已满足，或 final 截断有多少读多少）。 */
static int sniff_kind(stream_src_t *src)
{ {
unsigned char m[4] = {0}; unsigned char m[4] = {0};
FILE *f = fopen(path, "rb"); size_t n = stream_src_peek(src, m, 4, 0);
if (f) { size_t n = fread(m, 1, 4, f); fclose(f); if (n < 4) return DEC_MP3; } if (n >= 4 && m[0] == 'f' && m[1] == 'L' && m[2] == 'a' && m[3] == 'C') return DEC_FLAC;
if (m[0] == 'f' && m[1] == 'L' && m[2] == 'a' && m[3] == 'C') return DEC_FLAC;
return DEC_MP3; return DEC_MP3;
} }
int ncm_dec_open(ncm_decoder_t **out, const char *path, /* dr_flac 回调签名适配：seek 的 origin 是枚举、tell 用 drflac_int64(long long)，
int *rate, int *ch, int *bits, int64_t *total_frames) * 与 stream_src 的 int/int64_t 形参在 C 里不兼容，包一层。 */
static drflac_bool32 dec_flac_seek(void *ud, int offset, drflac_seek_origin origin)
{ {
if (!out || !path) return -1; return (drflac_bool32)stream_src_drflac_seek(ud, offset, (int)origin);
ncm_decoder_t *d = (ncm_decoder_t *)calloc(1, sizeof *d); }
if (!d) return -1; static drflac_bool32 dec_flac_tell(void *ud, drflac_int64 *cursor)
d->kind = sniff_kind(path); {
snprintf(d->path, sizeof d->path, "%s", path); int64_t c = 0;
int r = stream_src_drflac_tell(ud, &c);
*cursor = (drflac_int64)c;
return (drflac_bool32)r;
}
static int dec_open_on_src(ncm_decoder_t *d)
{
if (d->kind == DEC_FLAC) { if (d->kind == DEC_FLAC) {
d->flac = drflac_open_file(path, NULL); d->flac = drflac_open(stream_src_drflac_read, dec_flac_seek,
if (!d->flac) { free(d); return -1; } dec_flac_tell, d->src, NULL);
if (!d->flac) return -1;
d->rate = (int)d->flac->sampleRate; d->rate = (int)d->flac->sampleRate;
d->ch = (int)d->flac->channels; d->ch = (int)d->flac->channels;
/* 位宽映射（AUDIOD §4 归一交给 SDK/audiod）：≤16 → S16；>16 → S32 满幅 */ /* 位宽映射（AUDIOD §4 归一交给 SDK/audiod）：≤16 → S16；>16 → S32 满幅 */
d->bits = (d->flac->bitsPerSample <= 16) ? 16 : 32; d->bits = (d->flac->bitsPerSample <= 16) ? 16 : 32;
d->total_frames = (int64_t)d->flac->totalPCMFrameCount; d->total_frames = (int64_t)d->flac->totalPCMFrameCount;
} else { } else {
if (mp3dec_ex_open(&d->mp3, path, MP3D_SEEK_TO_BYTE) != 0) { free(d); return -1; } d->mp3_io.read = stream_src_read_cb;
d->mp3_io.read_data = d->src;
d->mp3_io.seek = stream_src_seek_cb;
d->mp3_io.seek_data = d->src;
if (mp3dec_ex_open_cb(&d->mp3, &d->mp3_io,
MP3D_SEEK_TO_BYTE | MP3D_DO_NOT_SCAN) != 0) return -1;
d->bits = 16; d->bits = 16;
d->stash = (int16_t *)malloc(DEC_STASH_FRAMES * 2 * sizeof(int16_t)); d->stash = (int16_t *)malloc(DEC_STASH_FRAMES * 2 * sizeof(int16_t));
if (!d->stash) { mp3dec_ex_close(&d->mp3); free(d); return -1; } if (!d->stash) { mp3dec_ex_close(&d->mp3); return -1; }
/* 预读首块：填 dec.info（hz/channels）+ 预热 stash */ /* 预读首块：填 dec.info（hz/channels）+ 预热 stash。
* 流模式下此处可能阻塞到下载推进（read_cb 阻塞语义），属预期。 */
size_t got = mp3dec_ex_read(&d->mp3, d->stash, DEC_STASH_FRAMES * 2); size_t got = mp3dec_ex_read(&d->mp3, d->stash, DEC_STASH_FRAMES * 2);
d->stash_n = got; d->stash_n = got;
d->rate = d->mp3.info.hz; d->rate = d->mp3.info.hz;
d->ch = d->mp3.info.channels; d->ch = d->mp3.info.channels;
if (d->rate <= 0 || d->ch <= 0) { /* 首块即失败/空流 */ if (d->rate <= 0 || d->ch <= 0) { /* 首块即失败/空流 */
mp3dec_ex_close(&d->mp3); free(d->stash); free(d); return -1; mp3dec_ex_close(&d->mp3); free(d->stash); d->stash = NULL; return -1;
} }
d->total_frames = (d->ch > 0) ? (int64_t)(d->mp3.samples / (uint64_t)d->ch) : 0; d->total_frames = (d->ch > 0) ? (int64_t)(d->mp3.samples / (uint64_t)d->ch) : 0;
} }
return 0;
}
int ncm_dec_open_src(ncm_decoder_t **out, stream_src_t *src,
int *rate, int *ch, int *bits, int64_t *total_frames)
{
if (!out || !src) return -1;
ncm_decoder_t *d = (ncm_decoder_t *)calloc(1, sizeof *d);
if (!d) return -1;
d->src = src;
d->kind = sniff_kind(src);
if (dec_open_on_src(d) != 0) { ncm_dec_close(d); return -1; }
if (d->ch < 1 || d->ch > 2) { ncm_dec_close(d); return -1; } /* v1 只接 单/双声道 */ if (d->ch < 1 || d->ch > 2) { ncm_dec_close(d); return -1; } /* v1 只接 单/双声道 */
*out = d; *out = d;
@@ -82,6 +122,22 @@ int ncm_dec_open(ncm_decoder_t **out, const char *path,
return 0; return 0;
} }
int ncm_dec_open(ncm_decoder_t **out, const char *path,
int *rate, int *ch, int *bits, int64_t *total_frames)
{
if (!out || !path) return -1;
struct stat st;
if (stat(path, &st) != 0 || !S_ISREG(st.st_mode)) return -1;
stream_src_t *src = NULL;
if (stream_src_open_static(&src, path, (uint64_t)st.st_size) != 0) return -1;
if (ncm_dec_open_src(out, src, rate, ch, bits, total_frames) != 0) {
stream_src_close(src);
return -1;
}
(*out)->src_owned = 1;
return 0;
}
int64_t ncm_dec_read(ncm_decoder_t *d, void *buf, int64_t cap_frames) int64_t ncm_dec_read(ncm_decoder_t *d, void *buf, int64_t cap_frames)
{ {
if (!d || !buf || cap_frames <= 0) return 0; if (!d || !buf || cap_frames <= 0) return 0;
@@ -117,10 +173,8 @@ int ncm_dec_seek_ms(ncm_decoder_t *d, int64_t ms, int64_t file_bytes, int64_t du
drflac_uint64 frame = (drflac_uint64)(ms * d->rate / 1000); drflac_uint64 frame = (drflac_uint64)(ms * d->rate / 1000);
return drflac_seek_to_pcm_frame(d->flac, frame) ? 0 : -1; return drflac_seek_to_pcm_frame(d->flac, frame) ? 0 : -1;
} }
/* mp3：关+重开（重建字节索引）再按字节近似 */ /* mp3：MP3D_SEEK_TO_BYTE 下 seek 只是 offset=pos + io->seek(pos)（F4），
mp3dec_ex_close(&d->mp3); * 无需索引、无需关重开；目标超已下载区时 read 自然阻塞等待。 */
memset(&d->mp3, 0, sizeof d->mp3);
if (mp3dec_ex_open(&d->mp3, d->path, MP3D_SEEK_TO_BYTE) != 0) return -1;
d->stash_n = d->stash_off = 0; d->stash_n = d->stash_off = 0;
int64_t target = (file_bytes > 0 && dur_ms > 0) ? file_bytes * ms / dur_ms : 0; int64_t target = (file_bytes > 0 && dur_ms > 0) ? file_bytes * ms / dur_ms : 0;
return mp3dec_ex_seek(&d->mp3, (uint64_t)(target > 0 ? target : 0)); return mp3dec_ex_seek(&d->mp3, (uint64_t)(target > 0 ? target : 0));
@@ -131,6 +185,7 @@ void ncm_dec_close(ncm_decoder_t *d)
if (!d) return; if (!d) return;
if (d->kind == DEC_FLAC) { if (d->flac) drflac_close(d->flac); } if (d->kind == DEC_FLAC) { if (d->flac) drflac_close(d->flac); }
else { mp3dec_ex_close(&d->mp3); free(d->stash); } else { mp3dec_ex_close(&d->mp3); free(d->stash); }
if (d->src_owned) stream_src_close(d->src);
free(d); free(d);
} }
patch_v2/ncm_app/app/play/decoder.h
+12 -3
View File
@@ -8,6 +8,7 @@
#define NCM_DECODER_H #define NCM_DECODER_H
#include <stdint.h> #include <stdint.h>
#include "stream_src.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@@ -15,14 +16,22 @@ extern "C" {
typedef struct ncm_decoder ncm_decoder_t; typedef struct ncm_decoder ncm_decoder_t;
/* 打开并探测流参数：rate/ch/bits/total_frames 经指针回填实际值（mp3 恒 16bit； /* 在 stream_src 上打开并探测流参数（边下边播/缓存命中统一入口，§21）：
* total_frames 0=未知）。返回 0=成功。 */ * magic 经 stream_src_peek 探测；mp3=mp3dec_ex_open_cb（MP3D_SEEK_TO_BYTE|MP3D_DO_NOT_SCAN，
* F3 红线：不带 DO_NOT_SCAN 会全流扫描阻塞到下载结束）；flac=drflac_open 回调模式。
* src 由调用方持有（dec_close 不关闭 src）。rate/ch/bits/total_frames 经指针回填
* （mp3 恒 16bit；total_frames 0=未知）。返回 0=成功。 */
int ncm_dec_open_src(ncm_decoder_t **out, stream_src_t *src,
int *rate, int *ch, int *bits, int64_t *total_frames);
/* 整文件路径便捷入口：内部建 final=size 的静态 stream_src（dec_close 一并释放）。
* 解码同样走 cb 路径（不 mmap 整文件，P1 修复），输出与 ncm_dec_open_src 一致。 */
int ncm_dec_open(ncm_decoder_t **out, const char *path, int ncm_dec_open(ncm_decoder_t **out, const char *path,
int *rate, int *ch, int *bits, int64_t *total_frames); int *rate, int *ch, int *bits, int64_t *total_frames);
/* 读最多 cap_frames 帧到 buf（交织，样本位宽=open 返回的 bits；cap 以帧计， /* 读最多 cap_frames 帧到 buf（交织，样本位宽=open 返回的 bits；cap 以帧计，
* buf 容量须 ≥ cap_frames*ch*(bits/8)）。返回实际帧数，0=EOF。 */ * buf 容量须 ≥ cap_frames*ch*(bits/8)）。返回实际帧数，0=EOF。 */
int64_t ncm_dec_read(ncm_decoder_t *d, void *buf, int64_t cap_frames); int64_t ncm_dec_read(ncm_decoder_t *d, void *buf, int64_t cap_frames);
/* seek 到 ms。flac=精确 PCM 帧；mp3=按 file_bytes*ms/dur_ms 字节近似（同旧语义）。 */ /* seek 到 ms。flac=精确 PCM 帧；mp3=按 file_bytes*ms/dur_ms 字节近似（同旧语义）。
* 流模式下 seek 目标超已下载区时读端自然阻塞等待（F4），不报错。 */
int ncm_dec_seek_ms(ncm_decoder_t *d, int64_t ms, int64_t file_bytes, int64_t dur_ms); int ncm_dec_seek_ms(ncm_decoder_t *d, int64_t ms, int64_t file_bytes, int64_t dur_ms);
void ncm_dec_close(ncm_decoder_t *d); void ncm_dec_close(ncm_decoder_t *d);
/* "mp3" / "flac"（日志/UI 用）。 */ /* "mp3" / "flac"（日志/UI 用）。 */
patch_v2/ncm_app/app/play/player_manager.c
+222 -83
View File
@@ -1,5 +1,5 @@
/* play/player_manager.c — 播放线程：URL 获取(全档表逐级降级)→缓存(命中直接播/否则流式落盘)→ /* play/player_manager.c — 播放线程：URL 获取(全档表逐级降级)→缓存(命中直接播/否则边下边播)→
* minimp3/dr_flac 解码→audio_out 直写。UI 不卡（网络+解码全在此线程）。 * minimp3/dr_flac 解码(stream_src 回调)→audio_out 直写。UI 不卡（网络+解码全在此线程）。
* *
* 模型：一个持久的播放线程。外层循环取「目标曲目」，run_song() 负责一首歌的 * 模型：一个持久的播放线程。外层循环取「目标曲目」，run_song() 负责一首歌的
* 「下载(缓冲) → 解码 → 输出 → 结束/被指令打断」。暂停=冻结（停读停写停推 pos，状态置 PAUSED）； * 「下载(缓冲) → 解码 → 输出 → 结束/被指令打断」。暂停=冻结（停读停写停推 pos，状态置 PAUSED）；
@@ -11,6 +11,12 @@
* 音频缓存键 = 歌曲ID+音质档位（用户定案 NCM_CACHE_DESIGN §2.5），旧无档位键温和兼容。 * 音频缓存键 = 歌曲ID+音质档位（用户定案 NCM_CACHE_DESIGN §2.5），旧无档位键温和兼容。
* §20：音质体系全量——用户档超会员权限不硬拒（钳顶后逐级降级，eff_level 回填供播放页 * §20：音质体系全量——用户档超会员权限不硬拒（钳顶后逐级降级，eff_level 回填供播放页
* 「已降级至 xx」标注；下一首回到用户档）；fee∈{1,4} 且非会员 → NCM_ERR_VIP 不发请求。 * 「已降级至 xx」标注；下一首回到用户档）；fee∈{1,4} 且非会员 → NCM_ERR_VIP 不发请求。
* §21：边下边播（NCM_STREAM_PLAY 方案 A）——下载拆到独立线程（write(2) 直写 .tmp +
* stream_src 推进可读边界），解码经 ncm_dec_open_src 的 read_cb（严格 fread 语义，F7）
* pread 同一文件；预缓冲 ≥128KB 才 open（minimp3 MINIMP3_IO_SIZE 强制门槛，F3）；
* 下载完成由播放线程 commit(rename)；缓存命中用 final=size 的静态 stream_src（P1：
* 不再 mmap 整文件）；http 30s 绝对 deadline 已改空闲超时（P2）。.part 续传/LRU 防淘汰
* 留阶段 3。
*/ */
#include "../ncm_app_internal.h" #include "../ncm_app_internal.h"
#include <stdio.h> #include <stdio.h>
@@ -19,6 +25,7 @@
#include <unistd.h> #include <unistd.h>
#include <sys/stat.h> #include <sys/stat.h>
#include "decoder.h" #include "decoder.h"
#include "stream_src.h"
static pthread_t g_thr; static pthread_t g_thr;
static int g_thr_on; static int g_thr_on;
@@ -92,6 +99,9 @@ void player_manager_play(int song_idx)
g_play.dl_total = 0; g_play.dl_total = 0;
g_play.seq++; g_play.seq++;
g_play.eff_level = -1; /* 新播放意图：生效档未定（song_local_file 回填） */ g_play.eff_level = -1; /* 新播放意图：生效档未定（song_local_file 回填） */
g_play.underruns = 0; /* §21：边下边播统计随新播放意图清零 */
g_play.underrun_ms = 0;
g_play.stalled = 0;
pthread_mutex_unlock(&g_play.mu); pthread_mutex_unlock(&g_play.mu);
} }
@@ -127,6 +137,9 @@ void player_manager_next(int dir)
g_play.dl_total = 0; g_play.dl_total = 0;
g_play.seq++; g_play.seq++;
g_play.eff_level = -1; /* 切歌：生效档随新曲重估（下首恢复用户档，§20） */ g_play.eff_level = -1; /* 切歌：生效档随新曲重估（下首恢复用户档，§20） */
g_play.underruns = 0;
g_play.underrun_ms = 0;
g_play.stalled = 0;
} }
pthread_mutex_unlock(&g_play.mu); pthread_mutex_unlock(&g_play.mu);
} }
@@ -143,13 +156,77 @@ void player_manager_stop(void)
} }
/* ---- 每首歌的播放体（在外层循环内调用）---- */ /* ---- 每首歌的播放体（在外层循环内调用）---- */
static int download_cb(void *ctx, const unsigned char *data, size_t len)
/* 边下边播每首曲的源对象（§21）：读端 stream_src + 下载路径写端/线程。
* run_song 栈上分配，下载线程 join 后才返回，生命周期安全。 */
#define PREBUFFER_BYTES (128 * 1024) /* 预缓冲门槛 = minimp3 MINIMP3_IO_SIZE（F3 实测强制） */
typedef struct {
stream_src_t *src; /* 读端（下载路径 written 由下载线程推进；缓存命中=静态源） */
ncm_cache_writer_t *w; /* 下载路径写端（commit/abort 归播放线程）；缓存命中=NULL */
pthread_t dl_thr;
int dl_thr_on;
int dl_rc; /* 下载线程结果（NCM_OK / 负错误码） */
char url[1024];/* 下载线程用（song_local_file 栈上 u.url 生命周期不够，拷贝） */
size_t maxb; /* 下载限幅 */
int64_t total; /* 标称大小（song_url size；0=未知；mp3 seek 分母） */
} song_src_t;
/* http 体回调（下载线程上下文；ncm_http 每次投递 ≤4KB）：write(2) 直写落盘 +
* 锁内推进 written + broadcast 唤醒读端 + 进度反馈。 */
static int stream_dl_cb(void *ctx, const unsigned char *data, size_t len)
{ {
/* 下载进度反馈（UI「缓冲中… N%」，§18）：回调在播放线程，锁内仅累加。 */ song_src_t *ss = (song_src_t *)ctx;
if (stream_src_aborted(ss->src)) return 1; /* 切歌/停止：中止 http */
if (ncm_cache_write(ss->w, data, len) != NCM_OK) return 1;
stream_src_note_written(ss->src, (uint64_t)len);
pthread_mutex_lock(&g_play.mu); pthread_mutex_lock(&g_play.mu);
g_play.dl_done += (int64_t)len; g_play.dl_done += (int64_t)len;
pthread_mutex_unlock(&g_play.mu); pthread_mutex_unlock(&g_play.mu);
return ncm_cache_write((ncm_cache_writer_t *)ctx, data, len); return 0;
}
static void *dl_thread(void *arg)
{
song_src_t *ss = (song_src_t *)arg;
ncm_http_req_t req;
memset(&req, 0, sizeof req);
req.url = ss->url;
req.method = "GET";
req.extra_hdrs = "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
req.verify_ca = NCM_HTTP_VERIFY_DEFAULT;
req.timeout_ms = 15000; /* 绝对段（连接/握手/头）上限；body 空闲超时 15s（P2） */
ncm_http_resp_t resp;
int rc = ncm_http_download(&req, stream_dl_cb, ss, ss->maxb, &resp);
if (rc == NCM_OK && resp.status != 200) rc = NCM_ERR_HTTP;
ss->dl_rc = rc;
/* 结束通知：成功 final=全长；失败/中止 final=截断点+failed（读端播到截断点自然结束，F5） */
stream_src_finish(ss->src, rc == NCM_OK ? 0 : rc);
return NULL;
}
/* 收尾（播放线程，解码循环退出后调用）：中止在途下载并 join → commit(rename 转正) 或
* abort(unlink .tmp)。阶段 2 语义：中断即丢弃；.part 续传/LRU 防淘汰留阶段 3。 */
static void song_src_dispose(song_src_t *ss)
{
if (ss->dl_thr_on) {
stream_src_abort(ss->src); /* 已完成则无副作用；在途则 cb 返回 NZ 中止 */
pthread_join(ss->dl_thr, NULL);
ss->dl_thr_on = 0;
}
if (ss->w) {
if (ss->dl_rc == NCM_OK) {
/* 下载完整：commit 转正进 LRU 池（rename 不影响读端已开 fd，此处已近曲终） */
if (ncm_cache_commit(ss->w) == 0)
ncm_cache_evict(&g_st.ctx.cache); /* 写后检查：新落盘可能推过上限 */
} else {
ncm_cache_abort(ss->w);
}
ss->w = NULL;
}
if (ss->src) { stream_src_close(ss->src); ss->src = NULL; }
} }
/* 缓存键（用户定案 NCM_CACHE_DESIGN §2.5）：歌曲ID + 音质档位 → "song_<id>_<level>.<ext>"。 /* 缓存键（用户定案 NCM_CACHE_DESIGN §2.5）：歌曲ID + 音质档位 → "song_<id>_<level>.<ext>"。
@@ -160,50 +237,63 @@ static void audio_cache_key(char *out, size_t sz, const char *id, int level)
snprintf(out, sz, "%s_%s", id, ncm_api_level_key(level)); snprintf(out, sz, "%s_%s", id, ncm_api_level_key(level));
} }
/* 得到本地音频路径 + 文件大小。命中缓存直接返回；否则 URL 降级 + 流式落缓存。 /* 切歌竞态护栏（§18）：物化/下载/预缓冲期间用户可能已切歌——只有仍是当前目标且处于
* 返回 NCM_OK 或负错误码。s 为播放曲快照（run_song 物化，与窗口解耦 §17）。 * BUFFER（本次播放意图未过期）才继续，否则直接回外层（外层会以新 cur 重跑 run_song）。 */
static int still_current(int idx)
{
pthread_mutex_lock(&g_play.mu);
int ok = (g_play.cur_song == idx) && (g_play.state == NCM_PC_BUFFER);
pthread_mutex_unlock(&g_play.mu);
return ok;
}
/* 得到本地音频源（§21 边下边播）。命中缓存 → 静态 stream_src（final=size，read 不阻塞，
* 顺带修 P1：不再 mmap 整文件）；否则 URL 降级 → 起下载线程写 .tmp → 预缓冲 ≥128KB 即返回
* （下载在后台继续，解码经 stream_src read_cb 跟播）。
* 返回 NCM_OK 或负错误码；成功时 ss->src 就绪、ss->total 与 *bytes 回填（下载未完成时
* total=song_url 标称 size，0=未知）。s 为播放曲快照（run_song 物化，与窗口解耦 §17）。
* §20 权限/会员： * §20 权限/会员：
* - fee 门禁（BIZ_NOTES §3 社区口径）：fee∈{1,4}（VIP 才能听/付费专）且当前非会员 * - fee 门禁（BIZ_NOTES §3 社区口径）：fee∈{1,4}（VIP 才能听/付费专）且当前非会员
* → 直接 NCM_ERR_VIP，**不发 song_url 请求**（省一次请求，防风控）；fee=0/8 放行 * → 直接 NCM_ERR_VIP，**不发 song_url 请求**（省一次请求，防风控）；fee=0/8 放行
* （8=免费听低音质，播放允许）。本地缓存命中优先于门禁（缓存可播不拦）。 * （8=免费听低音质，播放允许）。本地缓存命中优先于门禁（缓存可播不拦）。
* - VIP 档上限：用户档超会员权限不硬拒，播放时先钳到会员允许的最高档再逐级降级 * - VIP 档上限：用户档超会员权限不硬拒，播放时先钳到会员允许的最高档再逐级降级
* （免去注定空 URL 的高档请求）；实际生效档回填 g_play.eff_level。 */ * （免去注定空 URL 的高档请求）；实际生效档回填 g_play.eff_level。 */
static int song_local_file(const ncm_song_t *s, char *path, size_t psz, int64_t *bytes) static int song_local_file(const ncm_song_t *s, int idx, song_src_t *ss,
char *path, size_t psz, int64_t *bytes)
{ {
memset(ss, 0, sizeof *ss);
const char *id = s->id; const char *id = s->id;
char key[64]; char key[64];
audio_cache_key(key, sizeof key, id, g_level); audio_cache_key(key, sizeof key, id, g_level);
/* 缓存命中 → 离线直接播（新键两扩展名都试；档位=用户设定档，降级产物也归该档键） */ /* 缓存命中 → 静态 stream_src（新键两扩展名都试；档位=用户设定档，降级产物也归该档键） */
int hit = 0;
if (ncm_cache_lookup(&g_st.ctx.cache, key, "flac", path, psz) == NCM_OK || if (ncm_cache_lookup(&g_st.ctx.cache, key, "flac", path, psz) == NCM_OK ||
ncm_cache_lookup(&g_st.ctx.cache, key, "mp3", path, psz) == NCM_OK) { ncm_cache_lookup(&g_st.ctx.cache, key, "mp3", path, psz) == NCM_OK) {
struct stat st; hit = 1;
if (stat(path, &st) == 0) { } else if (ncm_cache_lookup(&g_st.ctx.cache, id, "mp3", path, psz) == NCM_OK) {
*bytes = (int64_t)st.st_size; /* 旧键温和兼容（§19 前存量：无档位后缀的 song_<id>[.]mp3，含历史双点名）：
/* 生效档推断（缓存键=用户档，降级产物归用户档键，无法精确还原）： * 命中即播，不主动改名/删除，由 LRU 自然淘汰。 */
* mp3 实体 + 用户档 > 极高 → 必为降级产物，标 EXHIGH；其余按用户档显示。 hit = 2;
* （flac 实体视为与用户档一致；hires→lossless 档内降级会高估显示，已知取舍。） */
const char *dot = strrchr(path, '.');
int eff = g_level;
if (dot && ncm_streq(dot, "mp3") && g_level > NCM_LEVEL_EXHIGH)
eff = NCM_LEVEL_EXHIGH;
pthread_mutex_lock(&g_play.mu);
g_play.eff_level = eff;
pthread_mutex_unlock(&g_play.mu);
return NCM_OK;
}
} }
/* 旧键温和兼容（§19 前存量：无档位后缀的 song_<id>[.]mp3，含历史双点名）：命中即播， if (hit) {
* 不主动改名/删除，由 LRU 自然淘汰。 */
if (ncm_cache_lookup(&g_st.ctx.cache, id, "mp3", path, psz) == NCM_OK) {
struct stat st; struct stat st;
if (stat(path, &st) == 0) { if (stat(path, &st) != 0) return NCM_ERR_NOENT;
*bytes = (int64_t)st.st_size; if (stream_src_open_static(&ss->src, path, (uint64_t)st.st_size) != 0)
pthread_mutex_lock(&g_play.mu); return NCM_ERR_IO;
g_play.eff_level = (g_level > NCM_LEVEL_EXHIGH) ? NCM_LEVEL_EXHIGH : g_level; ss->total = (int64_t)st.st_size;
pthread_mutex_unlock(&g_play.mu); *bytes = ss->total;
return NCM_OK; /* 生效档推断（缓存键=用户档，降级产物归用户档键，无法精确还原）：
} * mp3 实体 + 用户档 > 极高 → 必为降级产物，标 EXHIGH；其余按用户档显示。
* （flac 实体视为与用户档一致；hires→lossless 档内降级会高估显示，已知取舍。） */
const char *dot = strrchr(path, '.');
int eff = g_level;
if (dot && ncm_streq(dot, "mp3") && g_level > NCM_LEVEL_EXHIGH)
eff = NCM_LEVEL_EXHIGH;
pthread_mutex_lock(&g_play.mu);
g_play.eff_level = eff;
pthread_mutex_unlock(&g_play.mu);
return NCM_OK;
} }
/* fee 门禁：VIP 才能听（1=VIP 歌曲 / 4=付费数字专辑）且非会员 → 不请求 url。 /* fee 门禁：VIP 才能听（1=VIP 歌曲 / 4=付费数字专辑）且非会员 → 不请求 url。
@@ -222,50 +312,63 @@ static int song_local_file(const ncm_song_t *s, char *path, size_t psz, int64_t
if (!u.url[0]) return NCM_ERR_NOTFOUND; if (!u.url[0]) return NCM_ERR_NOTFOUND;
pthread_mutex_lock(&g_play.mu); pthread_mutex_lock(&g_play.mu);
g_play.eff_level = (eff >= 0) ? eff : want; g_play.eff_level = (eff >= 0) ? eff : want;
g_play.dl_total = (u.size > 0) ? u.size : 0; /* 缓冲进度% 分母（0=未知只转菊花） */
pthread_mutex_unlock(&g_play.mu); pthread_mutex_unlock(&g_play.mu);
/* 落盘扩展名：type 权威；type 缺失时看 url 扩展名，默认 mp3 */ /* 落盘扩展名：type 权威；type 缺失时看 url 扩展名，默认 mp3 */
const char *ext = "mp3"; const char *ext = "mp3";
if (ncm_streq(u.type, "flac")) ext = "flac"; if (ncm_streq(u.type, "flac")) ext = "flac";
else if (!u.type[0] && strstr(u.url, ".flac")) ext = "flac"; else if (!u.type[0] && strstr(u.url, ".flac")) ext = "flac";
pthread_mutex_lock(&g_play.mu);
g_play.dl_total = (u.size > 0) ? u.size : 0; /* 缓冲进度% 分母（0=未知只转菊花） */
pthread_mutex_unlock(&g_play.mu);
/* 写前检查：池大小超限先按 LRU 淘汰（此线程尚未开 temp，无在途文件被误删风险） */ /* 写前检查：池大小超限先按 LRU 淘汰（此线程尚未开 temp，无在途文件被误删风险） */
ncm_cache_evict(&g_st.ctx.cache); ncm_cache_evict(&g_st.ctx.cache);
/* 流式下载到缓存 temp → commit（稳妥者：先落盘再播） */ /* 边下边播（§21）：下载线程写 .tmp（write(2) 直写），解码线程 pread 同一文件 */
ncm_cache_writer_t *w = NULL; rc = ncm_cache_open(&g_st.ctx.cache, key, ext, &ss->w);
rc = ncm_cache_open(&g_st.ctx.cache, key, ext, &w);
if (rc != NCM_OK) return rc; if (rc != NCM_OK) return rc;
if (stream_src_open_stream(&ss->src, ncm_cache_writer_tmp_path(ss->w)) != 0) {
ncm_http_req_t req; ncm_cache_abort(ss->w); ss->w = NULL;
memset(&req, 0, sizeof req); return NCM_ERR_IO;
req.url = u.url; }
req.method = "GET"; ncm_strlcpy(path, ncm_cache_writer_tmp_path(ss->w), psz); /* 日志用 */
req.extra_hdrs = "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " ss->total = (u.size > 0) ? u.size : 0;
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
req.verify_ca = NCM_HTTP_VERIFY_DEFAULT;
req.timeout_ms = 30000;
ncm_http_resp_t resp;
/* 上限：Hi-Res flac 单曲可达数百 MB（192k/24bit 5min ≈345MB），flac 上限 1GB；mp3 维持 64MB。 /* 上限：Hi-Res flac 单曲可达数百 MB（192k/24bit 5min ≈345MB），flac 上限 1GB；mp3 维持 64MB。
* size 可信时按 size 限幅（防超额），未知按格式默认上限。 */ * size 可信时按 size 限幅（防超额），未知按格式默认上限。 */
size_t cap = (ext[0] == 'f') ? (1024u << 20) : (64u << 20); size_t cap = (ext[0] == 'f') ? (1024u << 20) : (64u << 20);
size_t maxb = (u.size > 0 && (uint64_t)u.size < cap) ? (size_t)u.size : cap; ss->maxb = (u.size > 0 && (uint64_t)u.size < cap) ? (size_t)u.size : cap;
rc = ncm_http_download(&req, download_cb, w, maxb, &resp); ncm_strlcpy(ss->url, u.url, sizeof ss->url);
if (rc != NCM_OK || resp.status != 200) { if (pthread_create(&ss->dl_thr, NULL, dl_thread, ss) != 0) {
ncm_cache_abort(w); ncm_cache_abort(ss->w); ss->w = NULL;
return (rc != NCM_OK) ? rc : NCM_ERR_HTTP; stream_src_close(ss->src); ss->src = NULL;
return NCM_ERR_IO;
} }
rc = ncm_cache_commit(w); ss->dl_thr_on = 1;
if (rc != 0) return rc;
/* 写后检查：新落盘可能把池推过上限 → 再按 LRU 淘汰最旧（刚写的 mtime 最新，存活） */ /* 预缓冲：≥128KB（minimp3 强制门槛，F3）才放行 open_cb；final/failed 提前出。
ncm_cache_evict(&g_st.ctx.cache); * still_current 护栏覆盖本阻塞点：等待期间切歌/停止 → 中止下载静默放弃。 */
if (ncm_cache_lookup(&g_st.ctx.cache, key, ext, path, psz) != NCM_OK) for (;;) {
return NCM_ERR_NOENT; int wr = stream_src_wait(ss->src, PREBUFFER_BYTES, 100);
struct stat st; if (wr != 0) break;
if (stat(path, &st) == 0) *bytes = (int64_t)st.st_size; if (g_app_quit || !still_current(idx)) {
stream_src_abort(ss->src);
pthread_join(ss->dl_thr, NULL); ss->dl_thr_on = 0;
ncm_cache_abort(ss->w); ss->w = NULL;
stream_src_close(ss->src); ss->src = NULL;
return NCM_ERR_IO; /* 调用方 still_current 复核后静默返回 */
}
}
if (stream_src_aborted(ss->src) ||
(stream_src_failed(ss->src) && stream_src_written(ss->src) < PREBUFFER_BYTES)) {
/* 中止，或首开声前失败（written < 预缓冲门槛）：abort .tmp
*（阶段 2 不保留不重试；重试策略留阶段 3）。已下过门槛的断流照常放行——
* 读端播到截断点自然结束（F5）。 */
int frc = stream_src_failed(ss->src);
pthread_join(ss->dl_thr, NULL); ss->dl_thr_on = 0;
ncm_cache_abort(ss->w); ss->w = NULL;
stream_src_close(ss->src); ss->src = NULL;
return frc ? frc : NCM_ERR_NET;
}
/* final < 门槛（小文件/截断）：照样放行，open_cb 读到的就是全部 */
*bytes = ss->total > 0 ? ss->total : (int64_t)stream_src_written(ss->src);
return NCM_OK; return NCM_OK;
} }
@@ -278,17 +381,7 @@ static void set_err(int err, const char *msg)
pthread_mutex_unlock(&g_play.mu); pthread_mutex_unlock(&g_play.mu);
} }
/* 切歌竞态护栏（§18）：物化/下载期间用户可能已切歌——只有仍是当前目标且处于 BUFFER /* 一首歌：源就绪(缓存/下载线程+预缓冲)→解码→输出，直到结束或被打断。返回后由外层处理下一首。 */
* （本次播放意图未过期）才继续，否则直接回外层（外层会以新 cur 重跑 run_song）。 */
static int still_current(int idx)
{
pthread_mutex_lock(&g_play.mu);
int ok = (g_play.cur_song == idx) && (g_play.state == NCM_PC_BUFFER);
pthread_mutex_unlock(&g_play.mu);
return ok;
}
/* 一首歌：下载→解码→输出，直到结束或被打断。返回后由外层处理下一首。 */
static void run_song(int idx) static void run_song(int idx)
{ {
/* §17 滑窗兼容：物化目标曲（窗内命中 / 盘缓存 / song_detail 单曲）并整体快照进 /* §17 滑窗兼容：物化目标曲（窗内命中 / 盘缓存 / song_detail 单曲）并整体快照进
@@ -304,35 +397,43 @@ static void run_song(int idx)
g_play.play_song_valid = 1; g_play.play_song_valid = 1;
pthread_mutex_unlock(&g_play.mu); pthread_mutex_unlock(&g_play.mu);
song_src_t ss;
int64_t file_bytes = 0; int64_t file_bytes = 0;
char path[512]; char path[512];
int rc = song_local_file(&s, path, sizeof path, &file_bytes); int rc = song_local_file(&s, idx, &ss, path, sizeof path, &file_bytes);
if (rc != NCM_OK) { if (rc != NCM_OK) {
if (!still_current(idx)) return; /* 下载期间已切歌：静默放弃（缓存已落盘不亏） */ if (!still_current(idx)) return; /* 下载期间已切歌：静默放弃（已落盘部分不亏） */
const char *m = (rc == NCM_ERR_VIP) ? "VIP only (fee gate)" const char *m = (rc == NCM_ERR_VIP) ? "VIP only (fee gate)"
: (rc == NCM_ERR_NOTFOUND) ? "no stream (VIP/copyright)" : (rc == NCM_ERR_NOTFOUND) ? "no stream (VIP/copyright)"
: (rc == NCM_ERR_AUTH) ? "session expired" : "load failed"; : (rc == NCM_ERR_AUTH) ? "session expired" : "load failed";
set_err(rc, m); set_err(rc, m);
return; return;
} }
if (!still_current(idx)) return; /* 下载完成但已切歌：勿开解码/勿动状态 */ if (!still_current(idx)) { /* 预缓冲完成但已切歌：勿开解码/勿动状态 */
song_src_dispose(&ss);
return;
}
ncm_strlcpy(g_path, path, sizeof g_path); ncm_strlcpy(g_path, path, sizeof g_path);
g_file_bytes = file_bytes; g_file_bytes = file_bytes;
int64_t dur = s.duration_ms > 0 ? s.duration_ms : 0; int64_t dur = s.duration_ms > 0 ? s.duration_ms : 0;
/* 解码分发（§19）：magic 探测 fLaC→dr_flac / 其它→minimp3；rate/ch/bits 按实际流。 */ /* 解码分发（§19/§21）：stream_src 上 magic 探测 fLaC→dr_flac / 其它→minimp3（open_cb
* SEEK_TO_BYTE|DO_NOT_SCAN）；rate/ch/bits 按实际流。 */
ncm_decoder_t *dec = NULL; ncm_decoder_t *dec = NULL;
int rate = 0, ch = 0, bits = 0; int rate = 0, ch = 0, bits = 0;
int64_t total_frames = 0; int64_t total_frames = 0;
if (ncm_dec_open(&dec, path, &rate, &ch, &bits, &total_frames) != 0) { if (ncm_dec_open_src(&dec, ss.src, &rate, &ch, &bits, &total_frames) != 0) {
song_src_dispose(&ss);
if (!still_current(idx)) return; /* open 期间（flac 元数据等待）已切歌 */
set_err(NCM_ERR_IO, "decode open failed"); return; set_err(NCM_ERR_IO, "decode open failed"); return;
} }
if (dur <= 0 && total_frames > 0 && rate > 0) dur = total_frames * 1000 / rate; if (dur <= 0 && total_frames > 0 && rate > 0) dur = total_frames * 1000 / rate;
/* 音频输出：按实际流参数开（flac ≤16bit→S16，>16bit→S32；audiod 侧格式归一+原生率跟随） */ /* 音频输出：按实际流参数开（flac ≤16bit→S16，>16bit→S32；audiod 侧格式归一+原生率跟随） */
if (audio_out_open(rate, ch, bits) != 0) { if (audio_out_open(rate, ch, bits) != 0) {
ncm_dec_close(dec); set_err(NCM_ERR_IO, "audio open failed"); return; ncm_dec_close(dec); song_src_dispose(&ss);
set_err(NCM_ERR_IO, "audio open failed"); return;
} }
/* 状态→播放 */ /* 状态→播放 */
@@ -351,6 +452,8 @@ static void run_song(int idx)
int64_t frames_done = 0; /* 已输出帧（每通道） */ int64_t frames_done = 0; /* 已输出帧（每通道） */
int need_seek_ms = -1; int need_seek_ms = -1;
int paused_edge = 0; /* 暂停沿：进暂停已向 audiod 发 pause */ int paused_edge = 0; /* 暂停沿：进暂停已向 audiod 发 pause */
int stalled_edge = 0; /* §21 停滞沿：已对 audiod pause(1)，待数据恢复 pause(0) */
int underruns_seen = 0;
for (;;) { for (;;) {
if (g_app_quit) break; if (g_app_quit) break;
@@ -385,7 +488,8 @@ static void run_song(int idx)
} }
if (need_seek_ms >= 0) { if (need_seek_ms >= 0) {
/* seek：flac 精确帧 / mp3 关+重开按字节近似（decoder 内处理）；输出重开 */ /* seek：flac 精确帧 / mp3 字节近似（MP3D_SEEK_TO_BYTE 直接 seek，无需关重开）；
* 目标超已下载区时 read_cb 自然阻塞等待（F4），输出重开 */
meow_log(MEOW_LOG_INFO, "play: seek idx=%d -> %dms", idx, need_seek_ms); meow_log(MEOW_LOG_INFO, "play: seek idx=%d -> %dms", idx, need_seek_ms);
audio_out_close(); audio_out_close();
if (ncm_dec_seek_ms(dec, need_seek_ms, g_file_bytes, dur) != 0) { if (ncm_dec_seek_ms(dec, need_seek_ms, g_file_bytes, dur) != 0) {
@@ -397,8 +501,19 @@ static void run_song(int idx)
continue; continue;
} }
/* §21 停滞联动：read_cb 单次等待 >1s（audiod 流饥饿风险）→ 先对 audiod pause(1)
* 保住流（暂停路径现状已有），数据恢复后 pause(0)（流死自动重开）。 */
if (stream_src_take_stalled(ss.src) && !stalled_edge) {
stalled_edge = 1;
meow_log(MEOW_LOG_INFO, "play: stalled idx=%d -> audio pause(1)", idx);
audio_out_pause(1);
pthread_mutex_lock(&g_play.mu);
g_play.stalled = 1;
pthread_mutex_unlock(&g_play.mu);
}
int64_t frames = ncm_dec_read(dec, pcm, PCM_CHUNK_FRAMES); int64_t frames = ncm_dec_read(dec, pcm, PCM_CHUNK_FRAMES);
if (frames == 0) { /* 播完 */ if (frames == 0) { /* 播完（下载中断时=截断点，F5） */
meow_log(MEOW_LOG_INFO, "play: done idx=%d frames=%lld", idx, (long long)frames_done); meow_log(MEOW_LOG_INFO, "play: done idx=%d frames=%lld", idx, (long long)frames_done);
break; break;
} }
@@ -409,6 +524,28 @@ static void run_song(int idx)
break; break;
} }
frames_done += frames; frames_done += frames;
if (stalled_edge) { /* 数据恢复：解除停滞 pause */
stalled_edge = 0;
meow_log(MEOW_LOG_INFO, "play: stall recovered idx=%d -> audio pause(0)", idx);
if (audio_out_pause(0) != 0) { set_err(NCM_ERR_IO, "audio resume failed"); break; }
pthread_mutex_lock(&g_play.mu);
g_play.stalled = 0;
pthread_mutex_unlock(&g_play.mu);
}
/* underrun 统计落 g_play（§21，设置页/日志可见；变化才持锁写） */
{
int u; uint64_t wm;
stream_src_stats(ss.src, &u, &wm);
if (u != underruns_seen) {
underruns_seen = u;
pthread_mutex_lock(&g_play.mu);
g_play.underruns = u;
g_play.underrun_ms = wm;
pthread_mutex_unlock(&g_play.mu);
meow_log(MEOW_LOG_INFO, "play: underrun idx=%d count=%d wait=%llums",
idx, u, (unsigned long long)wm);
}
}
/* 更新进度（~200ms 节流）*/ /* 更新进度（~200ms 节流）*/
int64_t pos = rate > 0 ? frames_done * 1000 / rate : 0; int64_t pos = rate > 0 ? frames_done * 1000 / rate : 0;
pthread_mutex_lock(&g_play.mu); pthread_mutex_lock(&g_play.mu);
@@ -419,6 +556,8 @@ static void run_song(int idx)
audio_out_close(); audio_out_close();
ncm_dec_close(dec); ncm_dec_close(dec);
/* 下载完成由播放线程 commit(rename) / 中断 abort（阶段 2 语义，§21） */
song_src_dispose(&ss);
/* 若应继续播下一首且非因命令打断，由外层处理（外层见 cur==idx 且需自然结束） */ /* 若应继续播下一首且非因命令打断，由外层处理（外层见 cur==idx 且需自然结束） */
} }
patch_v2/ncm_app/app/play/stream_src.c
+299
View File
@@ -0,0 +1,299 @@
/* play/stream_src.c — 边下边播共享流源实现（接口与契约见 stream_src.h，REPORT §21）。
*
* 关键实测事实（NCM_STREAM_PLAY.md，红线）：
* F7 read_cb 必须严格 fread 语义（填满才返回，真 EOF 才短读），否则 minimp3 假播完；
* F5 写端中断（final=截断点）→ 读端短读 → 解码干净结束于截断点；
* F4 seek 到未下载区只是改 read_pos，read 自然阻塞等待，数据到后继续出声。
*
* 等待/唤醒：pthread condvar + 100ms timedwait 兜底（防丢唤醒）。
* 再缓冲迟滞（§4.2）：单次调用累计等待 >500ms 后，要求 written-read_pos >= 64KB 才放行
* （防「每追上 1 帧就出声」的爆音感）；final/failed/abort 时不受限。
*/
#include "stream_src.h"
#include <fcntl.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#define WAIT_SLICE_MS 100 /* cond timedwait 兜底片长 */
#define REBUFFER_AFTER_MS 500 /* 单次调用累计等待超此值后启用再缓冲迟滞 */
#define REBUFFER_MIN (64 * 1024) /* 迟滞放行门槛（≈1.6s@320kbps） */
#define STALL_MS 1000 /* 单次调用等待超此值 → 置 stalled（播放线程 pause 联动） */
struct stream_src {
int fd; /* 只读 fd（pread；写端另有自己的写 fd） */
pthread_mutex_t mu;
pthread_cond_t cv; /* written/final/failed/abort 变化时 broadcast */
uint64_t written; /* 已落盘字节（单调增，写端推进） */
uint64_t final; /* 0=下载中；>0=最终大小（完成=全长，中断=截断点） */
int failed; /* <0=下载/IO 错误码 */
int abort; /* 切歌/停止：读端按 EOF 处理，写端回调返回 NZ */
uint64_t read_pos; /* 解码逻辑读指针（seek 回调改写；允许 > written） */
/* 统计 */
uint64_t wait_ms_total;
int underruns;
int stalled;
};
static int64_t mono_ms(void)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (int64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
}
static int src_alloc(stream_src_t **out, int fd)
{
stream_src_t *s = (stream_src_t *)calloc(1, sizeof *s);
if (!s) { close(fd); return -1; }
s->fd = fd;
pthread_mutex_init(&s->mu, NULL);
pthread_cond_init(&s->cv, NULL);
*out = s;
return 0;
}
int stream_src_open_stream(stream_src_t **out, const char *tmp_path)
{
if (!out || !tmp_path) return -1;
int fd = open(tmp_path, O_RDONLY);
if (fd < 0) return -1;
return src_alloc(out, fd); /* written=0/final=0：下载中 */
}
int stream_src_open_static(stream_src_t **out, const char *path, uint64_t size)
{
if (!out || !path) return -1;
int fd = open(path, O_RDONLY);
if (fd < 0) return -1;
int rc = src_alloc(out, fd);
if (rc == 0) {
(*out)->written = size;
(*out)->final = size ? size : 1; /* 空文件也置 final（read 立即 EOF） */
}
return rc;
}
void stream_src_close(stream_src_t *s)
{
if (!s) return;
if (s->fd >= 0) close(s->fd);
pthread_mutex_destroy(&s->mu);
pthread_cond_destroy(&s->cv);
free(s);
}
void stream_src_note_written(stream_src_t *s, uint64_t n)
{
if (!s || !n) return;
pthread_mutex_lock(&s->mu);
s->written += n;
pthread_cond_broadcast(&s->cv);
pthread_mutex_unlock(&s->mu);
}
void stream_src_finish(stream_src_t *s, int err)
{
if (!s) return;
pthread_mutex_lock(&s->mu);
s->final = s->written ? s->written : 1; /* 0 字节下载也视为结束（final=1 > written=0） */
if (err) s->failed = err;
pthread_cond_broadcast(&s->cv);
pthread_mutex_unlock(&s->mu);
}
void stream_src_abort(stream_src_t *s)
{
if (!s) return;
pthread_mutex_lock(&s->mu);
s->abort = 1;
pthread_cond_broadcast(&s->cv);
pthread_mutex_unlock(&s->mu);
}
int stream_src_aborted(stream_src_t *s)
{
if (!s) return 1;
pthread_mutex_lock(&s->mu);
int a = s->abort;
pthread_mutex_unlock(&s->mu);
return a;
}
int stream_src_wait(stream_src_t *s, uint64_t need, int timeout_ms)
{
if (!s) return -1;
pthread_mutex_lock(&s->mu);
if (s->written >= need) { pthread_mutex_unlock(&s->mu); return 1; }
if (s->final || s->failed || s->abort) { pthread_mutex_unlock(&s->mu); return -1; }
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_nsec += (long)timeout_ms * 1000000L;
if (ts.tv_nsec >= 1000000000L) { ts.tv_sec++; ts.tv_nsec -= 1000000000L; }
pthread_cond_timedwait(&s->cv, &s->mu, &ts);
int r;
if (s->written >= need) r = 1;
else if (s->final || s->failed || s->abort) r = -1;
else r = 0;
pthread_mutex_unlock(&s->mu);
return r;
}
size_t stream_src_peek(stream_src_t *s, void *buf, size_t n, uint64_t off)
{
if (!s || !buf || !n) return 0;
pthread_mutex_lock(&s->mu);
uint64_t avail = (s->written > off) ? s->written - off : 0;
pthread_mutex_unlock(&s->mu);
if (!avail) return 0;
if (n > avail) n = (size_t)avail;
ssize_t r = pread(s->fd, buf, n, (off_t)off);
return r > 0 ? (size_t)r : 0;
}
/* 核心读：严格 fread 语义。minimp3（MP3D_READ_CB）与 dr_flac（drflac_read_proc）
* 共用——dr_flac 接受「实际读到的字节数」，尽力填满是其超集，两契约同满足。 */
static size_t src_read(void *buf, size_t size, void *ud)
{
stream_src_t *s = (stream_src_t *)ud;
size_t done = 0;
int64_t waited = 0; /* 本次调用累计等待 ms */
int waited_this_call = 0; /* 本次调用是否已进入过等待（underrun 按调用计一次） */
pthread_mutex_lock(&s->mu);
while (done < size) {
uint64_t avail = (s->written > s->read_pos) ? s->written - s->read_pos : 0;
/* 再缓冲迟滞：本轮累计等过 >500ms 后，前方不足 64KB 且未结束 → 继续等
*（仅本轮尚未产出字节时下闸；已有产出则尽力填满）。 */
int gated = (done == 0 && avail > 0 && waited > REBUFFER_AFTER_MS &&
avail < REBUFFER_MIN && !s->final && !s->failed && !s->abort);
if (avail > 0 && !gated) {
size_t n = (size - done) < (size_t)avail ? (size - done) : (size_t)avail;
uint64_t pos = s->read_pos;
pthread_mutex_unlock(&s->mu); /* pread 期间放锁，不阻塞写端 broadcast */
ssize_t r = pread(s->fd, (char *)buf + done, n, (off_t)pos);
pthread_mutex_lock(&s->mu);
if (r <= 0) { /* 盘 IO 错：按中断收尾（真 EOF 语义） */
if (!s->failed) s->failed = -3; /* NCM_ERR_IO（本层不依赖 core 头） */
s->final = s->written ? s->written : 1;
pthread_cond_broadcast(&s->cv);
break;
}
s->read_pos += (uint64_t)r;
done += (size_t)r;
continue;
}
if (s->final || s->failed || s->abort) break; /* 真 EOF：短读/0 返回 */
/* 追上下载：记 underrun（每次 read 调用至多计一次——minimp3 一次 refill 常先给
* 部分数据再等待，done==0 口径会漏记；按「本调用发生了等待」计数） */
if (!waited_this_call) { waited_this_call = 1; s->underruns++; }
int64_t t0 = mono_ms();
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_nsec += WAIT_SLICE_MS * 1000000L;
if (ts.tv_nsec >= 1000000000L) { ts.tv_sec++; ts.tv_nsec -= 1000000000L; }
pthread_cond_timedwait(&s->cv, &s->mu, &ts);
int64_t dt = mono_ms() - t0;
if (dt > 0) { waited += dt; s->wait_ms_total += (uint64_t)dt; }
if (waited > STALL_MS) s->stalled = 1;
}
pthread_mutex_unlock(&s->mu);
return done;
}
size_t stream_src_read_cb(void *buf, size_t size, void *ud) { return src_read(buf, size, ud); }
int stream_src_seek_cb(uint64_t pos, void *ud)
{
stream_src_t *s = (stream_src_t *)ud;
pthread_mutex_lock(&s->mu);
s->read_pos = pos; /* 允许 > written：读端自然阻塞等待（F4） */
pthread_mutex_unlock(&s->mu);
return 0;
}
size_t stream_src_drflac_read(void *ud, void *buf, size_t bytes_to_read)
{
return src_read(buf, bytes_to_read, ud);
}
int stream_src_drflac_seek(void *ud, int offset, int origin)
{
stream_src_t *s = (stream_src_t *)ud;
pthread_mutex_lock(&s->mu);
if (origin == STREAM_SRC_SEEK_SET) {
s->read_pos = (offset < 0) ? 0 : (uint64_t)offset;
} else if (origin == STREAM_SRC_SEEK_END) {
/* dr_flac open 期用 SEEK_END+tell 取文件总长做元数据校验；下载中不知总长，
* 按 dr_flac 约定返回 FALSE（hasKnownFileSize=false → 跳过该校验）。
* 静态源/已完成的下载 final 已知 → 正常定位。 */
if (!s->final) { pthread_mutex_unlock(&s->mu); return 0; }
int64_t np = (int64_t)s->final + offset;
if (np < 0) { pthread_mutex_unlock(&s->mu); return 0; }
s->read_pos = (uint64_t)np;
} else {
int64_t np = (int64_t)s->read_pos + offset;
if (np < 0) { pthread_mutex_unlock(&s->mu); return 0; } /* drflac_bool32 false */
s->read_pos = (uint64_t)np;
}
pthread_mutex_unlock(&s->mu);
return 1; /* drflac_bool32 true */
}
int stream_src_drflac_tell(void *ud, int64_t *cursor)
{
stream_src_t *s = (stream_src_t *)ud;
if (!cursor) return 0;
pthread_mutex_lock(&s->mu);
*cursor = (int64_t)s->read_pos;
pthread_mutex_unlock(&s->mu);
return 1;
}
void stream_src_stats(stream_src_t *s, int *underruns, uint64_t *wait_ms)
{
if (!s) return;
pthread_mutex_lock(&s->mu);
if (underruns) *underruns = s->underruns;
if (wait_ms) *wait_ms = s->wait_ms_total;
pthread_mutex_unlock(&s->mu);
}
int stream_src_take_stalled(stream_src_t *s)
{
if (!s) return 0;
pthread_mutex_lock(&s->mu);
int v = s->stalled;
s->stalled = 0;
pthread_mutex_unlock(&s->mu);
return v;
}
uint64_t stream_src_written(stream_src_t *s)
{
if (!s) return 0;
pthread_mutex_lock(&s->mu);
uint64_t w = s->written;
pthread_mutex_unlock(&s->mu);
return w;
}
uint64_t stream_src_final(stream_src_t *s)
{
if (!s) return 1;
pthread_mutex_lock(&s->mu);
uint64_t f = s->final;
pthread_mutex_unlock(&s->mu);
return f;
}
int stream_src_failed(stream_src_t *s)
{
if (!s) return -1;
pthread_mutex_lock(&s->mu);
int f = s->failed;
pthread_mutex_unlock(&s->mu);
return f;
}
patch_v2/ncm_app/app/play/stream_src.h
+79
View File
@@ -0,0 +1,79 @@
/* play/stream_src.h — 边下边播共享流源（REPORT §21，方案 NCM_STREAM_PLAY A：写穿缓存）。
*
* 模型：下载线程把字节顺序写进 .tmp（ncm_cache 写者 write(2) 直写，不走 stdio 缓冲），
* 解码线程经本对象 pread 同一文件——落盘的文件本身就是下载缓冲，内存里无第二份拷贝。
* 写端每写完一块调用 stream_src_note_written() 推进可读边界并 broadcast 唤醒读端；
* 下载结束（完成/中断）stream_src_finish() 置 final；切歌/停止 stream_src_abort()。
*
* 读回调契约（实测红线 F7）：stream_src_read_cb 严格 fread 语义——填满才返回，
* 真 EOF（final/failed/abort 且数据耗尽）才短读；否则 minimp3 把短读当 EOF 假播完。
* dr_flac 回调语义不同（返回实际读到的字节数）：本对象同样先尽力填满再返回，
* 两种契约同时满足。
*
* 本层只依赖 pthread/pread/write，不依赖 core（保持 app/play 层自含）。
*/
#ifndef NCM_STREAM_SRC_H
#define NCM_STREAM_SRC_H
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct stream_src stream_src_t;
/* seek 原点（与 drflac_seek_origin 同值，避免本头依赖 dr_flac.h）。 */
enum { STREAM_SRC_SEEK_SET = 0, STREAM_SRC_SEEK_CUR = 1, STREAM_SRC_SEEK_END = 2 };
/* 下载路径：tmp_path 已由 ncm_cache_open 创建（写端持有自己的写 fd）；
* 本函数只开只读 fd（pread 与写端 write 无偏移冲突），written 从 0 起由写端推进。 */
int stream_src_open_stream(stream_src_t **out, const char *tmp_path);
/* 缓存命中路径：完整文件，written=final=size，read 永不阻塞（同一套读回调）。 */
int stream_src_open_static(stream_src_t **out, const char *path, uint64_t size);
void stream_src_close(stream_src_t *s);
/* ---- 写端（下载线程） ---- */
/* 数据已落盘（ncm_cache_write 成功）后调用：推进可读边界 + 唤醒读端。 */
void stream_src_note_written(stream_src_t *s, uint64_t n);
/* 下载结束：err==0=完成（final=written），否则中断（final=written + failed=err）。
* 之后 read_cb 数据耗尽即短读（真 EOF），解码自然结束于截断点（F5）。 */
void stream_src_finish(stream_src_t *s, int err);
/* 切歌/停止：唤醒所有等待，read 立即按 EOF 短读返回；下载回调应随后返回 NZ 中止 http。 */
void stream_src_abort(stream_src_t *s);
int stream_src_aborted(stream_src_t *s); /* 下载回调每块开头廉价检查 */
/* ---- 预缓冲 ---- */
/* 等 written >= need；final/failed/abort 提前返回。timeout_ms 为单次等待上限
* （调用方在循环里套切歌护栏）。返回 1=满足，0=超时，<0=已结束/失败/中止。 */
int stream_src_wait(stream_src_t *s, uint64_t need, int timeout_ms);
/* 同步 peek（pread，不动 read_pos）：magic 探测用。off+n 超出 written 的部分不读，
* 返回实际读到字节数。 */
size_t stream_src_peek(stream_src_t *s, void *buf, size_t n, uint64_t off);
/* ---- minimp3 回调（MP3D_READ_CB / MP3D_SEEK_CB） ---- */
size_t stream_src_read_cb(void *buf, size_t size, void *ud);
int stream_src_seek_cb(uint64_t pos, void *ud);
/* ---- dr_flac 回调（drflac_read_proc / drflac_seek_proc / drflac_tell_proc） ---- */
size_t stream_src_drflac_read(void *ud, void *buf, size_t bytes_to_read);
int stream_src_drflac_seek(void *ud, int offset, int origin); /* origin=STREAM_SRC_SEEK_* */
int stream_src_drflac_tell(void *ud, int64_t *cursor);
/* ---- 统计 / 停滞联动 ---- */
/* underrun=read_cb 追上下载（无数据可给）的等待次数；wait_ms=累计等待 ms。 */
void stream_src_stats(stream_src_t *s, int *underruns, uint64_t *wait_ms);
/* 单次 read 等待 >1s 置位（播放线程下一轮对 audiod pause(1)，恢复后 pause(0)）。
* 取走即清零。 */
int stream_src_take_stalled(stream_src_t *s);
uint64_t stream_src_written(stream_src_t *s);
uint64_t stream_src_final(stream_src_t *s); /* 0=下载中；>0=最终大小（完成=全长，中断=截断点） */
int stream_src_failed(stream_src_t *s); /* 0=无错误；<0=下载/IO 错误码 */
#ifdef __cplusplus
}
#endif
#endif /* NCM_STREAM_SRC_H */
patch_v2/ncm_app/bench/player_flow_sim.c
+25 -7
View File
@@ -17,12 +17,16 @@
* -Icore -Ivendor/jsmn -c bench/player_flow_sim.c -o /tmp/pf.o * -Icore -Ivendor/jsmn -c bench/player_flow_sim.c -o /tmp/pf.o
* gcc -O2 -ffunction-sections -DJSMN_HEADER -I. -I../sdk -I../meow_launcherd \ * gcc -O2 -ffunction-sections -DJSMN_HEADER -I. -I../sdk -I../meow_launcherd \
* -Icore -Ivendor/jsmn -Ivendor/minimp3 -Ivendor/dr_flac -c app/play/player_manager.c -o /tmp/pf_pm.o * -Icore -Ivendor/jsmn -Ivendor/minimp3 -Ivendor/dr_flac -c app/play/player_manager.c -o /tmp/pf_pm.o
* gcc -O2 -Wl,--gc-sections -o player_flow_sim /tmp/pf.o /tmp/pf_pm.o -lpthread -lm * gcc -O2 -ffunction-sections -DJSMN_HEADER -I. -I../sdk -I../meow_launcherd \
* -Icore -c app/play/stream_src.c -o /tmp/pf_ss.o
* gcc -O2 -Wl,--gc-sections -o player_flow_sim /tmp/pf.o /tmp/pf_pm.o /tmp/pf_ss.o -lpthread -lm
* 运行：./player_flow_sim （0 网络；PASS/FAIL 退出码） * 运行：./player_flow_sim （0 网络；PASS/FAIL 退出码）
* §19：P6 覆盖缓存键=歌曲ID+档位 + flac type → .flac 落盘扩展名。 * §19：P6 覆盖缓存键=歌曲ID+档位 + flac type → .flac 落盘扩展名。
* §20：P7 覆盖 VIP 钳顶（非会员用户档 SURROUND → 请求档 EXHIGH，缓存键仍用户档 sky_c51； * §20：P7 覆盖 VIP 钳顶（非会员用户档 SURROUND → 请求档 EXHIGH，缓存键仍用户档 sky_c51；
* SVIP 直达）+ eff_level 回填；P8 覆盖 fee 门禁（fee=1 非会员 NCM_ERR_VIP 零请求 / * SVIP 直达）+ eff_level 回填；P8 覆盖 fee 门禁（fee=1 非会员 NCM_ERR_VIP 零请求 /
* 缓存命中绕过 / CVIP 放行 / fee=8 放行）。 * 缓存命中绕过 / CVIP 放行 / fee=8 放行）。
* §21：边下边播——下载线程走 stub http_download（经真实 stream_src 预缓冲门槛），
* 解码器 stub 换 ncm_dec_open_src。
*/ */
#include "../app/ncm_app_internal.h" #include "../app/ncm_app_internal.h"
#include "../app/play/decoder.h" #include "../app/play/decoder.h"
@@ -95,15 +99,20 @@ int ncm_cache_lookup(const ncm_cache_t *c, const char *id, const char *ext, char
snprintf(out, out_sz, "/tmp/pf_sim.mp3"); snprintf(out, out_sz, "/tmp/pf_sim.mp3");
return NCM_OK; return NCM_OK;
} }
static char g_tmp_path[] = "/tmp/pf_sim_dl.tmp"; /* 下载路径 stub 的 .tmp（§21：stream_src 要真实打开） */
int ncm_cache_open(const ncm_cache_t *c, const char *id, const char *ext, ncm_cache_writer_t **w) int ncm_cache_open(const ncm_cache_t *c, const char *id, const char *ext, ncm_cache_writer_t **w)
{ {
(void)c; (void)c;
snprintf(g_last_key, sizeof g_last_key, "%s", id); snprintf(g_last_key, sizeof g_last_key, "%s", id);
snprintf(g_last_ext, sizeof g_last_ext, "%s", ext ? ext : ""); snprintf(g_last_ext, sizeof g_last_ext, "%s", ext ? ext : "");
FILE *f = fopen(g_tmp_path, "wb"); /* 建空 .tmp：stream_src_open_stream 需存在 */
if (f) fclose(f);
*w = (ncm_cache_writer_t *)calloc(1, 64); return NCM_OK; *w = (ncm_cache_writer_t *)calloc(1, 64); return NCM_OK;
} }
const char *ncm_cache_writer_tmp_path(const ncm_cache_writer_t *w) { (void)w; return g_tmp_path; }
int ncm_cache_write(ncm_cache_writer_t *w, const unsigned char *d, size_t l) { (void)w; (void)d; (void)l; return NCM_OK; } int ncm_cache_write(ncm_cache_writer_t *w, const unsigned char *d, size_t l) { (void)w; (void)d; (void)l; return NCM_OK; }
int ncm_cache_commit(ncm_cache_writer_t *w) { free(w); g_cache_ok = 1; return NCM_OK; } static int g_commits; /* §21：commit 移到曲尾 dispose（边下边播），P7 等收尾用 */
int ncm_cache_commit(ncm_cache_writer_t *w) { free(w); g_cache_ok = 1; g_commits++; return NCM_OK; }
int ncm_cache_abort(ncm_cache_writer_t *w) { free(w); return NCM_OK; } int ncm_cache_abort(ncm_cache_writer_t *w) { free(w); return NCM_OK; }
int ncm_cache_evict(const ncm_cache_t *c) { (void)c; return NCM_OK; } int ncm_cache_evict(const ncm_cache_t *c) { (void)c; return NCM_OK; }
void ncm_cache_set_limit_gb(ncm_cache_t *c, int gb) { (void)c; (void)gb; } void ncm_cache_set_limit_gb(ncm_cache_t *c, int gb) { (void)c; (void)gb; }
@@ -139,16 +148,16 @@ int ncm_http_download(const ncm_http_req_t *req, ncm_http_write_cb cb, void *ctx
return NCM_OK; return NCM_OK;
} }
/* ---- 解码器 stub（§19：player_manager 改走 ncm_dec_* 分发层）： /* ---- 解码器 stub（§19：player_manager 走 ncm_dec_* 分发层；§21：open 改 ncm_dec_open_src）：
* g_eof 前恒有数据（P1 用 g_reads_left 控制播完点） ---- */ * g_eof 前恒有数据（P1 用 g_reads_left 控制播完点） ---- */
static int g_eof; static int g_eof;
static int g_reads_left = -1; /* >=0: 剩余读次数后 EOF；-1: 直到 g_eof */ static int g_reads_left = -1; /* >=0: 剩余读次数后 EOF；-1: 直到 g_eof */
static int g_dec_open_bits = 16; /* 模拟流位宽（记录用） */ static int g_dec_open_bits = 16; /* 模拟流位宽（记录用） */
int ncm_dec_open(ncm_decoder_t **out, const char *path, int *rate, int *ch, int *bits, int ncm_dec_open_src(ncm_decoder_t **out, stream_src_t *src, int *rate, int *ch, int *bits,
int64_t *total_frames) int64_t *total_frames)
{ {
(void)path; (void)src;
*out = (ncm_decoder_t *)calloc(1, 16); *out = (ncm_decoder_t *)calloc(1, 16);
if (rate) *rate = 44100; if (rate) *rate = 44100;
if (ch) *ch = 2; if (ch) *ch = 2;
@@ -347,7 +356,16 @@ int main(void)
"eff_level=%d (expect EXHIGH，UI 标「已降级至 极高 HQ」)", player_manager_eff_level()); "eff_level=%d (expect EXHIGH，UI 标「已降级至 极高 HQ」)", player_manager_eff_level());
CHECK(strcmp(g_last_key, "1000_sky_c51") == 0, CHECK(strcmp(g_last_key, "1000_sky_c51") == 0,
"cache key=%s (expect 1000_sky_c51 = id+用户档，降级产物归用户档键)", g_last_key); "cache key=%s (expect 1000_sky_c51 = id+用户档，降级产物归用户档键)", g_last_key);
/* SVIP：同一用户档不钳顶，直达 SURROUND */ /* SVIP：同一用户档不钳顶，直达 SURROUND。
* §21 时序：commit 移到 song0 曲尾 dispose（边下边播）——先 stop 阻断外层自动顺延
* 到 song1 的竞态，再等 commit 落地后才切缓存开关，否则 commit stub 会把
* g_cache_ok 重新置 1 / 自动顺延的 song1 会先发出请求 → 断言读数被污染。 */
g_eof = 1;
player_manager_stop();
{
int cb = g_commits;
for (int t = 0; t < 3000 && g_commits == cb; t += 10) usleep(10 * 1000);
}
g_vip = NCM_VIP_SVIP; g_cache_ok = 0; g_url_calls = 0; g_url_req_level = -1; g_vip = NCM_VIP_SVIP; g_cache_ok = 0; g_url_calls = 0; g_url_req_level = -1;
player_manager_play(1); player_manager_play(1);
CHECK(wait_state(NCM_PC_PLAYING, 3000), "svip song playing"); CHECK(wait_state(NCM_PC_PLAYING, 3000), "svip song playing");
patch_v2/ncm_app/bench/stream_sim.c
+453
View File
@@ -0,0 +1,453 @@
/* bench/stream_sim.c — 边下边播全链离线验证（REPORT §21；NCM_STREAM_PLAY §8 阶段 0/1/2 矩阵）。
*
* 链路：假网络线程（可调速率/抖动/断流/断续网）→ 真实 ncm_cache 写者（write(2) 直写 .tmp）
* → 真实 stream_src（pread + condvar + fread 语义 read_cb）→ 真实 decoder
* （mp3=open_cb SEEK_TO_BYTE|DO_NOT_SCAN / flac=drflac_open 回调）→ 真实 audio_out(SINK_NULL)
* + PCM 捕获，与「同文件整首离线解码」逐字节比对（金标准；断流场景比到截断点）。
*
* 矩阵：速率 {10MB/s, 400kbps, 160kbps} × {正常播完, seek 已下载区, seek 未下载区等待,
* 40% 断流, 断续网}；附加 flac 边下边播用例（dr_flac 回调路径）。
* 断言：跑完无死锁（看门狗）、PCM 逐字节一致（seek 用例除外，断流比前缀）、首开声延迟、
* underrun 统计（慢网/断续网 >0）、commit 后缓存文件与源逐字节一致。
*
* 编译（宿主，ncm_app 目录下）：
* gcc -O2 -Wall -Wextra -DJSMN_HEADER -I. -Icore -I../sdk -I../meow_launcherd \
* -Ivendor/jsmn -Ivendor/minimp3 -Ivendor/dr_flac \
* bench/stream_sim.c app/play/stream_src.c app/play/decoder.c app/play/audio_out.c \
* core/ncm_cache.c -c # 逐个 -c 后链接，或整体：
* gcc -O2 -Wall -Wextra ...同上... -o stream_sim ... app/play/minimp3_impl.o dr_flac_impl.o -lpthread -lm
* （minimp3_impl/dr_flac_impl 为 vendor 豁免 TU，单独 -O2 无 -Wall 编译）
* mipsel：换 $CC_MIPS -static，产物用 qemu-mipsel 跑。
* 运行：./stream_sim [mp3 路径] （0 网络；PASS/FAIL 退出码）
*/
#include "../app/ncm_app_internal.h" /* audio_out 声明 + 全局态（g_st/g_play/g_app_quit） */
#include "../app/play/decoder.h"
#include "../app/play/stream_src.h"
#include "../core/ncm_cache.h"
#include "../core/ncm_common.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <time.h>
#include <sys/stat.h>
/* ---- 全局态（audio_out.c / ncm_app_internal.h 需要） ---- */
ncm_app_state_t g_st;
ncm_play_run_t g_play = { .mu = PTHREAD_MUTEX_INITIALIZER };
volatile int g_app_quit = 0;
volatile int g_net_ready = 0;
int g_host_mock = 1;
/* ---- 桩：SDK/核心库其他 TU 符号（本 sim 不链） ---- */
void meow_log(meow_log_level lvl, const char *fmt, ...) { (void)lvl; (void)fmt; }
uint64_t meow_ui_time_ms(void)
{
struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
/* audio_out.c 的 AUDIOD 后端符号（本 sim 恒 NCM_AUDIO_SINK=null，不会调到；仅链接用） */
int meow_audio_open(int rate, int ch, int fmt) { (void)rate; (void)ch; (void)fmt; return -1; }
int meow_audio_write(const void *pcm, int frames) { (void)pcm; return frames; }
int meow_audio_pause(int sid, int paused) { (void)sid; (void)paused; return 0; }
int meow_audio_close(int sid) { (void)sid; return 0; }
int meow_audio_query(meow_audio_state *out) { (void)out; return -1; }
void meow_audio_on_preempt(meow_audio_preempt_fn cb, void *ctx) { (void)cb; (void)ctx; }
/* ncm_cache.c 依赖（同 cache_evict_sim 口径内联） */
size_t ncm_strlcpy(char *dst, const char *src, size_t sz)
{
size_t n = 0;
if (sz) { while (src[n] && n < sz - 1) { dst[n] = src[n]; n++; } dst[n] = 0; }
while (src[n]) n++;
return n;
}
int ncm_store_mkdir_p(const char *path)
{
if (!path || !*path) return -1;
char tmp[512];
size_t len = strlen(path);
if (len >= sizeof tmp) return -1;
memcpy(tmp, path, len + 1);
if (tmp[len - 1] == '/') tmp[len - 1] = '\0';
for (char *p = tmp + 1; *p; p++) {
if (*p == '/') { *p = '\0'; mkdir(tmp, 0755); *p = '/'; }
}
return mkdir(tmp, 0755) == 0 || errno == EEXIST ? 0 : -1;
}
int ncm_store_read_cfg_int(const char *dir, const char *key, int dflt)
{ (void)dir; (void)key; return dflt; }
/* ---- 小工具 ---- */
static double now_s(void)
{
struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);
return (double)ts.tv_sec + ts.tv_nsec / 1e9;
}
typedef struct { unsigned char *b; size_t n, cap; } pcm_buf_t;
static void pcm_put(pcm_buf_t *p, const void *data, size_t len)
{
if (p->n + len > p->cap) {
size_t nc = p->cap ? p->cap * 2 : (1 << 20);
while (nc < p->n + len) nc *= 2;
p->b = (unsigned char *)realloc(p->b, nc);
if (!p->b) { fprintf(stderr, "oom\n"); exit(2); }
p->cap = nc;
}
memcpy(p->b + p->n, data, len);
p->n += len;
}
static int g_fail = 0;
#define CHECK(cond, fmt, ...) do { \
if (cond) printf(" PASS " fmt "\n", ##__VA_ARGS__); \
else { printf(" FAIL " fmt "\n", ##__VA_ARGS__); g_fail = 1; } \
} while (0)
/* ---- 假网络线程：按速率/抖动/断流/断续网 把源文件写进真实 ncm_cache 写者 ---- */
typedef struct {
const unsigned char *data;
size_t size;
uint64_t rate_Bps; /* 字节/秒 */
int jitter_ms; /* 每块延迟 ±jitter */
double cut_frac; /* >0: 写到该比例即断流（finish 带错误） */
int flaky; /* 断续网：每 ~6 块额外停 100-400ms */
stream_src_t *src;
ncm_cache_writer_t *w;
int rc; /* NCM_OK / 负 */
} net_t;
static void *net_thread(void *arg)
{
net_t *nt = (net_t *)arg;
const size_t CH = 4096;
size_t off = 0;
size_t cut_at = (nt->cut_frac > 0) ? (size_t)(nt->size * nt->cut_frac) : (size_t)-1;
unsigned rng = 12345;
int chunk_no = 0;
while (off < nt->size && off < cut_at) {
size_t n = nt->size - off;
if (n > CH) n = CH;
if (off + n > cut_at) n = cut_at - off;
/* 节奏：块/速率 + 抖动 */
double base_ms = nt->rate_Bps ? (double)n * 1000.0 / (double)nt->rate_Bps : 0.0;
rng = rng * 1103515245u + 12345u;
double jit = nt->jitter_ms ? ((double)((rng >> 16) % 200) / 100.0 - 1.0) * nt->jitter_ms : 0.0;
long sleep_ms = (long)(base_ms + jit);
if (nt->flaky && chunk_no % 6 == 5) {
rng = rng * 1103515245u + 12345u;
sleep_ms += 100 + (long)((rng >> 16) % 300); /* 断续网：额外停滞 */
}
if (sleep_ms > 0) usleep((useconds_t)sleep_ms * 1000);
if (ncm_cache_write(nt->w, nt->data + off, n) != NCM_OK) { nt->rc = NCM_ERR_IO; goto out; }
stream_src_note_written(nt->src, n);
off += n;
chunk_no++;
}
nt->rc = (off >= nt->size) ? NCM_OK : NCM_ERR_NET; /* cut=断流 */
out:
stream_src_finish(nt->src, nt->rc == NCM_OK ? 0 : nt->rc);
return NULL;
}
/* ---- 整文件离线解码（金标准 PCM） ---- */
static int decode_offline(const char *path, pcm_buf_t *pcm, int *rate, int *ch, int *bits,
int64_t *frames)
{
ncm_decoder_t *dec = NULL;
if (ncm_dec_open(&dec, path, rate, ch, bits, NULL) != 0) return -1;
static unsigned char buf[4096 * 2 * 4];
int64_t fr, total = 0;
while ((fr = ncm_dec_read(dec, buf, 4096)) > 0) {
pcm_put(pcm, buf, (size_t)fr * (size_t)(*ch) * (size_t)(*bits) / 8);
total += fr;
}
ncm_dec_close(dec);
if (frames) *frames = total;
return 0;
}
/* ---- 单条用例 ---- */
enum { SC_NORMAL = 0, SC_SEEK_DL, SC_SEEK_WAIT, SC_CUT, SC_FLAKY };
typedef struct {
pcm_buf_t pcm;
int64_t frames; /* 实际解码输出帧 */
int64_t frames_at_seek; /* seek 时已解码帧（非 seek 用例=0） */
int64_t seek_tgt_frames; /* seek 目标帧（非 seek 用例=0） */
int rate, ch, bits;
double first_sound_s; /* 网线程启动 → 首块 PCM */
int underruns;
uint64_t wait_ms;
double wall_s;
int open_ok;
} case_result_t;
static int run_case(const char *tag, const unsigned char *data, size_t size,
const char *ext, uint64_t rate_Bps, int jitter_ms, double cut_frac, int flaky,
int scenario, int64_t golden_total_frames, case_result_t *res)
{
memset(res, 0, sizeof *res);
char dir[] = "/tmp/ncm_stream_sim_XXXXXX";
if (!mkdtemp(dir)) { printf(" FAIL mkdtemp\n"); return -1; }
char cdir[600];
snprintf(cdir, sizeof cdir, "%s/cache", dir);
ncm_cache_t cache;
ncm_cache_init(&cache, cdir);
char key[32];
static int case_no = 0;
snprintf(key, sizeof key, "sim%d", case_no++);
ncm_cache_writer_t *w = NULL;
if (ncm_cache_open(&cache, key, ext, &w) != NCM_OK) { printf(" FAIL cache open\n"); return -1; }
stream_src_t *src = NULL;
if (stream_src_open_stream(&src, ncm_cache_writer_tmp_path(w)) != 0) {
printf(" FAIL stream open\n"); return -1;
}
net_t nt = { data, size, rate_Bps, jitter_ms, cut_frac, flaky, src, w, NCM_OK };
pthread_t nth;
double t0 = now_s();
if (pthread_create(&nth, NULL, net_thread, &nt) != 0) { printf(" FAIL pthread\n"); return -1; }
/* 预缓冲 ≥128KB（同 player_manager 门槛） */
double wd_t0 = now_s();
int wr;
while ((wr = stream_src_wait(src, 128 * 1024, 100)) == 0) {
if (now_s() - wd_t0 > 120) { printf(" FAIL prebuffer watchdog (deadlock?)\n"); g_fail = 1; _exit(1); }
}
if (stream_src_failed(src) && stream_src_written(src) < 128 * 1024) {
/* 首开声前失败（written < 预缓冲门槛）。已下过门槛的断流
*（如 cut40@10MB/s：finish 与预缓冲满足的竞态）照常放行，播到截断点（F5） */
printf(" FAIL download failed before prebuffer\n");
pthread_join(nth, NULL);
ncm_cache_abort(w); stream_src_close(src);
return -1;
}
ncm_decoder_t *dec = NULL;
int rate = 0, ch = 0, bits = 0;
if (ncm_dec_open_src(&dec, src, &rate, &ch, &bits, NULL) != 0) {
printf(" FAIL dec open\n");
pthread_join(nth, NULL);
ncm_cache_abort(w); stream_src_close(src);
return -1;
}
res->open_ok = 1;
res->rate = rate; res->ch = ch; res->bits = bits;
if (audio_out_open(rate, ch, bits) != 0) { printf(" FAIL audio open\n"); g_fail = 1; _exit(1); }
int64_t dur_ms = (golden_total_frames > 0 && rate > 0) ? golden_total_frames * 1000 / rate : 0;
static unsigned char pcm[4096 * 2 * 4];
int64_t decoded = 0; /* 实际解码输出帧（seek 断言口径） */
int seek_done = 0;
double first_sound = -1;
for (;;) {
if (now_s() - t0 > 150) { printf(" FAIL case watchdog (deadlock?)\n"); g_fail = 1; _exit(1); }
int64_t fr = ncm_dec_read(dec, pcm, 4096);
if (fr == 0) break;
if (first_sound < 0) first_sound = now_s() - t0;
if (audio_out_write(pcm, (int)fr) != (int)fr) { printf(" FAIL audio write\n"); g_fail = 1; _exit(1); }
pcm_put(&res->pcm, pcm, (size_t)fr * (size_t)ch * (size_t)bits / 8);
decoded += fr;
/* 实时步调（模拟 audio_out 背压节拍器，慢网才会真 underrun） */
if (rate > 0) usleep((useconds_t)(fr * 1000000 / rate));
/* seek 用例：播 ~1s 后 seek */
if (!seek_done && dur_ms > 0 && rate > 0 && decoded * 1000 / rate >= 1000) {
seek_done = 1;
int64_t tgt = 0;
if (scenario == SC_SEEK_DL) tgt = dur_ms / 4; /* 25%：预缓冲内，必已下载 */
else if (scenario == SC_SEEK_WAIT) tgt = dur_ms * 9 / 10; /* 90%：慢网未下载区，等待 */
if (tgt > 0) {
res->frames_at_seek = decoded;
res->seek_tgt_frames = tgt * rate / 1000;
ncm_dec_seek_ms(dec, tgt, (int64_t)size, dur_ms);
}
}
}
res->first_sound_s = first_sound;
res->frames = decoded;
stream_src_stats(src, &res->underruns, &res->wait_ms);
res->wall_s = now_s() - t0;
audio_out_close();
ncm_dec_close(dec);
pthread_join(nth, NULL);
stream_src_abort(src); /* 已完成则无副作用 */
/* commit/abort + 完整下载的落盘校验（缓存文件与源逐字节一致） */
if (nt.rc == NCM_OK) {
if (ncm_cache_commit(w) != 0) { printf(" FAIL commit\n"); g_fail = 1; }
else {
char fp[700];
if (ncm_cache_path(&cache, key, ext, fp, sizeof fp) == NCM_OK) {
FILE *f = fopen(fp, "rb");
if (!f) { printf(" FAIL committed file missing\n"); g_fail = 1; }
else {
unsigned char *got = (unsigned char *)malloc(size);
size_t rn = fread(got, 1, size, f);
int extra = fgetc(f);
fclose(f);
if (rn != size || extra != EOF || memcmp(got, data, size) != 0) {
printf(" FAIL committed bytes mismatch (rn=%zu size=%zu)\n", rn, size);
g_fail = 1;
}
free(got);
}
}
}
} else {
ncm_cache_abort(w);
}
stream_src_close(src);
printf(" [%s] wall=%.2fs first_sound=%.2fs frames=%lld underruns=%d wait=%llums\n",
tag, res->wall_s, res->first_sound_s, (long long)res->frames,
res->underruns, (unsigned long long)res->wait_ms);
return 0;
}
int main(int argc, char **argv)
{
(void)argc;
const char *mp3 = (argc > 1) ? argv[1] : "vendor/minimp3/vectors/performance/MIPSTest.mp3";
setenv("NCM_AUDIO_SINK", "null", 1);
/* 源文件入内存 */
FILE *f = fopen(mp3, "rb");
if (!f) { fprintf(stderr, "open %s failed\n", mp3); return 1; }
fseek(f, 0, SEEK_END); long fsz = ftell(f); fseek(f, 0, SEEK_SET);
unsigned char *data = (unsigned char *)malloc((size_t)fsz);
if (!data || fread(data, 1, (size_t)fsz, f) != (size_t)fsz) { fprintf(stderr, "read failed\n"); return 1; }
fclose(f);
size_t size = (size_t)fsz;
printf("src %s: %zu bytes\n", mp3, size);
/* 金标准：整首离线解码（同样走 cb 路径——ncm_dec_open 内部也是静态 stream_src） */
pcm_buf_t golden = {0};
int grate, gch, gbits;
int64_t gframes;
if (decode_offline(mp3, &golden, &grate, &gch, &gbits, &gframes) != 0) {
fprintf(stderr, "golden decode failed\n"); return 1;
}
printf("golden: %dHz x%d %dbit frames=%lld pcm=%zu bytes\n",
grate, gch, gbits, (long long)gframes, golden.n);
/* 40% 前缀金标准（断流用例比对到截断点） */
char prefix[] = "/tmp/ncm_stream_prefix_XXXXXX";
int pfd = mkstemp(prefix);
if (pfd < 0) return 1;
size_t cut_sz = size * 2 / 5;
if (write(pfd, data, cut_sz) != (ssize_t)cut_sz) { fprintf(stderr, "prefix write\n"); return 1; }
close(pfd);
pcm_buf_t golden_cut = {0};
int t1, t2, t3;
if (decode_offline(prefix, &golden_cut, &t1, &t2, &t3, NULL) != 0) {
fprintf(stderr, "golden prefix decode failed\n"); return 1;
}
unlink(prefix);
printf("golden-40%%: pcm=%zu bytes\n", golden_cut.n);
struct { const char *name; uint64_t Bps; } rates[] = {
{ "10MB/s", 10485760u },
{ "400kbps", 50000u },
{ "160kbps", 20000u },
};
case_result_t r;
int flaky_ur_total = 0; /* 断续网 underrun 跨速率聚合（见 flaky 用例注释） */
for (int ri = 0; ri < 3; ri++) {
const char *rn = rates[ri].name;
uint64_t Bps = rates[ri].Bps;
char tag[64];
snprintf(tag, sizeof tag, "normal@%s", rn);
printf("== CASE %s ==\n", tag);
if (run_case(tag, data, size, "mp3", Bps, 0, 0, 0, SC_NORMAL, gframes, &r) == 0) {
CHECK(r.pcm.n == golden.n && memcmp(r.pcm.b, golden.b, golden.n) == 0,
"PCM 与整首离线解码逐字节一致 (%zu/%zu)", r.pcm.n, golden.n);
if (Bps >= 1000000u)
CHECK(r.first_sound_s >= 0 && r.first_sound_s < 2.0,
"首开声 %.2fs < 2s", r.first_sound_s);
else if (Bps >= 50000u)
/* 物理下限：预缓冲 128KB / 50KB/s = 2.62s（F3 红线：MINIMP3_IO_SIZE 强制），
* <2s@400kbps 与该红线冲突——按可达阈值断言并在 REPORT §21 记录。 */
CHECK(r.first_sound_s >= 0 && r.first_sound_s < 4.0,
"首开声 %.2fs < 4s (128KB/50KBps=2.62s 下限)", r.first_sound_s);
if (Bps <= 20000u)
CHECK(r.underruns > 0, "慢网 underrun 统计 >0 (=%d)", r.underruns);
}
snprintf(tag, sizeof tag, "seek_dl@%s", rn);
printf("== CASE %s ==\n", tag);
if (run_case(tag, data, size, "mp3", Bps, 0, 0, 0, SC_SEEK_DL, gframes, &r) == 0) {
/* 期望 = seek 前已解码 + 目标之后剩余（字节近似 seek，±10% 容差） */
int64_t expect = r.frames_at_seek + (gframes - r.seek_tgt_frames);
double dev = expect > 0 ? (double)(r.frames - expect) / (double)expect : 1;
if (dev < 0) dev = -dev;
CHECK(dev < 0.10, "seek 已下载区后播完：decoded=%lld ≈ %lld (dev=%.1f%%)",
(long long)r.frames, (long long)expect, dev * 100);
}
snprintf(tag, sizeof tag, "seek_wait@%s", rn);
printf("== CASE %s ==\n", tag);
if (run_case(tag, data, size, "mp3", Bps, 0, 0, 0, SC_SEEK_WAIT, gframes, &r) == 0) {
int64_t expect = r.frames_at_seek + (gframes - r.seek_tgt_frames);
double dev = expect > 0 ? (double)(r.frames - expect) / (double)expect : 1;
if (dev < 0) dev = -dev;
CHECK(dev < 0.15, "seek 未下载区等待后播完：decoded=%lld ≈ %lld (dev=%.1f%%)",
(long long)r.frames, (long long)expect, dev * 100);
}
snprintf(tag, sizeof tag, "cut40@%s", rn);
printf("== CASE %s ==\n", tag);
if (run_case(tag, data, size, "mp3", Bps, 0, 0.4, 0, SC_CUT, gframes, &r) == 0) {
CHECK(r.pcm.n == golden_cut.n && memcmp(r.pcm.b, golden_cut.b, golden_cut.n) == 0,
"断流：PCM 与 40%% 前缀离线解码逐字节一致 (%zu/%zu)", r.pcm.n, golden_cut.n);
}
snprintf(tag, sizeof tag, "flaky@%s", rn);
printf("== CASE %s ==\n", tag);
if (run_case(tag, data, size, "mp3", Bps, 15, 0, 1, SC_FLAKY, gframes, &r) == 0) {
CHECK(r.pcm.n == golden.n && memcmp(r.pcm.b, golden.b, golden.n) == 0,
"断续网：PCM 逐字节一致 (%zu/%zu)", r.pcm.n, golden.n);
/* 单次断续网是否打空缓冲取决于解码速度（qemu 远慢于宿主→缓冲消耗慢→可能 0 次），
* 属时序非确定性——不做单用例硬断言，跨速率聚合见循环后。 */
flaky_ur_total += r.underruns;
}
}
CHECK(flaky_ur_total > 0, "断续网跨速率 underrun 聚合 >0 (=%d)", flaky_ur_total);
/* flac 边下边播兼容（dr_flac 回调路径接到 stream_src） */
const char *flac = "out/test-vectors/sweep_44k1_16.flac";
FILE *ff = fopen(flac, "rb");
if (!ff) {
printf("== CASE flac_stream == SKIP（%s 不存在；§19.9 可一键重造）\n", flac);
} else {
fseek(ff, 0, SEEK_END); long fz = ftell(ff); fseek(ff, 0, SEEK_SET);
unsigned char *fdata = (unsigned char *)malloc((size_t)fz);
if (!fdata || fread(fdata, 1, (size_t)fz, ff) != (size_t)fz) { fprintf(stderr, "flac read\n"); return 1; }
fclose(ff);
pcm_buf_t fg = {0};
int64_t fgframes;
if (decode_offline(flac, &fg, &t1, &t2, &t3, &fgframes) != 0) { fprintf(stderr, "flac golden\n"); return 1; }
printf("== CASE flac_stream@400kbps ==\n");
if (run_case("flac_stream@400kbps", fdata, (size_t)fz, "flac",
50000u, 10, 0, 1, SC_NORMAL, fgframes, &r) == 0) {
CHECK(r.rate == 44100 && r.bits == 16, "flac 参数 44.1k/16bit (=%d/%d)", r.rate, r.bits);
CHECK(r.pcm.n == fg.n && memcmp(r.pcm.b, fg.b, fg.n) == 0,
"flac 边下边播 PCM 逐字节一致 (%zu/%zu)", r.pcm.n, fg.n);
}
free(fdata);
free(fg.b);
}
free(golden.b); free(golden_cut.b); free(data);
printf(g_fail ? "== STREAM SIM: FAIL ==\n" : "== STREAM SIM: ALL PASS ==\n");
return g_fail;
}
patch_v2/ncm_app/build_ncm.sh
+1 -1
View File
@@ -21,7 +21,7 @@ APP="app/app.c app/ui/login.c app/ui/home.c app/ui/playlist.c app/ui/player.c \
app/ui/settings.c app/ui/search.c app/ui/ncm_colors.c app/ui/chrome.c \ app/ui/settings.c app/ui/search.c app/ui/ncm_colors.c app/ui/chrome.c \
app/logic/appstate.c app/logic/lyric.c app/logic/songmeta.c \ app/logic/appstate.c app/logic/lyric.c app/logic/songmeta.c \
app/logic/cover.c app/logic/account.c app/play/player_manager.c app/play/audio_out.c \ app/logic/cover.c app/logic/account.c app/play/player_manager.c app/play/audio_out.c \
app/play/ipc_media.c app/play/decoder.c app/play/minimp3_impl.c" app/play/ipc_media.c app/play/decoder.c app/play/stream_src.c app/play/minimp3_impl.c"
echo "==> app+core (strict)" echo "==> app+core (strict)"
for f in $APP $CORE; do for f in $APP $CORE; do
patch_v2/ncm_app/build_ncm_host.sh
+1 -1
View File
@@ -33,7 +33,7 @@ APP_SRC="app/ui/login.c app/ui/home.c app/ui/playlist.c app/ui/player.c \
app/ui/settings.c app/ui/search.c app/ui/ncm_colors.c app/ui/chrome.c \ app/ui/settings.c app/ui/search.c app/ui/ncm_colors.c app/ui/chrome.c \
app/logic/appstate.c app/logic/lyric.c app/logic/songmeta.c \ app/logic/appstate.c app/logic/lyric.c app/logic/songmeta.c \
app/logic/cover.c app/logic/account.c app/play/player_manager.c app/play/audio_out.c \ app/logic/cover.c app/logic/account.c app/play/player_manager.c app/play/audio_out.c \
app/play/ipc_media.c app/play/decoder.c app/play/minimp3_impl.c" app/play/ipc_media.c app/play/decoder.c app/play/stream_src.c app/play/minimp3_impl.c"
for f in $APP_SRC; do for f in $APP_SRC; do
b=$(basename "$f" .c) b=$(basename "$f" .c)
$CC_HOST -O2 -c -DMEOW_UI_HOST_TEST -DJSMN_HEADER $INC "$f" -o "$OUT/host/$b.o" || { echo "app $f FAILED"; exit 1; } $CC_HOST -O2 -c -DMEOW_UI_HOST_TEST -DJSMN_HEADER $INC "$f" -o "$OUT/host/$b.o" || { echo "app $f FAILED"; exit 1; }
patch_v2/ncm_app/core/ncm_cache.c
+29 -12
View File
@@ -4,6 +4,8 @@
#include "ncm_store.h" #include "ncm_store.h"
#include <dirent.h> #include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h> #include <limits.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@@ -95,7 +97,7 @@ int ncm_cache_lookup(const ncm_cache_t *c, const char *id, const char *ext,
struct ncm_cache_writer { struct ncm_cache_writer {
char final_path[NCM_CACHE_DIR_MAX + 64]; char final_path[NCM_CACHE_DIR_MAX + 64];
char tmp_path[NCM_CACHE_DIR_MAX + 80]; char tmp_path[NCM_CACHE_DIR_MAX + 80];
FILE *fp; int fd; /* 写 fd（write(2) 直写，§21：不走 stdio 缓冲，字节对读端即时可见） */
uint64_t nwritten; uint64_t nwritten;
int failed; int failed;
}; };
@@ -105,23 +107,39 @@ int ncm_cache_open(const ncm_cache_t *c, const char *id, const char *ext,
if (!c || !id || !w_out) return NCM_ERR_ARG; if (!c || !id || !w_out) return NCM_ERR_ARG;
ncm_cache_writer_t *w = (ncm_cache_writer_t *)calloc(1, sizeof *w); ncm_cache_writer_t *w = (ncm_cache_writer_t *)calloc(1, sizeof *w);
if (!w) return NCM_ERR_OOM; if (!w) return NCM_ERR_OOM;
w->fd = -1;
if (ncm_cache_path(c, id, ext, w->final_path, sizeof w->final_path) != 0) { if (ncm_cache_path(c, id, ext, w->final_path, sizeof w->final_path) != 0) {
free(w); return NCM_ERR_FULL; free(w); return NCM_ERR_FULL;
} }
snprintf(w->tmp_path, sizeof w->tmp_path, "%s.tmp", w->final_path); snprintf(w->tmp_path, sizeof w->tmp_path, "%s.tmp", w->final_path);
w->fp = fopen(w->tmp_path, "wb"); w->fd = open(w->tmp_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (!w->fp) { free(w); return NCM_ERR_IO; } if (w->fd < 0) { free(w); return NCM_ERR_IO; }
*w_out = w; *w_out = w;
return NCM_OK; return NCM_OK;
} }
/* 写端用 write(2) 直写（§21）：旧版 fwrite 有 4-8KB stdio 缓冲，字节对边下边播的
* pread 读端不可见；直写后每块落盘即推进可读边界。无用户态缓冲，fsync 只在 commit 一次。 */
int ncm_cache_write(ncm_cache_writer_t *w, const unsigned char *data, size_t len) { int ncm_cache_write(ncm_cache_writer_t *w, const unsigned char *data, size_t len) {
if (!w || !w->fp || w->failed) return NCM_ERR_ARG; if (!w || w->fd < 0 || w->failed) return NCM_ERR_ARG;
if (fwrite(data, 1, len, w->fp) != len) { w->failed = 1; return NCM_ERR_IO; } size_t off = 0;
while (off < len) {
ssize_t n = write(w->fd, data + off, len - off);
if (n < 0) {
if (errno == EINTR) continue;
w->failed = 1; return NCM_ERR_IO;
}
off += (size_t)n;
}
w->nwritten += len; w->nwritten += len;
return NCM_OK; return NCM_OK;
} }
/* 写者 .tmp 路径（边下边播：解码侧用它开只读 fd 建 stream_src；只读，勿改）。 */
const char *ncm_cache_writer_tmp_path(const ncm_cache_writer_t *w) {
return w ? w->tmp_path : "";
}
static int cmp_mtime_asc(const void *a, const void *b) { static int cmp_mtime_asc(const void *a, const void *b) {
const entry_t *x = (const entry_t *)a, *y = (const entry_t *)b; const entry_t *x = (const entry_t *)a, *y = (const entry_t *)b;
if (x->mtime < y->mtime) return -1; if (x->mtime < y->mtime) return -1;
@@ -169,15 +187,14 @@ int ncm_cache_evict(const ncm_cache_t *c) {
int ncm_cache_commit(ncm_cache_writer_t *w) { int ncm_cache_commit(ncm_cache_writer_t *w) {
if (!w) return NCM_ERR_ARG; if (!w) return NCM_ERR_ARG;
int rc = NCM_OK; int rc = NCM_OK;
if (w->failed || !w->fp) rc = NCM_ERR_IO; if (w->failed || w->fd < 0) rc = NCM_ERR_IO;
else if (fflush(w->fp) != 0) rc = NCM_ERR_IO; else if (fsync(w->fd) != 0) rc = NCM_ERR_IO;
else if (fsync(fileno(w->fp)) != 0) rc = NCM_ERR_IO; else if (close(w->fd) != 0) { w->fd = -1; rc = NCM_ERR_IO; }
else if (fclose(w->fp) != 0) rc = NCM_ERR_IO;
else { else {
w->fp = NULL; w->fd = -1;
if (rename(w->tmp_path, w->final_path) != 0) { unlink(w->tmp_path); rc = NCM_ERR_IO; } if (rename(w->tmp_path, w->final_path) != 0) { unlink(w->tmp_path); rc = NCM_ERR_IO; }
} }
if (w->fp) { fclose(w->fp); w->fp = NULL; } if (w->fd >= 0) { close(w->fd); w->fd = -1; }
if (rc == NCM_OK) { if (rc == NCM_OK) {
/* 刷新 mtime（= 最近访问）*/ /* 刷新 mtime（= 最近访问）*/
utime(w->final_path, NULL); utime(w->final_path, NULL);
@@ -188,7 +205,7 @@ int ncm_cache_commit(ncm_cache_writer_t *w) {
int ncm_cache_abort(ncm_cache_writer_t *w) { int ncm_cache_abort(ncm_cache_writer_t *w) {
if (!w) return NCM_ERR_ARG; if (!w) return NCM_ERR_ARG;
if (w->fp) { fclose(w->fp); w->fp = NULL; } if (w->fd >= 0) { close(w->fd); w->fd = -1; }
unlink(w->tmp_path); unlink(w->tmp_path);
free(w); free(w);
return NCM_OK; return NCM_OK;
patch_v2/ncm_app/core/ncm_cache.h
+4 -1
View File
@@ -43,13 +43,16 @@ int ncm_cache_path(const ncm_cache_t *c, const char *id, const char *ext,
int ncm_cache_lookup(const ncm_cache_t *c, const char *id, const char *ext, int ncm_cache_lookup(const ncm_cache_t *c, const char *id, const char *ext,
char *out, size_t out_sz); char *out, size_t out_sz);
/* 流式写入句柄：open 建 temp；write 累积；commit 落盘+刷新LRU+触发淘汰；abort 丢弃。 */ /* 流式写入句柄：open 建 temp；write 累积（write(2) 直写无 stdio 缓冲，§21 边下边播
* 读端即时可见）；commit 落盘+刷新LRU+触发淘汰；abort 丢弃。 */
typedef struct ncm_cache_writer ncm_cache_writer_t; typedef struct ncm_cache_writer ncm_cache_writer_t;
int ncm_cache_open(const ncm_cache_t *c, const char *id, const char *ext, int ncm_cache_open(const ncm_cache_t *c, const char *id, const char *ext,
ncm_cache_writer_t **w); ncm_cache_writer_t **w);
int ncm_cache_write(ncm_cache_writer_t *w, const unsigned char *data, size_t len); int ncm_cache_write(ncm_cache_writer_t *w, const unsigned char *data, size_t len);
int ncm_cache_commit(ncm_cache_writer_t *w); /* win; 返回 0=成功 */ int ncm_cache_commit(ncm_cache_writer_t *w); /* win; 返回 0=成功 */
int ncm_cache_abort(ncm_cache_writer_t *w); int ncm_cache_abort(ncm_cache_writer_t *w);
/* 写者 .tmp 路径（只读）：边下边播解码侧用它开只读 fd 建 stream_src。 */
const char *ncm_cache_writer_tmp_path(const ncm_cache_writer_t *w);
/* 当前缓存总字节（扫描目录） */ /* 当前缓存总字节（扫描目录） */
uint64_t ncm_cache_total_bytes(const ncm_cache_t *c); uint64_t ncm_cache_total_bytes(const ncm_cache_t *c);
patch_v2/ncm_app/core/ncm_http.c
+12 -2
View File
@@ -328,8 +328,15 @@ static int http_run(const ncm_http_req_t *req, sink_t *sink, ncm_http_resp_t *re
if (parse_url(req->url, &url) != 0) return NCM_ERR_ARG; if (parse_url(req->url, &url) != 0) return NCM_ERR_ARG;
if (strcmp(url.scheme, "https") != 0 && strcmp(url.scheme, "http") != 0) return NCM_ERR_ARG; if (strcmp(url.scheme, "https") != 0 && strcmp(url.scheme, "http") != 0) return NCM_ERR_ARG;
/* 超时语义（P2 改造，REPORT §21）：连接/握手/请求发送/响应头 保留绝对总上限 15s；
* 响应体阶段改**空闲超时**——每成功读到字节即顺延，15s 无字节才判超时。
* 旧实现 timeout_ms=30000 是全程绝对 deadline，整首下载超 30s 必 abort（慢网暗雷）；
* 边下边播下载持续整曲时长，必须先改为空闲语义。 */
uint32_t tmo = req->timeout_ms ? req->timeout_ms : 15000; uint32_t tmo = req->timeout_ms ? req->timeout_ms : 15000;
if (tmo > 15000) tmo = 15000; /* 绝对段统一钳到 15s */
int64_t deadline = ncm_monotonic_ms() + (int64_t)tmo; /* 截止时刻用单调钟，避免 NTP 校时跳变 */ int64_t deadline = ncm_monotonic_ms() + (int64_t)tmo; /* 截止时刻用单调钟，避免 NTP 校时跳变 */
int64_t body_deadline = 0; /* hdr_done 后启用：每收字节顺延 15s */
#define NCM_HTTP_BODY_IDLE_MS 15000
mbedtls_net_context net; mbedtls_net_context net;
@@ -467,10 +474,13 @@ static int http_run(const ncm_http_req_t *req, sink_t *sink, ncm_http_resp_t *re
if (body_feed(&bst, tmp, n, sink) < 0) { ret = NCM_ERR_JSON; goto done; } if (body_feed(&bst, tmp, n, sink) < 0) { ret = NCM_ERR_JSON; goto done; }
} }
if (sink->overflow || bst.st == BS_DONE) break; if (sink->overflow || bst.st == BS_DONE) break;
if (hdr_done) body_deadline = ncm_monotonic_ms() + NCM_HTTP_BODY_IDLE_MS; /* 有字节→顺延（P2 空闲超时） */
} else if (ret == MBEDTLS_ERR_SSL_WANT_READ) { } else if (ret == MBEDTLS_ERR_SSL_WANT_READ) {
if ((ret = wait_io(&net, MBEDTLS_NET_POLL_READ, deadline)) != 0) { if (ret==MBEDTLS_ERR_SSL_TIMEOUT) ret=NCM_ERR_TIMEOUT; goto done; } int64_t dl = hdr_done ? body_deadline : deadline; /* 响应体=空闲超时；此前=绝对上限 */
if ((ret = wait_io(&net, MBEDTLS_NET_POLL_READ, dl)) != 0) { if (ret==MBEDTLS_ERR_SSL_TIMEOUT) ret=NCM_ERR_TIMEOUT; goto done; }
} else if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) { } else if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) {
if ((ret = wait_io(&net, MBEDTLS_NET_POLL_WRITE, deadline)) != 0) goto done; int64_t dl = hdr_done ? body_deadline : deadline;
if ((ret = wait_io(&net, MBEDTLS_NET_POLL_WRITE, dl)) != 0) goto done;
} else if (ret == 0 || ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) { } else if (ret == 0 || ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) {
break; /* 对端关闭 */ break; /* 对端关闭 */
} else { } else {
patch_v2/ncm_app/core/ncm_http.h
+2 -1
View File
@@ -36,7 +36,8 @@ typedef struct ncm_http_req {
const char *body; /* 表单体，可为 NULL */ const char *body; /* 表单体，可为 NULL */
size_t body_len; /* 0 表示 strlen(body) */ size_t body_len; /* 0 表示 strlen(body) */
const char *extra_hdrs; /* 附加头（完整 CRLF 行），可为 NULL */ const char *extra_hdrs; /* 附加头（完整 CRLF 行），可为 NULL */
uint32_t timeout_ms; /* 整体超时(ms)；0=默认 15000 */ uint32_t timeout_ms; /* 连接/握手/请求/响应头的绝对总上限(ms，>15s 钳到 15s)；0=默认 15000。
* 响应体阶段不受此限：改空闲超时，每收到字节顺延，15s 无字节判超时（P2，§21）。 */
int verify_ca; /* 1=校验CA，0=跳过(仅调试) */ int verify_ca; /* 1=校验CA，0=跳过(仅调试) */
const char *ca_path; /* 指定 CA bundle 路径；NULL=系统默认 */ const char *ca_path; /* 指定 CA bundle 路径；NULL=系统默认 */
} ncm_http_req_t; } ncm_http_req_t;
patch_v2/ncm_app/ncm
BIN
View File
Binary file not shown.
patch_v2/ncm_app/ncm_host
BIN
View File
Binary file not shown.
patch_v2/ncm_app/test/test_ncm_core_host
BIN
View File
Binary file not shown.