@flow-player/test-streams 0.6.0

package/src/server/live.ts

@@ -0,0 +1,220 @@
+// /streams/live/<format>/<codec> 路径按需 spawn ffmpeg 子进程,
+// pipe stdout 给 HTTP response,stream 永远不 EOF。
+// ffmpeg 用 -stream_loop -1 + -re 实时速率无限循环,让浏览器端 fetch
+// 持续拿到新字节,player.metrics 长时间累计,模拟真实 live 验收。
+import { type ChildProcessByStdio, spawn } from "node:child_process";
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import { type Readable } from "node:stream";
+import { type CodecId, type FormatId } from "../config.ts";
+import { CODEC_SPEC } from "../fixtures/codec.ts";
+import { writeJson } from "./static.ts";
+
+const LIVE_MIME: Record<FormatId, string> = {
+  flv: "video/x-flv",
+  hls: "application/vnd.apple.mpegurl",
+  mp4: "video/mp4",
+  fmp4: "video/iso.segment",
+  ts: "video/mp2t",
+};
+
+const CODEC_SET: Record<string, true> = { h264: true, hevc: true };
+const FORMAT_SET: Record<string, true> = { flv: true, hls: true, mp4: true, fmp4: true, ts: true };
+
+const LIVE_PATTERN = /^\/streams\/live\/([a-z0-9]+)\/([a-z0-9]+)\/?$/;
+
+export function matchLivePath(path: string): { format: FormatId; codec: CodecId } | null {
+  const match = LIVE_PATTERN.exec(path);
+  if (!match) return null;
+  const [, formatRaw, codecRaw] = match;
+  if (!FORMAT_SET[formatRaw] || !CODEC_SET[codecRaw]) return null;
+  return { format: formatRaw as FormatId, codec: codecRaw as CodecId };
+}
+
+export type LiveStreamOptions = {
+  ffmpegPath?: string;
+  width?: number;
+  height?: number;
+  fps?: number;
+  bitrate?: string;
+};
+
+export function handleLiveStream(
+  req: IncomingMessage,
+  res: ServerResponse,
+  format: FormatId,
+  codec: CodecId,
+  options: LiveStreamOptions = {},
+): void {
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    res.writeHead(405, { Allow: "GET, HEAD, OPTIONS" });
+    res.end("Method Not Allowed\n");
+    return;
+  }
+  if (format === "hls") {
+    writeJson(res, 501, {
+      error: "HLS live streaming not yet supported in this build",
+      reason:
+        "use /streams/live/flv/hevc etc. for non-HLS live, or /streams/hls/hevc/master.m3u8 for VOD HLS",
+    });
+    return;
+  }
+  const ffmpegPath = options.ffmpegPath ?? "ffmpeg";
+  const width = options.width ?? 1280;
+  const height = options.height ?? 720;
+  const fps = options.fps ?? 25;
+  const bitrate = options.bitrate ?? "1500k";
+  const spec = CODEC_SPEC[codec];
+  const mime = LIVE_MIME[format];
+  const ffmpegArgs = buildLiveFfmpegArgs(format, codec, spec, {
+    width,
+    height,
+    fps,
+    bitrate,
+  });
+
+  if (req.method === "HEAD") {
+    res.writeHead(200, {
+      "Content-Type": mime,
+      "Access-Control-Allow-Origin": "*",
+      "X-Live-Source": "ffmpeg-stream-loop",
+    });
+    res.end();
+    return;
+  }
+
+  let proc: ChildProcessByStdio<null, Readable, Readable>;
+  try {
+    proc = spawn(ffmpegPath, ffmpegArgs, { stdio: ["ignore", "pipe", "pipe"] });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    writeJson(res, 503, { error: "ffmpeg spawn failed", reason: message });
+    return;
+  }
+
+  proc.once("error", (err) => {
+    if (!res.headersSent) {
+      writeJson(res, 503, { error: "ffmpeg failed to start", reason: err.message });
+      return;
+    }
+    res.destroy(err);
+  });
+
+  // ffmpeg 第一帧到达前 stderr 经常有 stat 消息;等 stdout 第一字节再发 head。
+  proc.stdout.once("data", () => {
+    if (!res.headersSent) {
+      res.writeHead(200, {
+        "Content-Type": mime,
+        "Access-Control-Allow-Origin": "*",
+        "Transfer-Encoding": "chunked",
+        "X-Live-Source": "ffmpeg-stream-loop",
+      });
+    }
+  });
+
+  proc.stdout.pipe(res);
+
+  const cleanup = (): void => {
+    if (!proc.killed) proc.kill("SIGKILL");
+  };
+  req.once("close", cleanup);
+  res.once("close", cleanup);
+}
+
+type FfmpegSpec = {
+  encoder: string;
+  videoArgs: ReadonlyArray<string>;
+  audioArgs: ReadonlyArray<string>;
+  pixelFormat: string;
+};
+
+type LiveFfmpegOptions = {
+  width: number;
+  height: number;
+  fps: number;
+  bitrate: string;
+};
+
+function buildLiveFfmpegArgs(
+  format: FormatId,
+  codec: CodecId,
+  spec: FfmpegSpec,
+  opts: LiveFfmpegOptions,
+): string[] {
+  const gop = String(opts.fps);
+  const videoInput = `testsrc2=size=${opts.width}x${opts.height}:rate=${opts.fps},format=yuv420p`;
+  const audioInput = `sine=frequency=1000:sample_rate=44100`;
+  const hevcTag = codec === "hevc" && format === "mp4" ? ["-tag:v", "hvc1"] : [];
+
+  const baseArgs = [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-fflags",
+    "+genpts",
+    "-re",
+    "-stream_loop",
+    "-1",
+    "-f",
+    "lavfi",
+    "-i",
+    videoInput,
+    "-f",
+    "lavfi",
+    "-i",
+    audioInput,
+    "-c:v",
+    spec.encoder,
+    ...spec.videoArgs,
+    ...liveLowLatencyVideoArgs(codec),
+    "-pix_fmt",
+    spec.pixelFormat,
+    "-g",
+    gop,
+    "-keyint_min",
+    gop,
+    "-sc_threshold",
+    "0",
+    "-b:v",
+    opts.bitrate,
+    ...hevcTag,
+    ...spec.audioArgs,
+  ];
+
+  if (format === "flv") {
+    return [...baseArgs, "-f", "flv", "-flvflags", "no_sequence_end", "-"];
+  }
+  if (format === "mp4") {
+    return [
+      ...baseArgs,
+      "-f",
+      "mp4",
+      "-movflags",
+      "+faststart+frag_keyframe+empty_moov+default_base_moof",
+      "-",
+    ];
+  }
+  if (format === "fmp4") {
+    return [
+      ...baseArgs,
+      "-f",
+      "mp4",
+      "-movflags",
+      "frag_keyframe+empty_moov+default_base_moof",
+      "-frag_duration",
+      "2000000",
+      "-",
+    ];
+  }
+  if (format === "ts") {
+    return [...baseArgs, "-f", "mpegts", "-"];
+  }
+  // hls 已在 handleLiveStream 早返;此处 unreachable。
+  throw new Error(`Unknown format: ${String(format)}`);
+}
+
+function liveLowLatencyVideoArgs(codec: CodecId): string[] {
+  if (codec === "h264" || codec === "hevc") {
+    return ["-tune", "zerolatency"];
+  }
+  return [];
+}

