diff --git a/patch_v2/ncm_app/REPORT.md b/patch_v2/ncm_app/REPORT.md index 7c2ab78..87014fd 100644 --- a/patch_v2/ncm_app/REPORT.md +++ b/patch_v2/ncm_app/REPORT.md @@ -1876,3 +1876,115 @@ ac5b29c40488f34e9220b14105bf63c2 build_ncm_host.sh # +account.c - vipType（login_status profile.vipType 10/11 口径）未用——BIZ_NOTES §1.2 标注非代码证据， 以 vip/info 双端点字段判定为准；真机若 vip/info 全挂可再加 profile.vipType 兜底。 - 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 金标准不变。 diff --git a/patch_v2/ncm_app/app/ncm_app_internal.h b/patch_v2/ncm_app/app/ncm_app_internal.h index 1dce553..51eac8c 100644 --- a/patch_v2/ncm_app/app/ncm_app_internal.h +++ b/patch_v2/ncm_app/app/ncm_app_internal.h @@ -90,6 +90,10 @@ typedef struct ncm_play_run { int64_t dl_total; /* 本曲标称大小（song_url 返回；0=未知） */ int has_track; /* 当前是否有可播曲目（含 url 获取中） */ 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 保护）， * 之后播放/歌词/IPC/UI 全读快照而非窗口——窗口滑出当前播放曲也不影响播放。 */ ncm_song_t play_song; diff --git a/patch_v2/ncm_app/app/play/decoder.c b/patch_v2/ncm_app/app/play/decoder.c index 66b100b..5c46fef 100644 --- a/patch_v2/ncm_app/app/play/decoder.c +++ b/patch_v2/ncm_app/app/play/decoder.c @@ -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 后才保证有效， * 而调用方开 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 "minimp3_ex.h" @@ -11,6 +22,7 @@ #include #include #include +#include #define DEC_STASH_FRAMES 4096 /* open 预读上限（帧），与播放循环单块读同量级 */ @@ -18,11 +30,13 @@ enum { DEC_MP3 = 0, DEC_FLAC = 1 }; struct ncm_decoder { int kind; - char path[512]; + stream_src_t *src; /* 读端（ncm_dec_open 自建静态源时 src_owned=1） */ + int src_owned; int rate, ch, bits; int64_t total_frames; /* 0=未知 */ /* mp3 */ mp3dec_ex_t mp3; + mp3dec_io_t mp3_io; /* 生命周期须覆盖 mp3（minimp3 内部存指针） */ int16_t *stash; /* 预读样本（交织 s16），stash_n 个样本 */ size_t stash_n, stash_off; /* flac */ @@ -30,48 +44,74 @@ struct ncm_decoder { }; /* magic 探测：首 4 字节 "fLaC" → flac；其余（ID3 / 0xFF 帧同步 / 未知）→ mp3 - *（未知格式留给 minimp3 在 open 时报错，不在本层加第三种分支）。 */ -static int sniff_kind(const char *path) + *（未知格式留给 minimp3 在 open 时报错，不在本层加第三种分支）。 + * 流模式下 peek 读已落盘前缀（预缓冲门槛 ≥128KB 已满足，或 final 截断有多少读多少）。 */ +static int sniff_kind(stream_src_t *src) { unsigned char m[4] = {0}; - FILE *f = fopen(path, "rb"); - if (f) { size_t n = fread(m, 1, 4, f); fclose(f); if (n < 4) return DEC_MP3; } - if (m[0] == 'f' && m[1] == 'L' && m[2] == 'a' && m[3] == 'C') return DEC_FLAC; + size_t n = stream_src_peek(src, m, 4, 0); + if (n >= 4 && m[0] == 'f' && m[1] == 'L' && m[2] == 'a' && m[3] == 'C') return DEC_FLAC; return DEC_MP3; } -int ncm_dec_open(ncm_decoder_t **out, const char *path, - int *rate, int *ch, int *bits, int64_t *total_frames) +/* dr_flac 回调签名适配：seek 的 origin 是枚举、tell 用 drflac_int64(long long)， + * 与 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; - ncm_decoder_t *d = (ncm_decoder_t *)calloc(1, sizeof *d); - if (!d) return -1; - d->kind = sniff_kind(path); - snprintf(d->path, sizeof d->path, "%s", path); + return (drflac_bool32)stream_src_drflac_seek(ud, offset, (int)origin); +} +static drflac_bool32 dec_flac_tell(void *ud, drflac_int64 *cursor) +{ + 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) { - d->flac = drflac_open_file(path, NULL); - if (!d->flac) { free(d); return -1; } + d->flac = drflac_open(stream_src_drflac_read, dec_flac_seek, + dec_flac_tell, d->src, NULL); + if (!d->flac) return -1; d->rate = (int)d->flac->sampleRate; d->ch = (int)d->flac->channels; /* 位宽映射（AUDIOD §4 归一交给 SDK/audiod）：≤16 → S16；>16 → S32 满幅 */ d->bits = (d->flac->bitsPerSample <= 16) ? 16 : 32; d->total_frames = (int64_t)d->flac->totalPCMFrameCount; } 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->stash = (int16_t *)malloc(DEC_STASH_FRAMES * 2 * sizeof(int16_t)); - if (!d->stash) { mp3dec_ex_close(&d->mp3); free(d); return -1; } - /* 预读首块：填 dec.info（hz/channels）+ 预热 stash */ + if (!d->stash) { mp3dec_ex_close(&d->mp3); return -1; } + /* 预读首块：填 dec.info（hz/channels）+ 预热 stash。 + * 流模式下此处可能阻塞到下载推进（read_cb 阻塞语义），属预期。 */ size_t got = mp3dec_ex_read(&d->mp3, d->stash, DEC_STASH_FRAMES * 2); d->stash_n = got; d->rate = d->mp3.info.hz; d->ch = d->mp3.info.channels; 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; } + 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 只接 单/双声道 */ *out = d; @@ -82,6 +122,22 @@ int ncm_dec_open(ncm_decoder_t **out, const char *path, 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) { 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); return drflac_seek_to_pcm_frame(d->flac, frame) ? 0 : -1; } - /* mp3：关+重开（重建字节索引）再按字节近似 */ - mp3dec_ex_close(&d->mp3); - memset(&d->mp3, 0, sizeof d->mp3); - if (mp3dec_ex_open(&d->mp3, d->path, MP3D_SEEK_TO_BYTE) != 0) return -1; + /* mp3：MP3D_SEEK_TO_BYTE 下 seek 只是 offset=pos + io->seek(pos)（F4）， + * 无需索引、无需关重开；目标超已下载区时 read 自然阻塞等待。 */ d->stash_n = d->stash_off = 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)); @@ -131,6 +185,7 @@ void ncm_dec_close(ncm_decoder_t *d) if (!d) return; if (d->kind == DEC_FLAC) { if (d->flac) drflac_close(d->flac); } else { mp3dec_ex_close(&d->mp3); free(d->stash); } + if (d->src_owned) stream_src_close(d->src); free(d); } diff --git a/patch_v2/ncm_app/app/play/decoder.h b/patch_v2/ncm_app/app/play/decoder.h index ebfee4a..7df9ed8 100644 --- a/patch_v2/ncm_app/app/play/decoder.h +++ b/patch_v2/ncm_app/app/play/decoder.h @@ -8,6 +8,7 @@ #define NCM_DECODER_H #include +#include "stream_src.h" #ifdef __cplusplus extern "C" { @@ -15,14 +16,22 @@ extern "C" { typedef struct ncm_decoder ncm_decoder_t; -/* 打开并探测流参数：rate/ch/bits/total_frames 经指针回填实际值（mp3 恒 16bit； - * total_frames 0=未知）。返回 0=成功。 */ +/* 在 stream_src 上打开并探测流参数（边下边播/缓存命中统一入口，§21）： + * 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 *rate, int *ch, int *bits, int64_t *total_frames); /* 读最多 cap_frames 帧到 buf（交织，样本位宽=open 返回的 bits；cap 以帧计， * buf 容量须 ≥ cap_frames*ch*(bits/8)）。返回实际帧数，0=EOF。 */ 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); void ncm_dec_close(ncm_decoder_t *d); /* "mp3" / "flac"（日志/UI 用）。 */ diff --git a/patch_v2/ncm_app/app/play/player_manager.c b/patch_v2/ncm_app/app/play/player_manager.c index f0b673a..509df65 100644 --- a/patch_v2/ncm_app/app/play/player_manager.c +++ b/patch_v2/ncm_app/app/play/player_manager.c @@ -1,5 +1,5 @@ -/* play/player_manager.c — 播放线程：URL 获取(全档表逐级降级)→缓存(命中直接播/否则流式落盘)→ - * minimp3/dr_flac 解码→audio_out 直写。UI 不卡（网络+解码全在此线程）。 +/* play/player_manager.c — 播放线程：URL 获取(全档表逐级降级)→缓存(命中直接播/否则边下边播)→ + * minimp3/dr_flac 解码(stream_src 回调)→audio_out 直写。UI 不卡（网络+解码全在此线程）。 * * 模型：一个持久的播放线程。外层循环取「目标曲目」，run_song() 负责一首歌的 * 「下载(缓冲) → 解码 → 输出 → 结束/被指令打断」。暂停=冻结（停读停写停推 pos，状态置 PAUSED）； @@ -11,6 +11,12 @@ * 音频缓存键 = 歌曲ID+音质档位（用户定案 NCM_CACHE_DESIGN §2.5），旧无档位键温和兼容。 * §20：音质体系全量——用户档超会员权限不硬拒（钳顶后逐级降级，eff_level 回填供播放页 * 「已降级至 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 @@ -19,6 +25,7 @@ #include #include #include "decoder.h" +#include "stream_src.h" static pthread_t g_thr; static int g_thr_on; @@ -92,6 +99,9 @@ void player_manager_play(int song_idx) g_play.dl_total = 0; g_play.seq++; 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); } @@ -127,6 +137,9 @@ void player_manager_next(int dir) g_play.dl_total = 0; g_play.seq++; 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); } @@ -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); g_play.dl_done += (int64_t)len; 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__."。 @@ -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)); } -/* 得到本地音频路径 + 文件大小。命中缓存直接返回；否则 URL 降级 + 流式落缓存。 - * 返回 NCM_OK 或负错误码。s 为播放曲快照（run_song 物化，与窗口解耦 §17）。 +/* 切歌竞态护栏（§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; +} + +/* 得到本地音频源（§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 权限/会员： * - fee 门禁（BIZ_NOTES §3 社区口径）：fee∈{1,4}（VIP 才能听/付费专）且当前非会员 * → 直接 NCM_ERR_VIP，**不发 song_url 请求**（省一次请求，防风控）；fee=0/8 放行 * （8=免费听低音质，播放允许）。本地缓存命中优先于门禁（缓存可播不拦）。 * - VIP 档上限：用户档超会员权限不硬拒，播放时先钳到会员允许的最高档再逐级降级 * （免去注定空 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; char key[64]; 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 || ncm_cache_lookup(&g_st.ctx.cache, key, "mp3", path, psz) == NCM_OK) { - struct stat st; - if (stat(path, &st) == 0) { - *bytes = (int64_t)st.st_size; - /* 生效档推断（缓存键=用户档，降级产物归用户档键，无法精确还原）： - * 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; - } + hit = 1; + } else if (ncm_cache_lookup(&g_st.ctx.cache, id, "mp3", path, psz) == NCM_OK) { + /* 旧键温和兼容（§19 前存量：无档位后缀的 song_[.]mp3，含历史双点名）： + * 命中即播，不主动改名/删除，由 LRU 自然淘汰。 */ + hit = 2; } - /* 旧键温和兼容（§19 前存量：无档位后缀的 song_[.]mp3，含历史双点名）：命中即播， - * 不主动改名/删除，由 LRU 自然淘汰。 */ - if (ncm_cache_lookup(&g_st.ctx.cache, id, "mp3", path, psz) == NCM_OK) { + if (hit) { struct stat st; - if (stat(path, &st) == 0) { - *bytes = (int64_t)st.st_size; - pthread_mutex_lock(&g_play.mu); - g_play.eff_level = (g_level > NCM_LEVEL_EXHIGH) ? NCM_LEVEL_EXHIGH : g_level; - pthread_mutex_unlock(&g_play.mu); - return NCM_OK; - } + if (stat(path, &st) != 0) return NCM_ERR_NOENT; + if (stream_src_open_static(&ss->src, path, (uint64_t)st.st_size) != 0) + return NCM_ERR_IO; + ss->total = (int64_t)st.st_size; + *bytes = ss->total; + /* 生效档推断（缓存键=用户档，降级产物归用户档键，无法精确还原）： + * 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。 @@ -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; pthread_mutex_lock(&g_play.mu); 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); /* 落盘扩展名：type 权威；type 缺失时看 url 扩展名，默认 mp3 */ const char *ext = "mp3"; if (ncm_streq(u.type, "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，无在途文件被误删风险） */ ncm_cache_evict(&g_st.ctx.cache); - /* 流式下载到缓存 temp → commit（稳妥者：先落盘再播） */ - ncm_cache_writer_t *w = NULL; - rc = ncm_cache_open(&g_st.ctx.cache, key, ext, &w); + /* 边下边播（§21）：下载线程写 .tmp（write(2) 直写），解码线程 pread 同一文件 */ + rc = ncm_cache_open(&g_st.ctx.cache, key, ext, &ss->w); if (rc != NCM_OK) return rc; - - ncm_http_req_t req; - memset(&req, 0, sizeof req); - req.url = u.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 = 30000; - - ncm_http_resp_t resp; + if (stream_src_open_stream(&ss->src, ncm_cache_writer_tmp_path(ss->w)) != 0) { + ncm_cache_abort(ss->w); ss->w = NULL; + return NCM_ERR_IO; + } + ncm_strlcpy(path, ncm_cache_writer_tmp_path(ss->w), psz); /* 日志用 */ + ss->total = (u.size > 0) ? u.size : 0; /* 上限：Hi-Res flac 单曲可达数百 MB（192k/24bit 5min ≈345MB），flac 上限 1GB；mp3 维持 64MB。 * size 可信时按 size 限幅（防超额），未知按格式默认上限。 */ 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; - rc = ncm_http_download(&req, download_cb, w, maxb, &resp); - if (rc != NCM_OK || resp.status != 200) { - ncm_cache_abort(w); - return (rc != NCM_OK) ? rc : NCM_ERR_HTTP; + ss->maxb = (u.size > 0 && (uint64_t)u.size < cap) ? (size_t)u.size : cap; + ncm_strlcpy(ss->url, u.url, sizeof ss->url); + if (pthread_create(&ss->dl_thr, NULL, dl_thread, ss) != 0) { + ncm_cache_abort(ss->w); ss->w = NULL; + stream_src_close(ss->src); ss->src = NULL; + return NCM_ERR_IO; } - rc = ncm_cache_commit(w); - if (rc != 0) return rc; - /* 写后检查：新落盘可能把池推过上限 → 再按 LRU 淘汰最旧（刚写的 mtime 最新，存活） */ - ncm_cache_evict(&g_st.ctx.cache); - if (ncm_cache_lookup(&g_st.ctx.cache, key, ext, path, psz) != NCM_OK) - return NCM_ERR_NOENT; - struct stat st; - if (stat(path, &st) == 0) *bytes = (int64_t)st.st_size; + ss->dl_thr_on = 1; + + /* 预缓冲：≥128KB（minimp3 强制门槛，F3）才放行 open_cb；final/failed 提前出。 + * still_current 护栏覆盖本阻塞点：等待期间切歌/停止 → 中止下载静默放弃。 */ + for (;;) { + int wr = stream_src_wait(ss->src, PREBUFFER_BYTES, 100); + if (wr != 0) break; + 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; } @@ -278,17 +381,7 @@ static void set_err(int err, const char *msg) 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) { /* §17 滑窗兼容：物化目标曲（窗内命中 / 盘缓存 / song_detail 单曲）并整体快照进 @@ -304,35 +397,43 @@ static void run_song(int idx) g_play.play_song_valid = 1; pthread_mutex_unlock(&g_play.mu); + song_src_t ss; int64_t file_bytes = 0; 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 (!still_current(idx)) return; /* 下载期间已切歌：静默放弃（缓存已落盘不亏） */ + if (!still_current(idx)) return; /* 下载期间已切歌：静默放弃（已落盘部分不亏） */ const char *m = (rc == NCM_ERR_VIP) ? "VIP only (fee gate)" : (rc == NCM_ERR_NOTFOUND) ? "no stream (VIP/copyright)" : (rc == NCM_ERR_AUTH) ? "session expired" : "load failed"; set_err(rc, m); return; } - if (!still_current(idx)) return; /* 下载完成但已切歌：勿开解码/勿动状态 */ + if (!still_current(idx)) { /* 预缓冲完成但已切歌：勿开解码/勿动状态 */ + song_src_dispose(&ss); + return; + } ncm_strlcpy(g_path, path, sizeof g_path); g_file_bytes = file_bytes; 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; int rate = 0, ch = 0, bits = 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; } if (dur <= 0 && total_frames > 0 && rate > 0) dur = total_frames * 1000 / rate; /* 音频输出：按实际流参数开（flac ≤16bit→S16，>16bit→S32；audiod 侧格式归一+原生率跟随） */ 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; /* 已输出帧（每通道） */ int need_seek_ms = -1; int paused_edge = 0; /* 暂停沿：进暂停已向 audiod 发 pause */ + int stalled_edge = 0; /* §21 停滞沿：已对 audiod pause(1)，待数据恢复 pause(0) */ + int underruns_seen = 0; for (;;) { if (g_app_quit) break; @@ -385,7 +488,8 @@ static void run_song(int idx) } 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); audio_out_close(); 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; } + /* §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); - if (frames == 0) { /* 播完 */ + if (frames == 0) { /* 播完（下载中断时=截断点，F5） */ meow_log(MEOW_LOG_INFO, "play: done idx=%d frames=%lld", idx, (long long)frames_done); break; } @@ -409,6 +524,28 @@ static void run_song(int idx) break; } 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 节流）*/ int64_t pos = rate > 0 ? frames_done * 1000 / rate : 0; pthread_mutex_lock(&g_play.mu); @@ -419,6 +556,8 @@ static void run_song(int idx) audio_out_close(); ncm_dec_close(dec); + /* 下载完成由播放线程 commit(rename) / 中断 abort（阶段 2 语义，§21） */ + song_src_dispose(&ss); /* 若应继续播下一首且非因命令打断，由外层处理（外层见 cur==idx 且需自然结束） */ } diff --git a/patch_v2/ncm_app/app/play/stream_src.c b/patch_v2/ncm_app/app/play/stream_src.c new file mode 100644 index 0000000..e720298 --- /dev/null +++ b/patch_v2/ncm_app/app/play/stream_src.c @@ -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 +#include +#include +#include +#include +#include + +#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; +} diff --git a/patch_v2/ncm_app/app/play/stream_src.h b/patch_v2/ncm_app/app/play/stream_src.h new file mode 100644 index 0000000..122248a --- /dev/null +++ b/patch_v2/ncm_app/app/play/stream_src.h @@ -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 +#include + +#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 */ diff --git a/patch_v2/ncm_app/bench/player_flow_sim.c b/patch_v2/ncm_app/bench/player_flow_sim.c index dd1e76b..676c4eb 100644 --- a/patch_v2/ncm_app/bench/player_flow_sim.c +++ b/patch_v2/ncm_app/bench/player_flow_sim.c @@ -17,12 +17,16 @@ * -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 \ * -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 退出码） * §19：P6 覆盖缓存键=歌曲ID+档位 + flac type → .flac 落盘扩展名。 * §20：P7 覆盖 VIP 钳顶（非会员用户档 SURROUND → 请求档 EXHIGH，缓存键仍用户档 sky_c51； * SVIP 直达）+ eff_level 回填；P8 覆盖 fee 门禁（fee=1 非会员 NCM_ERR_VIP 零请求 / * 缓存命中绕过 / CVIP 放行 / fee=8 放行）。 + * §21：边下边播——下载线程走 stub http_download（经真实 stream_src 预缓冲门槛）， + * 解码器 stub 换 ncm_dec_open_src。 */ #include "../app/ncm_app_internal.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"); 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) { (void)c; snprintf(g_last_key, sizeof g_last_key, "%s", id); 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; } +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_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_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; } @@ -139,16 +148,16 @@ int ncm_http_download(const ncm_http_req_t *req, ncm_http_write_cb cb, void *ctx 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 控制播完点） ---- */ static int g_eof; static int g_reads_left = -1; /* >=0: 剩余读次数后 EOF；-1: 直到 g_eof */ static int g_dec_open_bits = 16; /* 模拟流位宽（记录用） */ -int ncm_dec_open(ncm_decoder_t **out, const char *path, int *rate, int *ch, int *bits, - int64_t *total_frames) +int ncm_dec_open_src(ncm_decoder_t **out, stream_src_t *src, int *rate, int *ch, int *bits, + int64_t *total_frames) { - (void)path; + (void)src; *out = (ncm_decoder_t *)calloc(1, 16); if (rate) *rate = 44100; if (ch) *ch = 2; @@ -347,7 +356,16 @@ int main(void) "eff_level=%d (expect EXHIGH，UI 标「已降级至 极高 HQ」)", player_manager_eff_level()); CHECK(strcmp(g_last_key, "1000_sky_c51") == 0, "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; player_manager_play(1); CHECK(wait_state(NCM_PC_PLAYING, 3000), "svip song playing"); diff --git a/patch_v2/ncm_app/bench/stream_sim.c b/patch_v2/ncm_app/bench/stream_sim.c new file mode 100644 index 0000000..8bc0739 --- /dev/null +++ b/patch_v2/ncm_app/bench/stream_sim.c @@ -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 +#include +#include +#include +#include +#include +#include +#include +#include + +/* ---- 全局态（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; +} diff --git a/patch_v2/ncm_app/build_ncm.sh b/patch_v2/ncm_app/build_ncm.sh index b325cbe..391e703 100755 --- a/patch_v2/ncm_app/build_ncm.sh +++ b/patch_v2/ncm_app/build_ncm.sh @@ -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/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/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)" for f in $APP $CORE; do diff --git a/patch_v2/ncm_app/build_ncm_host.sh b/patch_v2/ncm_app/build_ncm_host.sh index cf7ad07..3e7c44d 100755 --- a/patch_v2/ncm_app/build_ncm_host.sh +++ b/patch_v2/ncm_app/build_ncm_host.sh @@ -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/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/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 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; } diff --git a/patch_v2/ncm_app/core/ncm_cache.c b/patch_v2/ncm_app/core/ncm_cache.c index 733b83f..8290794 100644 --- a/patch_v2/ncm_app/core/ncm_cache.c +++ b/patch_v2/ncm_app/core/ncm_cache.c @@ -4,6 +4,8 @@ #include "ncm_store.h" #include +#include +#include #include #include #include @@ -95,7 +97,7 @@ int ncm_cache_lookup(const ncm_cache_t *c, const char *id, const char *ext, struct ncm_cache_writer { char final_path[NCM_CACHE_DIR_MAX + 64]; char tmp_path[NCM_CACHE_DIR_MAX + 80]; - FILE *fp; + int fd; /* 写 fd（write(2) 直写，§21：不走 stdio 缓冲，字节对读端即时可见） */ uint64_t nwritten; 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; ncm_cache_writer_t *w = (ncm_cache_writer_t *)calloc(1, sizeof *w); if (!w) return NCM_ERR_OOM; + w->fd = -1; if (ncm_cache_path(c, id, ext, w->final_path, sizeof w->final_path) != 0) { free(w); return NCM_ERR_FULL; } snprintf(w->tmp_path, sizeof w->tmp_path, "%s.tmp", w->final_path); - w->fp = fopen(w->tmp_path, "wb"); - if (!w->fp) { free(w); return NCM_ERR_IO; } + w->fd = open(w->tmp_path, O_WRONLY | O_CREAT | O_TRUNC, 0644); + if (w->fd < 0) { free(w); return NCM_ERR_IO; } *w_out = w; 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) { - if (!w || !w->fp || w->failed) return NCM_ERR_ARG; - if (fwrite(data, 1, len, w->fp) != len) { w->failed = 1; return NCM_ERR_IO; } + if (!w || w->fd < 0 || w->failed) return NCM_ERR_ARG; + 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; 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) { const entry_t *x = (const entry_t *)a, *y = (const entry_t *)b; 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) { if (!w) return NCM_ERR_ARG; int rc = NCM_OK; - if (w->failed || !w->fp) rc = NCM_ERR_IO; - else if (fflush(w->fp) != 0) rc = NCM_ERR_IO; - else if (fsync(fileno(w->fp)) != 0) rc = NCM_ERR_IO; - else if (fclose(w->fp) != 0) rc = NCM_ERR_IO; + if (w->failed || w->fd < 0) rc = NCM_ERR_IO; + else if (fsync(w->fd) != 0) rc = NCM_ERR_IO; + else if (close(w->fd) != 0) { w->fd = -1; rc = NCM_ERR_IO; } 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 (w->fp) { fclose(w->fp); w->fp = NULL; } + if (w->fd >= 0) { close(w->fd); w->fd = -1; } if (rc == NCM_OK) { /* 刷新 mtime（= 最近访问）*/ 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) { 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); free(w); return NCM_OK; diff --git a/patch_v2/ncm_app/core/ncm_cache.h b/patch_v2/ncm_app/core/ncm_cache.h index 055eebd..de580b3 100644 --- a/patch_v2/ncm_app/core/ncm_cache.h +++ b/patch_v2/ncm_app/core/ncm_cache.h @@ -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, 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; int ncm_cache_open(const ncm_cache_t *c, const char *id, const char *ext, ncm_cache_writer_t **w); 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_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); diff --git a/patch_v2/ncm_app/core/ncm_http.c b/patch_v2/ncm_app/core/ncm_http.c index 4e1dec9..4a26149 100644 --- a/patch_v2/ncm_app/core/ncm_http.c +++ b/patch_v2/ncm_app/core/ncm_http.c @@ -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 (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; + if (tmo > 15000) tmo = 15000; /* 绝对段统一钳到 15s */ 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; @@ -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 (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) { - 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) { - 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) { break; /* 对端关闭 */ } else { diff --git a/patch_v2/ncm_app/core/ncm_http.h b/patch_v2/ncm_app/core/ncm_http.h index 34012cf..41fd3bb 100644 --- a/patch_v2/ncm_app/core/ncm_http.h +++ b/patch_v2/ncm_app/core/ncm_http.h @@ -36,7 +36,8 @@ typedef struct ncm_http_req { const char *body; /* 表单体，可为 NULL */ size_t body_len; /* 0 表示 strlen(body) */ 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=跳过(仅调试) */ const char *ca_path; /* 指定 CA bundle 路径；NULL=系统默认 */ } ncm_http_req_t; diff --git a/patch_v2/ncm_app/ncm b/patch_v2/ncm_app/ncm index 24b6cf2..fe268f6 100755 Binary files a/patch_v2/ncm_app/ncm and b/patch_v2/ncm_app/ncm differ diff --git a/patch_v2/ncm_app/ncm_host b/patch_v2/ncm_app/ncm_host index 86bffe1..ee5b9ab 100755 Binary files a/patch_v2/ncm_app/ncm_host and b/patch_v2/ncm_app/ncm_host differ diff --git a/patch_v2/ncm_app/test/test_ncm_core_host b/patch_v2/ncm_app/test/test_ncm_core_host index 6fe8755..d64acd7 100755 Binary files a/patch_v2/ncm_app/test/test_ncm_core_host and b/patch_v2/ncm_app/test/test_ncm_core_host differ