Skip to content

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

perf(live): 直播测活全面优化(时间预算/缓存/流式/准确性)

bestZweifcf9ae67d672
diff --git a/package.json b/package.json
index ad63753..86cd222 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "libretv",
- "version": "2.6.0",
+ "version": "2.7.0",
"private": true,
"description": "免费在线视频搜索与观看平台(Next.js 重构版)",
"license": "AGPL-3.0-or-later",
diff --git a/src/app/api/live/probe/route.test.ts b/src/app/api/live/probe/route.test.ts
new file mode 100644
index 0000000..8872cba
--- /dev/null
+++ b/src/app/api/live/probe/route.test.ts
@@ -0,0 +1,151 @@
+import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+import { POST } from './route';
+import { SESSION_COOKIE, signSession } from '@/lib/auth';
+
+/**
+ * 测活接口单测:流式 NDJSON、codec 解析、内容校验、结果缓存、内网放行。
+ * 上游一律用 mock fetch,不产生真实网络请求。
+ */
+
+const MASTER = [
+ '#EXTM3U',
+ '#EXT-X-STREAM-INF:BANDWIDTH=800000,CODECS="hvc1.1.6.L93.B0,mp4a.40.2"',
+ 'media.m3u8',
+ '',
+].join('\n');
+
+const MEDIA = ['#EXTM3U', '#EXT-X-TARGETDURATION:6', '#EXTINF:6.0,', 'seg1.ts', ''].join('\n');
+
+const HTML = '<!doctype html><html><body>error</body></html>';
+
+function jsonRes(body: string, contentType: string, status = 200): Response {
+ return new Response(body, { status, headers: { 'content-type': contentType } });
+}
+
+/** 按 URL 分发的上游 mock:master / media / segment 正常,fake 站返回 HTML */
+function mockUpstream(): { fn: ReturnType<typeof vi.fn> } {
+ const fn = vi.fn(async (input: RequestInfo | URL) => {
+ const url = String(input);
+ if (url.includes('/master.m3u8')) return jsonRes(MASTER, 'application/vnd.apple.mpegurl');
+ if (url.includes('/media.m3u8')) return jsonRes(MEDIA, 'application/vnd.apple.mpegurl');
+ if (url.includes('/seg1.ts')) {
+ return new Response('binary', { status: 206, headers: { 'content-type': 'video/mp2t' } });
+ }
+ if (url.includes('/fake-page.m3u8')) return jsonRes(HTML, 'text/html; charset=utf-8');
+ if (url.includes('/fake-stream.flv')) return jsonRes(HTML, 'text/html; charset=utf-8');
+ return new Response('not found', { status: 404, headers: { 'content-type': 'text/plain' } });
+ });
+ vi.stubGlobal('fetch', fn);
+ return { fn };
+}
+
+function makeRequest(urls: string[], stream: boolean): Request {
+ const { token } = signSession();
+ return new Request(`https://local.test/api/live/probe${stream ? '?stream=1' : ''}`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ cookie: `${SESSION_COOKIE}=${token}`,
+ },
+ body: JSON.stringify({ urls }),
+ });
+}
+
+async function readNdjson(res: Response) {
+ const text = await res.text();
+ return text
+ .split('\n')
+ .map((l) => l.trim())
+ .filter(Boolean)
+ .map((l) => JSON.parse(l) as Record<string, unknown>);
+}
+
+beforeAll(() => {
+ process.env.PASSWORD = 'test-password';
+ delete process.env.PROXY_SECRET;
+});
+
+afterEach(() => {
+ vi.unstubAllGlobals();
+});
+
+describe('POST /api/live/probe', () => {
+ it('stream=1 以 NDJSON 逐条返回,并解析 master 的 CODECS', async () => {
+ mockUpstream();
+ const res = await POST(makeRequest(['https://iptv.test/master.m3u8'], true));
+ expect(res.headers.get('content-type')).toContain('application/x-ndjson');
+
+ const lines = await readNdjson(res);
+ expect(lines).toHaveLength(1);
+ expect(lines[0]).toMatchObject({
+ url: 'https://iptv.test/master.m3u8',
+ ok: true,
+ level: 'segment',
+ codec: 'hvc1.1.6.L93.B0,mp4a.40.2',
+ });
+ });
+
+ it('非流式请求保持原有 JSON 结构(向后兼容)', async () => {
+ mockUpstream();
+ const res = await POST(makeRequest(['https://iptv.test/master.m3u8?json=1'], false));
+ const data = (await res.json()) as { results: Record<string, unknown>[] };
+ expect(data.results).toHaveLength(1);
+ expect(data.results[0]).toMatchObject({ ok: true, level: 'segment' });
+ });
+
+ it('返回 HTML 的伪 m3u8 判为不可用', async () => {
+ mockUpstream();
+ const res = await POST(makeRequest(['https://fake.test/fake-page.m3u8'], true));
+ const [line] = await readNdjson(res);
+ expect(line.ok).toBe(false);
+ expect(String(line.error)).toContain('不是有效的 m3u8');
+ });
+
+ it('返回 HTML 的伪直链判为不可用(content-type 校验)', async () => {
+ mockUpstream();
+ const res = await POST(makeRequest(['https://fake.test/fake-stream.flv'], true));
+ const [line] = await readNdjson(res);
+ expect(line.ok).toBe(false);
+ expect(String(line.error)).toContain('不是流媒体');
+ });
+
+ it('成功结果命中服务端缓存,重复测活不再请求上游', async () => {
+ const { fn } = mockUpstream();
+ const url = 'https://iptv.test/master.m3u8?cache-check=1';
+ // 必须读完流(读到 controller.close)才能确保首轮探测已完成
+ const first = await POST(makeRequest([url], true));
+ const [firstLine] = await readNdjson(first);
+ expect(firstLine.ok).toBe(true);
+ const callsAfterFirst = fn.mock.calls.length;
+ expect(callsAfterFirst).toBeGreaterThan(0);
+
+ const res = await POST(makeRequest([url], true));
+ const [line] = await readNdjson(res);
+ expect(line.ok).toBe(true);
+ expect(fn.mock.calls.length).toBe(callsAfterFirst);
+ });
+
+ it('未开启 LIVE_ALLOW_PRIVATE 时拒绝内网地址', async () => {
+ mockUpstream();
+ delete process.env.LIVE_ALLOW_PRIVATE;
+ const res = await POST(makeRequest(['http://127.0.0.1:8080/live.m3u8'], true));
+ const [line] = await readNdjson(res);
+ expect(line.ok).toBe(false);
+ expect(String(line.error)).toContain('允许范围');
+ });
+
+ it('开启 LIVE_ALLOW_PRIVATE 后自建内网源可正常探测(与直播代理口径一致)', async () => {
+ process.env.LIVE_ALLOW_PRIVATE = '1';
+ vi.stubGlobal(
+ 'fetch',
+ vi.fn(async () => jsonRes(MASTER, 'application/vnd.apple.mpegurl'))
+ );
+ try {
+ const res = await POST(makeRequest(['http://192.168.1.10:8080/iptv/master.m3u8'], true));
+ const [line] = await readNdjson(res);
+ expect(line.ok).toBe(true);
+ } finally {
+ delete process.env.LIVE_ALLOW_PRIVATE;
+ }
+ });
+});
diff --git a/src/app/api/live/probe/route.ts b/src/app/api/live/probe/route.ts
index 6041193..bbe9531 100644
--- a/src/app/api/live/probe/route.ts
+++ b/src/app/api/live/probe/route.ts
@@ -1,6 +1,5 @@
import { NextResponse } from 'next/server';
import { guardRequest, jsonError } from '@/lib/api-guard';
-import { checkUpstreamAllowed } from '@/lib/ssrf';
import { fetchUpstreamWithMeta } from '@/lib/fetch-utils';
export const runtime = 'nodejs';
@@ -19,11 +18,28 @@ export const dynamic = 'force-dynamic';
* 非 m3u8(FLV 等)维持单级探测。结果 level 标识探测深度:
* segment=分片级(最可信)/ manifest=仅 manifest 级 / head=单级直探
* 200/206 响应头视为可达;仍不保证编码可解码(H.265 等)。
+ *
+ * 性能与准确性要点:
+ * - 每个频道有整体时间预算(URL_BUDGET_MS),三级探测共享,避免逐级 5s 叠加成长尾;
+ * - 结果带短 TTL 缓存(成功 10min / 失败 2min),多用户重复测活不再重复打上游;
+ * - 请求带源站 Referer,消除「源校验 Referer 导致的可播却测不通」假阴性;
+ * - 校验 m3u8 的 #EXTM3U 前缀与直链的 content-type,剔除 200 的 HTML/JSON 错误页;
+ * - master playlist 解析 CODECS 一并返回,前端据此提示 H.265 等浏览器无法解码的情况;
+ * - 走直播侧 SSRF 口径(allowPrivate):LIVE_ALLOW_PRIVATE=1 时自建内网 IPTV 同样能测通;
+ * - `?stream=1` 以 NDJSON 逐条推送结果(命中缓存的立即返回),前端状态点可边测边亮;
+ * 不带该参数时仍返回整批 JSON,保持向后兼容。
*/
const MAX_URLS = 50;
-const CONCURRENCY = 8;
-const TIMEOUT_MS = 5000;
+const CONCURRENCY = 16;
+/** 单个频道三级探测的总预算(含 SSRF 校验与各级请求) */
+const URL_BUDGET_MS = 6000;
+/** 分片级最长等待:分片只需响应头,超时说明源不可用 */
+const SEGMENT_TIMEOUT_MS = 2500;
+/** 结果缓存:成功结果稳定,失败可能是瞬断,分开设置 */
+const CACHE_TTL_OK_MS = 10 * 60 * 1000;
+const CACHE_TTL_FAIL_MS = 2 * 60 * 1000;
+const CACHE_MAX_ENTRIES = 2000;
const UA =
process.env.USER_AGENT ||
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36';
@@ -35,29 +51,74 @@ interface ProbeOutcome {
ms?: number;
level?: 'segment' | 'manifest' | 'head';
error?: string;
+ /** master playlist 的 CODECS 属性(如 hvc1.1.6.L93.B0,mp4a.40.2),用于前端提示编码兼容性 */
+ codec?: string;
+}
+
+interface FetchHeadResult {
+ ok: boolean;
+ status: number;
+ text?: string;
+ finalUrl: string;
+ contentType: string;
+ isM3u8: boolean;
+}
+
+/** 明显的网页/接口响应(200 的 HTML/JSON 错误页不能当成流) */
+function isWebPageType(contentType: string): boolean {
+ const ct = contentType.toLowerCase();
+ return (
+ ct.includes('text/html') ||
+ ct.includes('application/xhtml') ||
+ ct.includes('application/json') ||
+ ct.includes('text/xml') ||
+ ct.includes('application/xml')
+ );
}
-/** 请求一个资源,拿到响应头即断开 body;返回 ok、状态码与重定向后的最终 URL */
-async function fetchHeadersOnly(url: string): Promise<{ ok: boolean; status: number; text?: string; finalUrl: string }> {
+/** 源站 Referer:部分 IPTV 源校验 Referer 才放行列表/分片,缺失会误判为不可用 */
+function refererOf(url: string): string | undefined {
+ try {
+ return `${new URL(url).origin}/`;
+ } catch {
+ return undefined;
+ }
+}
+
+/** 请求一个资源,拿到响应头即断开 body(m3u8 额外读取文本以供解析) */
+async function fetchHeadersOnly(
+ url: string,
+ timeoutMs: number,
+ referer?: string
+): Promise<FetchHeadResult> {
+ const headers: Record<string, string> = {
+ 'User-Agent': UA,
+ Accept: '*/*',
+ Range: 'bytes=0-1',
+ };
+ if (referer) headers.Referer = referer;
+
+ // allowPrivate:与直播流代理同一把尺子,LIVE_ALLOW_PRIVATE=1 时自建内网 IPTV 才能测通;
+ // fetchUpstreamWithMeta 内部逐跳做 SSRF 校验,此处不再重复预检(省一次 DNS 解析)
const { res, finalUrl } = await fetchUpstreamWithMeta(url, {
- timeoutMs: TIMEOUT_MS,
+ timeoutMs,
retries: 0,
- headers: { 'User-Agent': UA, Accept: '*/*', Range: 'bytes=0-1' },
+ headers,
+ allowPrivate: true,
});
- const ok = res.ok;
- const status = res.status;
const contentType = res.headers.get('content-type') || '';
- const looksLikeM3u8 =
+ const isM3u8 =
contentType.includes('mpegurl') || contentType.includes('x-mpegurl') ||
url.toLowerCase().split('?')[0].endsWith('.m3u8');
+
let text: string | undefined;
- if (looksLikeM3u8) {
+ if (isM3u8) {
// m3u8 是小文本,读取以供解析;分片则不读取
text = await res.text();
} else if (res.body) {
try { await res.body.cancel(); } catch { /* 忽略 */ }
}
- return { ok, status, text, finalUrl };
+ return { ok: res.ok, status: res.status, text, finalUrl, contentType, isM3u8 };
}
/** 从 media playlist 中取第一个分片/初始化段 URL */
@@ -93,79 +154,204 @@ function firstVariantUrl(content: string, baseUrl: string): string | undefined |
return undefined;
}
+/** 提取 master playlist 的 CODECS 属性 */
+function extractCodecs(content: string): string | undefined {
+ const m = content.match(/CODECS="([^"]+)"/i);
+ return m?.[1]?.trim() || undefined;
+}
+
+const HEADER_OK = /^#EXTM3U/;
+
+function elapsed(start: number): number {
+ return Math.round(performance.now() - start);
+}
+
/** 两级探测:manifest →(master 时穿透 variant)→ 分片 */
async function probeOne(url: string): Promise<ProbeOutcome> {
const start = performance.now();
- const verdict = await checkUpstreamAllowed(url);
- if (!verdict.ok) return { url, ok: false, error: verdict.reason };
+ const deadline = start + URL_BUDGET_MS;
+ const remaining = () => deadline - performance.now();
+
+ const referer = refererOf(url);
+ const timeout = () => Math.max(500, Math.round(remaining()));
try {
// 第一级:入口地址
- const entry = await fetchHeadersOnly(url);
+ const entry = await fetchHeadersOnly(url, timeout(), referer);
if (!entry.ok) {
return { url, ok: false, status: entry.status, ms: elapsed(start), error: `入口响应 ${entry.status}` };
}
- // 非 m3u8(FLV/TS 直链):单级判定
- if (!entry.text) {
+
+ // 非 m3u8(FLV/TS 直链):拒绝明显的网页/接口响应,其余单级判定
+ if (!entry.isM3u8) {
+ if (isWebPageType(entry.contentType)) {
+ return {
+ url,
+ ok: false,
+ status: entry.status,
+ ms: elapsed(start),
+ error: `返回内容不是流媒体(${entry.contentType.split(';')[0]})`,
+ };
+ }
return { url, ok: true, status: entry.status, ms: elapsed(start), level: 'head' };
}
+ // m3u8 必须含 #EXTM3U 头,否则是伪装的 HTML/错误页
+ const entryText = (entry.text || '').replace(/^\uFEFF/, '').trimStart();
+ if (!HEADER_OK.test(entryText)) {
+ return { url, ok: false, status: entry.status, ms: elapsed(start), error: '返回内容不是有效的 m3u8' };
+ }
+
// 第二级:media playlist(master 则先穿透 variant)。
// 相对地址一律以重定向后的最终 URL 为 base(gslb 调度源 302 后路径会变)
let mediaUrl = entry.finalUrl;
- let mediaText = entry.text;
- const variant = firstVariantUrl(entry.text, entry.finalUrl);
+ let mediaText = entryText;
+ let codec = extractCodecs(entryText);
+ const variant = firstVariantUrl(entryText, entry.finalUrl);
if (variant === undefined) {
return { url, ok: false, ms: elapsed(start), error: 'playlist 中没有可用的流地址' };
}
if (variant !== null) {
- const variantVerdict = await checkUpstreamAllowed(variant);
- if (!variantVerdict.ok) {
- return { url, ok: false, ms: elapsed(start), error: `子播放列表被拒绝: ${variantVerdict.reason}` };
- }
- const variantRes = await fetchHeadersOnly(variant);
- if (!variantRes.ok || !variantRes.text) {
- return { url, ok: false, status: variantRes.status, ms: elapsed(start), error: `子播放列表响应 ${variantRes.status}` };
+ const variantRes = await fetchHeadersOnly(variant, timeout(), referer);
+ const variantText = (variantRes.text || '').replace(/^\uFEFF/, '').trimStart();
+ if (!variantRes.ok || !HEADER_OK.test(variantText)) {
+ return {
+ url,
+ ok: false,
+ status: variantRes.status,
+ ms: elapsed(start),
+ error: `子播放列表响应 ${variantRes.status}`,
+ };
}
mediaUrl = variantRes.finalUrl;
- mediaText = variantRes.text;
- }
- const mediaVerdict = await checkUpstreamAllowed(mediaUrl);
- if (!mediaVerdict.ok) {
- return { url, ok: false, ms: elapsed(start), error: `播放列表被拒绝: ${mediaVerdict.reason}` };
+ mediaText = variantText;
+ codec = codec ?? extractCodecs(variantText);
}
// 第三级:分片
const segmentUrl = firstSegmentUrl(mediaText, mediaUrl);
if (!segmentUrl) {
// 空 media playlist(直播源刚启动/无分片)视为 manifest 级通过
- return { url, ok: true, status: entry.status, ms: elapsed(start), level: 'manifest' };
- }
- const segmentVerdict = await checkUpstreamAllowed(segmentUrl);
- if (!segmentVerdict.ok) {
- return { url, ok: false, ms: elapsed(start), error: `分片地址被拒绝: ${segmentVerdict.reason}` };
+ return { url, ok: true, status: entry.status, ms: elapsed(start), level: 'manifest', codec };
}
- const segment = await fetchHeadersOnly(segmentUrl);
+ const segmentStart = performance.now();
+ const segment = await fetchHeadersOnly(segmentUrl, Math.min(timeout(), SEGMENT_TIMEOUT_MS), referer);
+ // ms 只统计分片往返:三级累计耗时当作「延迟」对用户没有参考意义
+ const segmentMs = elapsed(segmentStart);
return {
url,
ok: segment.ok,
status: segment.status,
- ms: elapsed(start),
+ ms: segmentMs,
level: 'segment',
+ codec,
error: segment.ok ? undefined : `分片响应 ${segment.status}`,
};
} catch (err) {
+ const timedOut = performance.now() >= deadline;
return {
url,
ok: false,
ms: elapsed(start),
- error: err instanceof Error ? err.message : '探测失败',
+ error: timedOut ? `探测超时(${URL_BUDGET_MS}ms)` : err instanceof Error ? err.message : '探测失败',
};
}
}
-function elapsed(start: number): number {
- return Math.round(performance.now() - start);
+const NDJSON_HEADERS = {
+ 'Content-Type': 'application/x-ndjson; charset=utf-8',
+ 'Cache-Control': 'no-store, no-transform',
+ // 禁用反代缓冲,保证每条结果立即到达客户端
+ 'X-Accel-Buffering': 'no',
+};
+
+/**
+ * 流式测活:命中缓存的结果立即推送,其余探测完成一条推一条(NDJSON)。
+ * 相比整批等待最慢的一条,前端状态点可以边测边亮。
+ * 客户端断开(切筛选/关页)时 req.signal 触发,worker 停止且不再写入。
+ */
+function ndjsonResponse(urls: string[], reqSignal: AbortSignal): Response {
+ const encoder = new TextEncoder();
+ const cachedOutcomes: ProbeOutcome[] = [];
+ const pending: string[] = [];
+ for (const u of urls) {
+ const hit = cacheGet(u);
+ if (hit) cachedOutcomes.push(hit);
+ else pending.push(u);
+ }
+
+ let closed = false;
+ const stream = new ReadableStream<Uint8Array>({
+ start(controller) {
+ const send = (o: ProbeOutcome) => {
+ if (closed) return;
+ try {
+ controller.enqueue(encoder.encode(JSON.stringify(o) + '\n'));
+ } catch {
+ closed = true;
+ }
+ };
+ const finish = () => {
+ if (closed) return;
+ closed = true;
+ try { controller.close(); } catch { /* 已关闭 */ }
+ };
+ reqSignal.addEventListener('abort', () => { closed = true; }, { once: true });
+
+ for (const o of cachedOutcomes) send(o);
+
+ let cursor = 0;
+ const worker = async () => {
+ while (cursor < pending.length) {
+ if (closed || reqSignal.aborted) return;
+ const url = pending[cursor++];
+ const outcome = await probeOne(url);
+ if (closed || reqSignal.aborted) return;
+ cacheSet(url, outcome);
+ send(outcome);
+ }
+ };
+ void Promise.all(Array.from({ length: Math.min(CONCURRENCY, pending.length) }, worker))
+ .then(finish)
+ .catch(finish);
+ },
+ cancel() {
+ // 客户端主动断开
+ closed = true;
+ },
+ });
+
+ return new NextResponse(stream, { headers: NDJSON_HEADERS });
+}
+
+/** 结果短 TTL 缓存:成功 10min、失败 2min,避免多用户重复测活打爆上游 */
+const probeCache = new Map<string, { outcome: ProbeOutcome; expiresAt: number }>();
+
+function cacheGet(url: string): ProbeOutcome | undefined {
+ const entry = probeCache.get(url);
+ if (!entry) return undefined;
+ if (Date.now() > entry.expiresAt) {
+ probeCache.delete(url);
+ return undefined;
+ }
+ return entry.outcome;
+}
+
+function cacheSet(url: string, outcome: ProbeOutcome): void {
+ if (probeCache.size >= CACHE_MAX_ENTRIES) {
+ const now = Date.now();
+ for (const [k, v] of probeCache) {
+ if (now > v.expiresAt) probeCache.delete(k);
+ }
+ if (probeCache.size >= CACHE_MAX_ENTRIES) {
+ const oldest = probeCache.keys().next().value;
+ if (oldest !== undefined) probeCache.delete(oldest);
+ }
+ }
+ probeCache.set(url, {
+ outcome,
+ expiresAt: Date.now() + (outcome.ok ? CACHE_TTL_OK_MS : CACHE_TTL_FAIL_MS),
+ });
}
export async function POST(req: Request) {
@@ -183,18 +369,35 @@ export async function POST(req: Request) {
const urls = [...new Set(
body.urls.filter((u): u is string => typeof u === 'string' && /^https?:\/\//.test(u))
)].slice(0, MAX_URLS);
- if (urls.length === 0) return NextResponse.json({ results: [] });
+ const stream = new URL(req.url).searchParams.get('stream') === '1';
+ if (urls.length === 0) {
+ return stream
+ ? new NextResponse('', { headers: NDJSON_HEADERS })
+ : NextResponse.json({ results: [] });
+ }
+
+ if (stream) return ndjsonResponse(urls, req.signal);
- // 简单并发池:固定 worker 数从游标取任务
const outcomes = new Map<string, ProbeOutcome>();
+ // 先命中缓存,减少需要真实探测的目标
+ const pending: string[] = [];
+ for (const u of urls) {
+ const hit = cacheGet(u);
+ if (hit) outcomes.set(u, hit);
+ else pending.push(u);
+ }
+
+ // 简单并发池:固定 worker 数从游标取任务(单线程内 cursor++ 无 await 间隙,无竞态)
let cursor = 0;
const worker = async () => {
- while (cursor < urls.length) {
- const url = urls[cursor++];
- outcomes.set(url, await probeOne(url));
+ while (cursor < pending.length) {
+ const url = pending[cursor++];
+ const outcome = await probeOne(url);
+ cacheSet(url, outcome);
+ outcomes.set(url, outcome);
}
};
- await Promise.all(Array.from({ length: Math.min(CONCURRENCY, urls.length) }, worker));
+ await Promise.all(Array.from({ length: Math.min(CONCURRENCY, pending.length) }, worker));
return NextResponse.json(
{ results: urls.map((u) => outcomes.get(u)!) },
diff --git a/src/components/live-channel-list.tsx b/src/components/live-channel-list.tsx
index cdca8af..43398d8 100644
--- a/src/components/live-channel-list.tsx
+++ b/src/components/live-channel-list.tsx
@@ -121,7 +121,7 @@ export function LiveChannelList({ channels, groups, currentUrl, onSelect }: Chan
className="btn-ghost !py-1 !px-2 text-xs"
disabled={isProbing || filtered.length === 0}
onClick={() => void probe(filtered)}
- title="轻量探测当前列表频道的可达性与延迟(每批 10 条并发探测,结果 6 小时内有效)"
+ title="探测当前列表频道是否可播(分片级校验,每批 50 条并发,结果 6 小时内有效)"
>
⚡ 测活
</button>
@@ -252,6 +252,16 @@ function ChannelRow({
if (active) ref.current?.scrollIntoView({ block: 'nearest' });
}, [active]);
+ // H.265/HEVC:国内 IPTV 常见,测活通过但 Chromium 内核通常无法软解
+ const isHevc = Boolean(probe?.codec && /hvc1|hev1|hevc/i.test(probe.codec));
+ const levelText =
+ probe?.level === 'segment' ? '分片可用' : probe?.level === 'head' ? '直链可达' : 'manifest 可用';
+ const probeTitle = probe
+ ? probe.ok
+ ? `${levelText}${probe.ms != null ? ` · 分片耗时 ${probe.ms}ms` : ''}${isHevc ? ' · H.265 编码,需 Edge/Safari' : ''}`
+ : probe.error || '不可用'
+ : undefined;
+
return (
<li ref={ref}>
<div
@@ -301,12 +311,20 @@ function ChannelRow({
'w-1.5 h-1.5 rounded-full shrink-0',
probe.ok ? 'bg-green-500' : 'bg-red-400'
)}
- title={probe.ok ? `${probe.level === 'segment' ? '分片可用' : 'manifest 可用'} · ${probe.ms}ms` : probe.error || '不可用'}
+ title={probeTitle}
/>
)}
<span className={cn('text-xs truncate', active ? 'text-accent font-medium' : 'text-content')}>
{channel.name}
</span>
+ {isHevc && (
+ <span
+ className="shrink-0 rounded bg-amber-500/15 px-1 text-[9px] font-medium text-amber-500"
+ title="H.265 编码:测活通过但 Chromium 内核通常无法解码,建议用 Edge/Safari"
+ >
+ H.265
+ </span>
+ )}
</div>
{channel.group && (
<div className="text-[10px] text-faint truncate">{channel.group}</div>
diff --git a/src/components/use-live-probe.ts b/src/components/use-live-probe.ts
index 688eae4..3c0aaf8 100644
--- a/src/components/use-live-probe.ts
+++ b/src/components/use-live-probe.ts
@@ -8,8 +8,9 @@ import { LIVE_PROBE_TTL_MS, useAppStore, type LiveProbeEntry } from '@/lib/store
* 直播频道批量测活 hook:
* - 结果持久化到 store(liveProbeResults),6 小时内直接复用(LIVE_PROBE_TTL_MS);
* - 触发探测时只补测缺失或已过期的频道,全部仍有效则提示跳过;
- * - 目标列表分批(每批 10 条)顺序发给 /api/live/probe,服务端批内并发 8;
- * - 再次调用自动作废上一轮(runId 比对),clear 重置。
+ * - 服务端以 NDJSON 流式逐条返回,结果边测边写入列表(节流合并,避免高频 re-render);
+ * - 每批 CHUNK_SIZE 条并行 CHUNK_CONCURRENCY 批,服务端批内并发 16;
+ * - 重新测活/清空时 abort 在途请求并作废上一轮(runId 比对)。
*/
export interface ProbeResult {
@@ -17,10 +18,15 @@ export interface ProbeResult {
ms?: number;
level?: 'segment' | 'manifest' | 'head';
error?: string;
+ codec?: string;
}
-const CHUNK_SIZE = 10;
+const CHUNK_SIZE = 50;
+/** 同时在途的批次数:与 CHUNK_SIZE 相乘即最大并发探测规模 */
+const CHUNK_CONCURRENCY = 2;
const MAX_TARGETS = 400;
+/** 流式结果的写回节流间隔:把高频到达的结果合并成一次 store 更新 */
+const FLUSH_INTERVAL_MS = 200;
export function useLiveProbe() {
const cache = useAppStore((s) => s.liveProbeResults);
@@ -28,6 +34,7 @@ export function useLiveProbe() {
const [hint, setHint] = useState('');
const runIdRef = useRef(0);
const hintTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+ const abortRef = useRef<AbortController | null>(null);
const showHint = useCallback((text: string) => {
setHint(text);
@@ -36,7 +43,10 @@ export function useLiveProbe() {
}, []);
useEffect(() => () => {
+ // 卸载时作废在途轮次并断开请求
+ runIdRef.current++;
if (hintTimerRef.current) clearTimeout(hintTimerRef.current);
+ abortRef.current?.abort();
}, []);
// 仅暴露 6 小时内的结果,过期条目对 UI 不可见
@@ -45,7 +55,7 @@ export function useLiveProbe() {
const map = new Map<string, ProbeResult>();
for (const [url, e] of Object.entries(cache)) {
if (now - e.timestamp < LIVE_PROBE_TTL_MS) {
- map.set(url, { ok: e.ok, ms: e.ms, level: e.level, error: e.error });
+ map.set(url, { ok: e.ok, ms: e.ms, level: e.level, error: e.error, codec: e.codec });
}
}
return map;
@@ -53,6 +63,8 @@ export function useLiveProbe() {
const clear = useCallback(() => {
runIdRef.current++;
+ abortRef.current?.abort();
+ abortRef.current = null;
useAppStore.getState().clearLiveProbeResults();
setProgress(null);
}, []);
@@ -75,31 +87,82 @@ export function useLiveProbe() {
}
const runId = ++runIdRef.current;
+ // 作废上一轮的在途请求,避免切换筛选/重复点击后旧结果继续写回
+ abortRef.current?.abort();
+ const controller = new AbortController();
+ abortRef.current = controller;
+
+ const chunks: string[][] = [];
+ for (let i = 0; i < stale.length; i += CHUNK_SIZE) {
+ chunks.push(stale.slice(i, i + CHUNK_SIZE));
+ }
setProgress({ done: 0, total: stale.length });
- const writeToCache = (entries: Record<string, LiveProbeEntry>) => {
+ let done = 0;
+ let buffer: Record<string, LiveProbeEntry> = {};
+ let flushTimer: ReturnType<typeof setTimeout> | null = null;
+
+ const flush = () => {
+ if (flushTimer) {
+ clearTimeout(flushTimer);
+ flushTimer = null;
+ }
if (runIdRef.current !== runId) return;
- useAppStore.getState().setLiveProbeResults(entries);
+ if (Object.keys(buffer).length > 0) {
+ const entries = buffer;
+ buffer = {};
+ useAppStore.getState().setLiveProbeResults(entries);
+ }
+ setProgress({ done: Math.min(done, stale.length), total: stale.length });
+ };
+ const scheduleFlush = () => {
+ if (!flushTimer) flushTimer = setTimeout(flush, FLUSH_INTERVAL_MS);
};
- for (let i = 0; i < stale.length; i += CHUNK_SIZE) {
- if (runIdRef.current !== runId) return;
- const chunk = stale.slice(i, i + CHUNK_SIZE);
- try {
- const { results: list } = await api.liveProbe(chunk);
- const entries: Record<string, LiveProbeEntry> = {};
- for (const r of list) {
- entries[r.url] = { ok: r.ok, ms: r.ms, level: r.level, error: r.error, timestamp: Date.now() };
+ let nextChunk = 0;
+ const worker = async () => {
+ for (;;) {
+ if (runIdRef.current !== runId) return;
+ const index = nextChunk++;
+ if (index >= chunks.length) return;
+ const chunk = chunks[index];
+ const received = new Set<string>();
+ try {
+ await api.liveProbeStream(
+ chunk,
+ (r) => {
+ received.add(r.url);
+ if (runIdRef.current !== runId) return;
+ buffer[r.url] = {
+ ok: r.ok,
+ ms: r.ms,
+ level: r.level,
+ error: r.error,
+ codec: r.codec,
+ timestamp: Date.now(),
+ };
+ done++;
+ scheduleFlush();
+ },
+ controller.signal
+ );
+ } catch {
+ // 整批失败/被取消:不写缓存,保持待测状态以便下次重试
}
- writeToCache(entries);
- } catch {
- // 整批请求失败(网络断开等):不写缓存,保持待测状态以便下次重试
+ // 流中途断开时未返回的目标:只补进度,不写缓存
+ done += chunk.length - received.size;
+ flush();
}
- if (runIdRef.current !== runId) return;
- setProgress({ done: Math.min(i + CHUNK_SIZE, stale.length), total: stale.length });
- }
+ };
+ await Promise.all(
+ Array.from({ length: Math.min(CHUNK_CONCURRENCY, chunks.length) }, worker)
+ );
+
+ if (flushTimer) clearTimeout(flushTimer);
if (runIdRef.current !== runId) return;
+ flush();
setProgress(null);
+ if (abortRef.current === controller) abortRef.current = null;
},
[showHint]
);
diff --git a/src/lib/client-api.ts b/src/lib/client-api.ts
index ce44cf2..81fe9fd 100644
--- a/src/lib/client-api.ts
+++ b/src/lib/client-api.ts
@@ -17,6 +17,20 @@ export class ApiError extends Error {
const UNAUTHORIZED_EVENT = 'libretv:unauthorized';
+/** 单条测活结果(/api/live/probe,JSON 与 NDJSON 流共用同一结构) */
+export interface LiveProbeResult {
+ url: string;
+ ok: boolean;
+ status?: number;
+ /** 分片级探测:仅统计分片往返耗时 */
+ ms?: number;
+ /** segment=分片级(最可信)/ manifest=仅列表可达 / head=直链单级 */
+ level?: 'segment' | 'manifest' | 'head';
+ error?: string;
+ /** master playlist 的 CODECS,用于前端提示 H.265 等不可解码情况 */
+ codec?: string;
+}
+
export function onUnauthorized(handler: (event: CustomEvent) => void): () => void {
const wrapped = (e: Event) => handler(e as CustomEvent);
window.addEventListener(UNAUTHORIZED_EVENT, wrapped);
@@ -148,15 +162,67 @@ export const api = {
},
/** 批量测活:分片级探测频道可达性与延迟(单批最多 50 条) */
- liveProbe: (urls: string[]) =>
- request<{ results: { url: string; ok: boolean; status?: number; ms?: number; level?: 'segment' | 'manifest' | 'head'; error?: string }[] }>(
+ liveProbe: (urls: string[], signal?: AbortSignal) =>
+ request<{ results: LiveProbeResult[] }>(
'/api/live/probe',
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ urls }),
+ signal,
}
),
+
+ /**
+ * 流式测活:服务端以 NDJSON 逐条推送(命中缓存的立即返回),
+ * 结果边测边回调,列表状态点可以边测边亮。
+ */
+ liveProbeStream: async (
+ urls: string[],
+ onResult: (result: LiveProbeResult) => void,
+ signal?: AbortSignal
+ ): Promise<void> => {
+ const res = await fetch('/api/live/probe?stream=1', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ urls }),
+ signal,
+ });
+ if (res.status === 401) {
+ window.dispatchEvent(new CustomEvent(UNAUTHORIZED_EVENT));
+ throw new ApiError('需要登录', 401);
+ }
+ if (res.status === 503) {
+ window.dispatchEvent(new CustomEvent(UNAUTHORIZED_EVENT, { detail: 'setup' }));
+ throw new ApiError('服务器未配置密码', 503);
+ }
+ if (!res.ok || !res.body) throw new ApiError(`请求失败 (${res.status})`, res.status);
+
+ const reader = res.body.getReader();
+ const decoder = new TextDecoder();
+ let buffer = '';
+ const consume = (line: string) => {
+ const text = line.trim();
+ if (!text) return;
+ try {
+ onResult(JSON.parse(text) as LiveProbeResult);
+ } catch {
+ // 坏行跳过,不影响其余结果
+ }
+ };
+ for (;;) {
+ const { done, value } = await reader.read();
+ if (done) break;
+ buffer += decoder.decode(value, { stream: true });
+ let idx: number;
+ while ((idx = buffer.indexOf('\n')) >= 0) {
+ consume(buffer.slice(0, idx));
+ buffer = buffer.slice(idx + 1);
+ }
+ }
+ buffer += decoder.decode();
+ consume(buffer);
+ },
};
export interface SearchFailure {
diff --git a/src/lib/fetch-utils.ts b/src/lib/fetch-utils.ts
index ad69170..49dd7ee 100644
--- a/src/lib/fetch-utils.ts
+++ b/src/lib/fetch-utils.ts
@@ -1,6 +1,6 @@
/** 服务端上游请求工具:超时、重试、安全跳转、JSON 解析 */
-import { checkUpstreamAllowed } from './ssrf';
+import { checkLiveUrlAllowed, checkUpstreamAllowed } from './ssrf';
export interface FetchOptions extends RequestInit {
timeoutMs?: number;
@@ -10,6 +10,11 @@ export interface FetchOptions extends RequestInit {
* 每一跳重新执行 SSRF 校验——否则公网 URL 可 302 跳转到内网地址绕过预检。
*/
safeRedirects?: boolean;
+ /**
+ * 直播场景放行内网地址(自建 IPTV):仅在部署者设置 LIVE_ALLOW_PRIVATE=1 时生效。
+ * 校验复用 checkLiveUrlAllowed,与直播流代理使用同一把尺子。
+ */
+ allowPrivate?: boolean;
}
const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
@@ -28,7 +33,7 @@ export async function fetchUpstream(url: string, options: FetchOptions = {}): Pr
/** 同 fetchUpstream,额外返回重定向后的最终 URL */
export async function fetchUpstreamWithMeta(url: string, options: FetchOptions = {}): Promise<FetchResult> {
- const { timeoutMs = 8000, retries = 0, safeRedirects = true, ...init } = options;
+ const { timeoutMs = 8000, retries = 0, safeRedirects = true, allowPrivate = false, ...init } = options;
let lastError: unknown;
for (let attempt = 0; attempt <= retries; attempt++) {
try {
@@ -43,7 +48,9 @@ export async function fetchUpstreamWithMeta(url: string, options: FetchOptions =
// 手动逐跳跟随,每一跳重新过 SSRF 校验
let current = url;
for (let hop = 0; hop <= MAX_REDIRECT_HOPS; hop++) {
- const verdict = await checkUpstreamAllowed(current);
+ const verdict = allowPrivate
+ ? await checkLiveUrlAllowed(current)
+ : await checkUpstreamAllowed(current);
if (!verdict.ok) {
throw new Error(`跳转目标被拒绝: ${verdict.reason}`);
}
diff --git a/src/lib/store.ts b/src/lib/store.ts
index 67cb421..9d27e26 100644
--- a/src/lib/store.ts
+++ b/src/lib/store.ts
@@ -72,6 +72,8 @@ export interface LiveProbeEntry {
ms?: number;
level?: 'segment' | 'manifest' | 'head';
error?: string;
+ /** 流编码(master playlist 的 CODECS 属性),用于提示 H.265 等不可解码情况 */
+ codec?: string;
/** 测活时间戳(epoch ms),配合 TTL 判断有效性 */
timestamp: number;
}