package/src/server/routes.ts

@@ -0,0 +1,141 @@
+// 路由表:/streams/health、/streams/list、/streams/vod-list、/streams/:format/:codec、
+// /streams/(hls|fmp4)/:codec/...、/streams/vod/:name。
+// resolveRoute() 把 path 解析成 fixture-relative 路径;handleXxx 负责写 JSON 响应。
+import { type ServerResponse } from "node:http";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ALL_CODECS, ALL_FORMATS, type CodecId, type FormatId } from "../config.ts";
+import { type Manifest, summarizeCatalog } from "../fixtures/catalog.ts";
+import { writeJson } from "./static.ts";
+
+const FORMAT_SET: Record<string, true> = Object.fromEntries(ALL_FORMATS.map((f) => [f, true]));
+const CODEC_SET: Record<string, true> = Object.fromEntries(ALL_CODECS.map((c) => [c, true]));
+const HLS_FMP4: Record<string, true> = { hls: true, fmp4: true };
+
+const SINGLE = /^\/streams\/([a-z0-9]+)\/([a-z0-9]+)\/?$/;
+const PLAYLIST = /^\/streams\/(hls|fmp4)\/([a-z0-9]+)\/(.+)$/;
+const VOD = /^\/streams\/vod\/([a-zA-Z0-9._-]+)\/?$/;
+
+export function resolveRoute(path: string): string | null {
+  // 单文件:/streams/flv/h264、/streams/mp4/hevc、/streams/ts/h264
+  const single = SINGLE.exec(path);
+  if (single) {
+    const [, formatRaw, codecRaw] = single;
+    if (!FORMAT_SET[formatRaw] || !CODEC_SET[codecRaw]) return null;
+    if (HLS_FMP4[formatRaw]) return null; // hls/fmp4 必须带子文件路径
+    const format = formatRaw as FormatId;
+    const codec = codecRaw as CodecId;
+    return join(format, `${codec}.${format}`);
+  }
+  // playlist 内子文件
+  const playlist = PLAYLIST.exec(path);
+  if (playlist) {
+    const [, formatRaw, codecRaw, rest] = playlist;
+    if (!FORMAT_SET[formatRaw] || !CODEC_SET[codecRaw]) return null;
+    return join(formatRaw, codecRaw, rest);
+  }
+  // /streams/vod/:name
+  const vod = VOD.exec(path);
+  if (vod) {
+    const [, name] = vod;
+    return join("vod", name);
+  }
+  return null;
+}
+
+export function handleHealth(
+  res: ServerResponse,
+  manifest: Manifest | null,
+  fixtureDir: string,
+): void {
+  const summary = summarizeCatalog(fixtureDir);
+  const status = manifest ? 200 : 503;
+  writeJson(res, status, {
+    status: summary.exists ? "ok" : "down",
+    codecs: summary.codecs,
+    formats: summary.formats,
+    fixtures: summary.fixtureCount,
+    reason: manifest ? undefined : summary.reason,
+  });
+}
+
+export function handleList(res: ServerResponse, manifest: Manifest | null): void {
+  if (!manifest) {
+    writeJson(res, 503, { error: "manifest not found" });
+    return;
+  }
+  writeJson(res, 200, manifest);
+}
+
+export type VodSegmentDescriptor = {
+  url: string;
+  startTimestamp: number;
+  endTimestamp: number;
+  timeLen: number;
+  fileSize: number;
+  channelID: number;
+  RecordType: number;
+};
+
+export type VodListResponse = {
+  segments: ReadonlyArray<VodSegmentDescriptor>;
+};
+
+export function handleVodList(
+  res: ServerResponse,
+  manifest: Manifest | null,
+  fixtureDir: string,
+): void {
+  // 优先读 vod-list.json(由 extend-vod CLI 生成),支持任意段数 + 段长。
+  const vodListPath = join(fixtureDir, "vod", "vod-list.json");
+  if (existsSync(vodListPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(vodListPath, "utf8")) as {
+        entries: ReadonlyArray<{ path: string; size: number }>;
+      };
+      const segMs = manifest?.durationSeconds ? manifest.durationSeconds * 1000 : 0;
+      const segments: VodSegmentDescriptor[] = raw.entries.map((e, i) => ({
+        url: `/streams/${e.path}`,
+        startTimestamp: i * segMs,
+        endTimestamp: (i + 1) * segMs,
+        timeLen: segMs,
+        fileSize: e.size,
+        channelID: 1,
+        RecordType: 1,
+      }));
+      writeJson(res, 200, { segments });
+      return;
+    } catch {
+      // fallthrough to legacy 2-segment path
+    }
+  }
+  if (!manifest) {
+    writeJson(res, 503, { error: "manifest not found" });
+    return;
+  }
+  const h264mp4 = manifest.fixtures.find((f) => f.codec === "h264" && f.format === "mp4");
+  const fileSize = h264mp4?.entries[0]?.size ?? 0;
+  const durMs = manifest.durationSeconds * 1000;
+  writeJson(res, 200, {
+    segments: [
+      {
+        url: "/streams/vod/sample-1.mp4",
+        startTimestamp: 0,
+        endTimestamp: durMs,
+        timeLen: durMs,
+        fileSize,
+        channelID: 1,
+        RecordType: 1,
+      },
+      {
+        url: "/streams/vod/sample-2.mp4",
+        startTimestamp: durMs,
+        endTimestamp: durMs * 2,
+        timeLen: durMs,
+        fileSize,
+        channelID: 1,
+        RecordType: 1,
+      },
+    ],
+  });
+}

