Skip to content

一分钟搭建影视站,支持Docker等部署方式

fix(cache): 分片缓存 key 锚定文档基址,预取幂等按锚点精化

bestZweif374a93d7b4e
diff --git a/src/components/player-shell.tsx b/src/components/player-shell.tsx
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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;