一分钟搭建影视站,支持Docker等部署方式
fix(cache): 分片缓存 key 锚定文档基址,预取幂等按锚点精化
bestZweif374a93d7b4e
diff --git a/src/components/player-shell.tsx b/src/components/player-shell.tsxindex b6ea6c9..4dbb78c 100644--- a/src/components/player-shell.tsx+++ b/src/components/player-shell.tsx@@ -85,6 +85,8 @@ export function PlayerShell({const videoErrorRetryUsedRef = useRef(false);// 进度恢复每集只执行一次(MANIFEST_PARSED 可能因代理回退再次触发)const restoredRef = useRef(false);+ // timeupdate 续跑预取的游标:必须按集清零,否则会沿用上一集的时间戳推迟首次续跑+ const lastPrefetchEnsureRef = useRef(0);// setupHls 可能改走代理形式,video:error 重试要用最近一次的地址const currentMediaUrlRef = useRef(url);// 本集的恢复策略实例:跨直连/代理两级重建共享计数@@ -162,8 +164,11 @@ export function PlayerShell({hls.on(Hls.Events.MANIFEST_PARSED, async () => {recoveryRef.current?.markHealthy();+ // 预取锚点:恢复进度时直接取恢复目标。赋值后 video.currentTime 未必立刻反映+ // (Safari 系),而 ensure 是以「锚点未变」为前提复用 parsing 中的运行的——+ // 这里读到旧值会把窗口建在片头,且白等一次纠错重建。+ let prefetchAnchor = video.currentTime;// 进度恢复(每集一次):优先 URL position,其次 IndexedDB 记录- let restoreSeekPending = false;if (!restoredRef.current) {restoredRef.current = true;try {@@ -171,17 +176,13 @@ export function PlayerShell({const duration = artRef.current?.duration || 0;if (saved > 10 && duration > 0 && saved < duration - 2) {if (artRef.current) artRef.current.currentTime = saved;- // Safari 系此刻 video.currentTime 未必已反映赋值,预取锚点会短暂- // 落在 0——交给紧随的 video:seeked 事件以恢复后的锚点触发预取- restoreSeekPending = true;+ prefetchAnchor = saved;showHint(`已从 ${formatTime(saved)} 继续播放`);}} catch { /* 忽略恢复失败 */ }}- // 新集立即预取(否则要等 timeupdate 的 30s 节流,起播初期无缓存);- // 有恢复 seek 待执行时跳过:seeked 事件带着恢复后的锚点触发预取,- // 避免 parsing 中被第二次 ensure abort 白扔一次拉取与解析- if (!restoreSeekPending) ensurePrefetch(mediaUrl, video.currentTime);+ // 新集立即预取(否则要等 timeupdate 的 30s 节流,起播初期无缓存)+ ensurePrefetch(mediaUrl, prefetchAnchor);video.play().catch(() => {});});// 播放链路恢复(FRAG_LOADED / MANIFEST_PARSED):静默窗外清零连续失败计数@@ -244,6 +245,7 @@ export function PlayerShell({playbackStartedRef.current = false;videoErrorRetryUsedRef.current = false;restoredRef.current = false;+ lastPrefetchEnsureRef.current = 0;recoveryRef.current = new PlaybackRecovery();// 换集时清掉上一集的预取窗口,避免带宽被旧集占用getVideoPrefetcher().stop();@@ -268,7 +270,6 @@ export function PlayerShell({endedRef.current = false;let lastSave = 0;- let lastPrefetchEnsure = 0;const art = new Artplayer({container: containerRef.current,@@ -334,8 +335,8 @@ export function PlayerShell({propsRef.current.onTimeUpdate?.(art.currentTime, art.duration);}// 每 30s 续跑一次前向预取窗口(ensure 幂等,窗口未覆盖足够余量才会重建)- if (now - lastPrefetchEnsure > 30_000) {- lastPrefetchEnsure = now;+ if (now - lastPrefetchEnsureRef.current > 30_000) {+ lastPrefetchEnsureRef.current = now;// 用 currentMediaUrlRef(代理回退后的实际地址):否则预取的 key 与// loader 读取的 key 不一致,缓存永不命中且直连 fetch 白耗流量ensurePrefetch(currentMediaUrlRef.current, art.currentTime);diff --git a/src/lib/m3u8-parse.ts b/src/lib/m3u8-parse.tsindex 955ce62..f7f057f 100644--- a/src/lib/m3u8-parse.ts+++ b/src/lib/m3u8-parse.ts@@ -1,4 +1,4 @@-import { makeAbsolute, stripAdGroups } from './m3u8';+import { makeAbsolute, stripAdGroups, documentBaseURI } from './m3u8';/*** m3u8 播放列表解析(预取器与离线下载共用)。@@ -6,6 +6,8 @@ import { makeAbsolute, stripAdGroups } from './m3u8';* 与 hls.js loader 侧的一致性是本地缓存命中的前提:* 两侧都通过 `new URL()` 绝对化地址(见 video-cache.buildSegmentCacheKey),* 因此这里对分片地址也必须用同一构造器抹平默认端口 / 百分号编码差异。+ * 但仅有同一构造器不够——基址本身可能就是根相对的代理形式,+ * `new URL(相对分片, 相对基址)` 会抛错并原样返回,所以入参要先锚到文档基址。*/export interface ParsedSegment {@@ -108,7 +110,11 @@ export async function parseM3u8Playlist(opts?: ParseOptions): Promise<ParsedPlaylist> {if (depth > MAX_DEPTH) throw new Error(`m3u8 嵌套超过 ${MAX_DEPTH} 层`);- const res = await fetch(url, { headers: { Accept: '*/*' } });+ // 入参本身可能是本站根相对地址(代理形态),先锚成绝对地址再作为解析基址:+ // 否则 new URL(相对分片, 相对基址) 抛错,segments[].url 就停留在相对形式,+ // 与 hls.js 按绝对清单地址解析出的同一个分片不再是同一个缓存 key+ const base = makeAbsolute(url, documentBaseURI());+ const res = await fetch(base, { headers: { Accept: '*/*' } });if (!res.ok) throw new Error(`m3u8 拉取失败:HTTP ${res.status}`);// 剔除片头广告段要在统计时长/分片之前做,下载产物才不会带上广告const text = opts?.stripLeadAd === false ? await res.text() : stripAdGroups(await res.text());@@ -130,7 +136,7 @@ export async function parseM3u8Playlist(}if (!line || line.startsWith('#')) continue;if (pending) {- const abs = makeAbsolute(line, url);+ const abs = makeAbsolute(line, base);variants.push({url: abs,bandwidth: pending.bandwidth,@@ -156,7 +162,7 @@ export async function parseM3u8Playlist(if (line.startsWith('#EXT-X-KEY')) {// 取最后一次出现的 KEY(逐段换 key 的源不在支持范围)const conf = parseAesConf(line);- if (conf) aesConf = { ...conf, uri: makeAbsolute(conf.uri, url) };+ if (conf) aesConf = { ...conf, uri: makeAbsolute(conf.uri, base) };continue;}if (line.startsWith('#EXT-X-BYTERANGE')) {@@ -168,7 +174,7 @@ export async function parseM3u8Playlist(continue;}if (!line || line.startsWith('#')) continue;- segments.push({ url: makeAbsolute(line, url), duration: pendingDuration });+ segments.push({ url: makeAbsolute(line, base), duration: pendingDuration });pendingDuration = 0;}if (!segments.length) throw new Error('m3u8 未解析到分片');diff --git a/src/lib/m3u8.ts b/src/lib/m3u8.tsindex 18387cd..476741d 100644--- a/src/lib/m3u8.ts+++ b/src/lib/m3u8.ts@@ -16,7 +16,18 @@ export function isProxiedUri(uri: string): boolean {return uri.startsWith('/api/proxy') || uri.startsWith('/api/live/stream');}-export function makeAbsolute(url: string, base: string): string {+/**+ * 文档基址:把本站根相对地址锚成绝对地址时使用。+ * 代理形态的地址形如 `/api/proxy?url=…`(见 PROXY_BASE),而+ * `new URL(相对串, 相对基址)` 必然抛错、只能原样返回,于是同一个分片在+ * 预取侧与播放器侧会是两个不同的字符串。SSR 下没有 document,返回+ * undefined,由调用方按「无法锚定」降级处理。+ */+export function documentBaseURI(): string | undefined {+ return typeof document === 'undefined' ? undefined : document.baseURI;+}++export function makeAbsolute(url: string, base: string | undefined): string {try {return new URL(url, base).href;} catch {diff --git a/src/lib/video-cache.ts b/src/lib/video-cache.tsindex 2a02d54..d19ce57 100644--- a/src/lib/video-cache.ts+++ b/src/lib/video-cache.ts@@ -1,4 +1,5 @@import { db } from './db';+import { documentBaseURI } from './m3u8';/*** 视频片段本地缓存层。@@ -13,7 +14,8 @@ import { db } from './db';** key 一致性是缓存命中的前提:hls.js loader 请求分片时的 context.url 与预取器* 解析出的分片地址,都必须经 `new URL()` 归一化(抹平默认端口/百分号编码差异)。- * 播放列表是代理改写形式(/api/proxy?url=…)时分片也是同源地址,两种形式天然一致。+ * 播放列表走代理改写形式(/api/proxy?url=…)时分片也是**本站根相对串**,+ * 不带基址的 `new URL()` 会原样放过——必须锚到文档基址才与绝对形式收敛为同一个 key。*/export const VIDEO_CACHE_NAME = 'libretv-video-v1';@@ -70,10 +72,13 @@ export function saveCacheSettings(next: Partial<CacheSettings>): CacheSettings {return merged;}-/** 分片缓存 key:`new URL()` 归一化(与 hls.js loader 侧一致,缓存命中的前提) */+/**+ * 分片缓存 key:归一化成绝对地址(两侧一致,缓存命中的前提)。+ * 以文档基址作基线,本站根相对的代理形式与绝对形式才会收敛到同一个串。+ */export function buildSegmentCacheKey(segmentUrl: string): string {try {- return new URL(segmentUrl).href;+ return new URL(segmentUrl, documentBaseURI()).href;} catch {return segmentUrl;}diff --git a/src/lib/video-prefetcher.test.ts b/src/lib/video-prefetcher.test.tsindex 66577ad..cbd496b 100644--- a/src/lib/video-prefetcher.test.ts+++ b/src/lib/video-prefetcher.test.ts@@ -1,6 +1,8 @@-import { afterEach, describe, expect, it, vi } from 'vitest';+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';import { computeWindow, indexAtTime, VideoPrefetcher } from './video-prefetcher';-import { clearVideoCache } from './video-cache';+import { buildSegmentCacheKey, clearVideoCache } from './video-cache';+import { parseM3u8Playlist } from './m3u8-parse';+import { rewriteM3u8 } from './m3u8';afterEach(async () => {vi.unstubAllGlobals();@@ -31,76 +33,169 @@ describe('computeWindow', () => {});it('锚点接近片尾时钳制', () => {- const { fromIdx, toIdx } = computeWindow(durations, 19, 6, 5);+ const { toIdx } = computeWindow(durations, 19, 6, 5);expect(toIdx).toBe(5);});- it('时长全缺失时按数量兜底', () => {- const { toIdx } = computeWindow([0, 0, 0, 0, 0, 0], 0, 6, 5);- expect(toIdx).toBeLessThanOrEqual(6);+ it('时长全缺失时按数量兜底,且不越过分片总数', () => {+ expect(computeWindow(new Array(6).fill(0), 0, 6).toIdx).toBe(6);+ // 分片数必须超过兜底上限才钉得住:否则「兜底」与「整集」结果相同,断言落空+ expect(computeWindow(new Array(300).fill(0), 0, 6).toIdx).toBe(200);+ // 无限模式(暂停黄金窗口)对这类源同样收在兜底上限,不再铺满整集+ expect(computeWindow(new Array(300).fill(0), 0, 0).toIdx).toBe(200);});});describe('VideoPrefetcher.ensure 幂等', () => {+ /** 200 片 × 5s = 1000s:前向余量判定需要窗口明显大于 FORWARD_MARGIN_SECONDS */+ const SEG_COUNT = 200;+ const SEG_BASE = 'https://cdn.example.com/';+ const M3U8_URL = `${SEG_BASE}index.m3u8`;const PLAYLIST = ['#EXTM3U',- '#EXTINF:5,',- 'https://cdn.example.com/seg1.ts',- '#EXTINF:5,',- 'https://cdn.example.com/seg2.ts',+ ...Array.from({ length: SEG_COUNT }, (_, i) => `#EXTINF:5,\n${SEG_BASE}seg${i + 1}.ts`),].join('\n');+ const segUrl = (n: number) => `${SEG_BASE}seg${n}.ts`;- const M3U8_URL = 'https://cdn.example.com/index.m3u8';+ function deferred() {+ let resolve = () => {};+ const promise = new Promise<void>((r) => {+ resolve = r;+ });+ return { promise, resolve };+ }- function makePrefetcher() {+ interface MockOptions {+ /** 首次 m3u8 拉取挂起指定毫秒,制造「parsing 在途」的窗口 */+ gateM3u8Ms?: number;+ /** 分片请求全部挂起,让运行稳定停在 running 状态 */+ holdSegments?: boolean;+ }++ function makePrefetcher(opts: MockOptions = {}) {const m3u8Fetches = vi.fn();- // 首次 m3u8 拉取可挂起(模拟 parsing 中途的第二次 ensure),其余立即返回- let gated = true;- const fetchMock = vi.fn((input: RequestInfo | URL) => {+ const segUrls: string[] = [];+ const hold = deferred();+ let firstM3u8 = true;+ vi.stubGlobal('fetch', vi.fn(async (input: RequestInfo | URL) => {const url = typeof input === 'string' ? input : (input as Request).url;- if (url.includes('index.m3u8')) {+ if (url.includes('.m3u8')) {m3u8Fetches();- if (gated) {- gated = false;- return new Promise<Response>((r) => setTimeout(() => r(new Response(PLAYLIST, { status: 200 })), 50));+ if (firstM3u8 && opts.gateM3u8Ms) {+ firstM3u8 = false;+ await new Promise((r) => setTimeout(r, opts.gateM3u8Ms));}- return Promise.resolve(new Response(PLAYLIST, { status: 200 }));+ return new Response(PLAYLIST, { status: 200 });}- return Promise.resolve(new Response(new ArrayBuffer(1000), { status: 200 }));- });- vi.stubGlobal('fetch', fetchMock);- return { m3u8Fetches };+ segUrls.push(url);+ if (opts.holdSegments) await hold.promise;+ return new Response(new ArrayBuffer(1024), { status: 200 });+ }));+ return { m3u8Fetches, segUrls, release: () => hold.resolve() };}- it('parsing 期间同 descriptor 的第二次 ensure 不 abort 刚起跑的运行', async () => {- const { m3u8Fetches } = makePrefetcher();- const p = new VideoPrefetcher();+ function ensureAt(pf: VideoPrefetcher, currentTime: number) {+ pf.ensure({ m3u8Url: M3U8_URL, currentTime, episodeKey: 's:v:0', horizonSeconds: 300 });+ }++ it('parsing 期间同锚点的第二次 ensure 不 abort 刚起跑的运行', async () => {+ const { m3u8Fetches, segUrls, release } = makePrefetcher({ gateM3u8Ms: 30, holdSegments: true });+ const pf = new VideoPrefetcher();- p.ensure({ m3u8Url: M3U8_URL, currentTime: 0, episodeKey: 's:v:0', horizonSeconds: 10 });- // 解析尚未完成(fetch 挂起)时的第二次 ensure:同 descriptor,不得重建- p.ensure({ m3u8Url: M3U8_URL, currentTime: 0, episodeKey: 's:v:0', horizonSeconds: 10 });+ ensureAt(pf, 0);+ expect(pf.getStats().state).toBe('parsing');+ ensureAt(pf, 0);expect(m3u8Fetches).toHaveBeenCalledTimes(1);- await vi.waitFor(() => expect(p.getStats().state).toBe('done'));+ // 复用的是同一次运行:解析完成后照常推进到分片+ await vi.waitFor(() => expect(pf.getStats().state).toBe('running'));expect(m3u8Fetches).toHaveBeenCalledTimes(1);+ expect(segUrls[0]).toBe(segUrl(1));++ pf.stop();+ release();+ });++ it('parsing 期间锚点变化必须重建,且窗口按新锚点计算', async () => {+ const { m3u8Fetches, segUrls, release } = makePrefetcher({ gateM3u8Ms: 30, holdSegments: true });+ const pf = new VideoPrefetcher();++ ensureAt(pf, 0);+ // 解析在途时用户拖到 600s:沿用旧锚点会把整个窗口建在片头,且要到队列耗尽才纠正+ ensureAt(pf, 600);+ expect(m3u8Fetches).toHaveBeenCalledTimes(2);++ await vi.waitFor(() => expect(pf.getStats().state).toBe('running'));+ // 新窗口自 600 - 30(回看)= 570s 起,即第 114 片+ expect(segUrls[0]).toBe(segUrl(114));++ pf.stop();+ release();+ });++ it('running 状态的前向余量按最新播放头判定,不按建窗时的旧值', async () => {+ const { m3u8Fetches, release } = makePrefetcher({ holdSegments: true });+ const pf = new VideoPrefetcher();++ ensureAt(pf, 0);+ await vi.waitFor(() => expect(pf.getStats().state).toBe('running'));+ expect(m3u8Fetches).toHaveBeenCalledTimes(1);++ // 窗口 [0, 300]:播放头 100s 仍有 200s 前向余量 → 复用+ ensureAt(pf, 100);+ expect(m3u8Fetches).toHaveBeenCalledTimes(1);++ // 播放头 260s:余量不足 60s → 必须重建(按建窗时的 0s 判定会永远判「够用」)+ ensureAt(pf, 260);+ expect(m3u8Fetches).toHaveBeenCalledTimes(2);++ pf.stop();+ release();});it('done 状态的重复 ensure 按设计重建;换集必重建', async () => {- const { m3u8Fetches } = makePrefetcher();- const p = new VideoPrefetcher();+ const { m3u8Fetches, release } = makePrefetcher();+ const pf = new VideoPrefetcher();- p.ensure({ m3u8Url: M3U8_URL, currentTime: 0, episodeKey: 's:v:0', horizonSeconds: 10 });- await vi.waitFor(() => expect(p.getStats().state).toBe('done'));+ ensureAt(pf, 0);+ await vi.waitFor(() => expect(pf.getStats().state).toBe('done'));expect(m3u8Fetches).toHaveBeenCalledTimes(1);// done 后的 ensure 会重查覆盖并重建(分片已缓存的拉取在 loader 侧命中)- p.ensure({ m3u8Url: M3U8_URL, currentTime: 0, episodeKey: 's:v:0', horizonSeconds: 10 });- await vi.waitFor(() => expect(p.getStats().state).toBe('done'));+ ensureAt(pf, 0);+ await vi.waitFor(() => expect(pf.getStats().state).toBe('done'));expect(m3u8Fetches).toHaveBeenCalledTimes(2);// 换集:descriptor 不同 → 必须重建- p.ensure({ m3u8Url: M3U8_URL, currentTime: 0, episodeKey: 's:v:1', horizonSeconds: 10 });- await vi.waitFor(() => expect(p.getStats().state).toBe('done'));+ pf.ensure({ m3u8Url: M3U8_URL, currentTime: 0, episodeKey: 's:v:1', horizonSeconds: 300 });+ await vi.waitFor(() => expect(pf.getStats().state).toBe('done'));expect(m3u8Fetches).toHaveBeenCalledTimes(3);+ release();+ });+});++describe('缓存 key 归一(代理形态根相对地址)', () => {+ const APP = 'https://app.example.com';+ const UPSTREAM = 'https://cdn.example.com/live/index.m3u8';+ const MANIFEST = `/api/proxy?url=${encodeURIComponent(UPSTREAM)}`;++ beforeEach(() => {+ vi.stubGlobal('document', { baseURI: `${APP}/watch` });+ });++ it('同一分片的相对形式与绝对形式收敛为同一个 key', () => {+ const rel = '/api/proxy?url=https%3A%2F%2Fcdn.example.com%2Flive%2Fseg1.ts';+ expect(buildSegmentCacheKey(rel)).toBe(buildSegmentCacheKey(`${APP}${rel}`));+ });++ it('代理回退下预取解析出的分片地址与 hls.js 解析同一行完全一致', async () => {+ // 服务端 /api/proxy 下发给播放器的正是这个改写后的 body(分片为本站根相对地址)+ const proxied = rewriteM3u8('#EXTM3U\n#EXTINF:5,\nseg1.ts', UPSTREAM);+ vi.stubGlobal('fetch', vi.fn(async () => new Response(proxied, { status: 200 })));++ const parsed = await parseM3u8Playlist(MANIFEST);+ const loaderUrl = new URL(proxied.split('\n')[2], `${APP}${MANIFEST}`).href;++ expect(parsed.segments[0].url).toBe(loaderUrl);});});diff --git a/src/lib/video-prefetcher.ts b/src/lib/video-prefetcher.tsindex 13406bc..7a4a759 100644--- a/src/lib/video-prefetcher.ts+++ b/src/lib/video-prefetcher.ts@@ -55,6 +55,8 @@ interface RunDescriptor {/** 前向余量:正在跑的窗口距播放位置还有 60s 以上时,ensure 不重建 */const FORWARD_MARGIN_SECONDS = 60;+/** parsing 期间视为「锚点未变」的容差:恢复进度等场景下 seek 目标与读到的播放头会差一点 */+const ANCHOR_EPSILON_SECONDS = 1;const LOOK_BEHIND_SECONDS_DEFAULT = 30;/** 时长缺失时的兜底窗口(分片数) */const FALLBACK_MAX_SEGMENTS = 200;@@ -121,21 +123,28 @@ export class VideoPrefetcher {const horizon = options.horizonSeconds ?? settings.horizonSeconds;const descriptor: RunDescriptor = { m3u8Url: options.m3u8Url, episodeKey: options.episodeKey, horizonSeconds: horizon };- // 幂等判断:- // - running:同一集且窗口覆盖足够 → 不打断;- // - parsing:窗口尚未可知,同 descriptor 直接复用——否则「MANIFEST_PARSED- // 起跑 + 恢复 seek 立即第二次 ensure」会 abort 刚起跑的运行,白扔一次- // m3u8 拉取与解析(窗口若未覆盖新锚点,由后续触发按 running 规则重建)。- const reusable =- (this.stats.state === 'running' || this.stats.state === 'parsing') &&- this.descriptor &&+ // 幂等判断:先确认是同一个运行(同集、同清单、同窗口长度),再看窗口罩不罩得住新锚点。+ // - parsing:窗口还没算出来,无从判断覆盖——只在锚点基本没变时复用,省掉「刚起跑+ // 就被第二次 ensure abort」那次白扔的拉取与解析;锚点变了必须重建,否则会一直+ // 把窗口算在旧位置上,直到队列耗尽才有机会纠正;+ // - running:窗口已知,按**本次传入**的播放头判断前向余量。这里不能用+ // this.currentTime——它只在 run() 里赋过一次值,播放头跑出去后仍按建窗时的+ // 位置判定,会一路误判「还够用」而不再重建。+ const sameRun =+ !!this.descriptor &&this.descriptor.m3u8Url === descriptor.m3u8Url &&this.descriptor.episodeKey === descriptor.episodeKey &&this.descriptor.horizonSeconds === descriptor.horizonSeconds;- if (reusable) {- if (this.stats.state === 'parsing') return;+ if (sameRun) {if (- this.currentTime + FORWARD_MARGIN_SECONDS < this.windowToTime &&+ this.stats.state === 'parsing' &&+ Math.abs(options.currentTime - this.currentTime) < ANCHOR_EPSILON_SECONDS+ ) {+ return;+ }+ if (+ this.stats.state === 'running' &&+ options.currentTime + FORWARD_MARGIN_SECONDS < this.windowToTime &&options.currentTime >= this.windowFromTime) {return;