package/src/server/server.ts

@@ -0,0 +1,193 @@
+// Streams HTTP(S) server:托管 @flow-player/test-streams/fixtures 下生成的全部 fixture。
+// 与 browser-playback-proxy-server 职责分离:本服务只读本地磁盘,不转发 LAN 上游。
+import { createReadStream, readFileSync } from "node:fs";
+import {
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+  createServer as createHttpServer,
+} from "node:http";
+import { createServer as createHttpsServer } from "node:https";
+import { type AddressInfo } from "node:net";
+import { extname, resolve, sep } from "node:path";
+import { DEFAULT_HOST, DEFAULT_PORT } from "../config.ts";
+import { type Manifest, loadManifest } from "../fixtures/catalog.ts";
+import { applyCors, setRangeHeaders, writeBadRequest, writeNotFound } from "./static.ts";
+import { handleHealth, handleList, handleVodList, resolveRoute } from "./routes.ts";
+import { handleLiveStream, matchLivePath } from "./live.ts";
+export type StreamsServerHandle = {
+  server: Server;
+  port: number;
+  host: string;
+  close: () => Promise<void>;
+  refreshManifest: () => Manifest | null;
+};
+
+export type StreamsServerOptions = {
+  port?: number;
+  host?: string;
+  fixtureDir: string;
+  cert?: string;
+  key?: string;
+};
+
+export function createStreamsServer(options: StreamsServerOptions): StreamsServerHandle {
+  const host = options.host ?? DEFAULT_HOST;
+  const port = options.port ?? DEFAULT_PORT;
+  const fixtureDir = resolve(options.fixtureDir);
+
+  const ctx: { manifest: Manifest | null; fixtureDir: string } = {
+    manifest: loadManifest(fixtureDir),
+    fixtureDir,
+  };
+  const refreshManifest = (): Manifest | null => {
+    ctx.manifest = loadManifest(fixtureDir);
+    return ctx.manifest;
+  };
+
+  const handler = (req: IncomingMessage, res: ServerResponse) => {
+    applyCors(res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS",
+        "Access-Control-Allow-Headers": "Range, Content-Type, If-None-Match",
+      });
+      res.end();
+      return;
+    }
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405, { Allow: "GET, HEAD, OPTIONS" });
+      res.end("Method Not Allowed\n");
+      return;
+    }
+    try {
+      const path = decodePath(req.url ?? "/");
+      if (path.includes("..")) {
+        writeBadRequest(res, "Path traversal not allowed");
+        return;
+      }
+      if (path === "/streams/health" || path === "/streams/health/") {
+        handleHealth(res, ctx.manifest, fixtureDir);
+        return;
+      }
+      if (path === "/streams/list" || path === "/streams/list/") {
+        handleList(res, ctx.manifest);
+        return;
+      }
+      if (path === "/streams/vod-list" || path === "/streams/vod-list/") {
+        handleVodList(res, ctx.manifest, ctx.fixtureDir);
+        return;
+      }
+      const resolved = resolveRoute(path);
+      if (resolved) {
+        serveEntry(req, res, fixtureDir, resolved);
+        return;
+      }
+      const liveMatch = matchLivePath(path);
+      if (liveMatch) {
+        handleLiveStream(req, res, liveMatch.format, liveMatch.codec);
+        return;
+      }
+      writeNotFound(res);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end(`Internal Error: ${message}\n`);
+      } else {
+        res.destroy(err instanceof Error ? err : new Error(message));
+      }
+    }
+  };
+
+  const server =
+    options.cert && options.key
+      ? createHttpsServer(
+          {
+            cert: readFileSync(resolve(options.cert)),
+            key: readFileSync(resolve(options.key)),
+          },
+          handler,
+        )
+      : createHttpServer(handler);
+
+  return {
+    server,
+    port,
+    host,
+    close: () =>
+      new Promise<void>((resolveClose, rejectClose) => {
+        server.close((err) => (err ? rejectClose(err) : resolveClose()));
+      }),
+    refreshManifest,
+  };
+}
+
+export async function listen(server: StreamsServerHandle): Promise<StreamsServerHandle> {
+  const { promise, resolve, reject } = Promise.withResolvers<StreamsServerHandle>();
+  server.server.once("error", reject);
+  server.server.listen(server.port, server.host, () => {
+    const addr = server.server.address() as AddressInfo | null;
+    if (!addr) {
+      reject(new Error("server.address() returned null after listen"));
+      return;
+    }
+    server.port = addr.port;
+    resolve(server);
+  });
+  return promise;
+}
+
+const FIXTURE_MIME: Record<string, string> = {
+  ".flv": "video/x-flv",
+  ".mp4": "video/mp4",
+  ".m4s": "video/iso.segment",
+  ".ts": "video/mp2t",
+  ".m3u8": "application/vnd.apple.mpegurl",
+  ".json": "application/json; charset=utf-8",
+  ".aac": "audio/aac",
+};
+
+function serveEntry(
+  req: IncomingMessage,
+  res: ServerResponse,
+  fixtureDir: string,
+  relPath: string,
+): void {
+  const abs = resolve(fixtureDir, relPath);
+  const rel = relativePosix(fixtureDir, abs);
+  if (rel === "" || rel.startsWith("..") || rel.includes(`..${sep}`)) {
+    writeNotFound(res);
+    return;
+  }
+  const mime = FIXTURE_MIME[extname(abs).toLowerCase()] ?? "application/octet-stream";
+  const rangeInfo = setRangeHeaders(req, res, abs, mime);
+  if (rangeInfo && "alreadyServed" in rangeInfo) return;
+  if (req.method === "HEAD") {
+    res.end();
+    return;
+  }
+  const startEnd = rangeInfo && "start" in rangeInfo ? rangeInfo : null;
+  const stream = startEnd
+    ? createReadStream(abs, { start: startEnd.start, end: startEnd.end })
+    : createReadStream(abs);
+  stream.on("error", (err) => res.destroy(err));
+  stream.pipe(res);
+}
+
+// 手动实现相对路径(避免引入 path.relative 的隐式语义),只接受 fixtureDir 子树。
+function relativePosix(root: string, abs: string): string {
+  if (abs === root) return "";
+  if (abs.startsWith(root + sep)) return abs.slice(root.length + 1);
+  if (abs.startsWith(root)) return abs.slice(root.length);
+  return abs;
+}
+
+function decodePath(rawTarget: string): string {
+  const stripped = rawTarget.split(/[?#]/, 1)[0] || "/";
+  try {
+    return decodeURIComponent(stripped);
+  } catch {
+    return stripped;
+  }
+}

package/src/server/static.ts

@@ -0,0 +1,83 @@
+// 静态文件 + Range 响应 + CORS 头 + JSON/NotFound 工具。
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import { createReadStream, statSync } from "node:fs";
+export function applyCors(res: ServerResponse): void {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Range, Content-Type, If-None-Match");
+}
+
+export function writeJson(res: ServerResponse, status: number, body: unknown): void {
+  const text = JSON.stringify(body);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(text),
+    "Cache-Control": "no-store",
+  });
+  res.end(text);
+}
+
+export function writeNotFound(res: ServerResponse): void {
+  res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+  res.end("Not Found\n");
+}
+
+export function writeBadRequest(res: ServerResponse, message: string): void {
+  res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+  res.end(`${message}\n`);
+}
+
+export function writeStaticFile(res: ServerResponse, fullPath: string, mime: string): void {
+  res.setHeader("Content-Type", mime);
+  res.setHeader("Cache-Control", "no-store");
+  const stream = createReadStream(fullPath);
+  stream.on("error", (err) => res.destroy(err));
+  stream.pipe(res);
+}
+
+// 单段 Range 处理:仅支持 bytes=start-end,不支持 multi-range。
+// 返回 RangeInfo | null:
+//   - { alreadyServed: true }: HEAD 或 416 边界情况, caller 不要再写。
+//   - { start, end }: 有效 Range, caller 需用 createReadStream(abs, {start, end}) + pipe。
+//   - null: 非 Range 请求, caller 用全文件 stream。
+export type RangeInfo = { alreadyServed: true } | { start: number; end: number } | null;
+
+export function setRangeHeaders(
+  req: IncomingMessage,
+  res: ServerResponse,
+  fullPath: string,
+  mime: string,
+): RangeInfo {
+  const stat = statSync(fullPath);
+  const total = stat.size;
+  res.setHeader("Accept-Ranges", "bytes");
+  const range = req.headers.range;
+  if (!range) {
+    res.setHeader("Content-Length", total);
+    res.setHeader("Content-Type", mime);
+    return null;
+  }
+  const match = /^bytes=(\d*)-(\d*)$/.exec(range);
+  if (!match) {
+    res.setHeader("Content-Length", total);
+    res.setHeader("Content-Type", mime);
+    return null;
+  }
+  const startRaw = match[1];
+  const endRaw = match[2];
+  let start = startRaw === "" ? Math.max(0, total - Number(endRaw || 0)) : Number(startRaw);
+  let end = endRaw === "" ? total - 1 : Number(endRaw);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || end >= total) {
+    res.setHeader("Content-Range", `bytes */${total}`);
+    res.writeHead(416);
+    res.end();
+    return { alreadyServed: true };
+  }
+  start = Math.max(0, start);
+  end = Math.min(total - 1, end);
+  res.setHeader("Content-Range", `bytes ${start}-${end}/${total}`);
+  res.setHeader("Content-Length", end - start + 1);
+  res.setHeader("Content-Type", mime);
+  res.statusCode = 206;
+  return { start, end };
+}