@flow-player/test-streams 0.6.0 → 0.6.2

package/dist/fixtures/catalog.js

@@ -0,0 +1,63 @@
+// src/fixtures/catalog.ts
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+
+// src/config.ts
+var ALL_CODECS = ["h264", "hevc"];
+var ALL_FORMATS = ["flv", "hls", "mp4", "fmp4", "ts"];
+
+// src/fixtures/catalog.ts
+function loadManifest(fixtureDir) {
+  const path = resolve(fixtureDir, "manifest.json");
+  if (!existsSync(path)) return null;
+  const raw = JSON.parse(readFileSync(path, "utf8"));
+  return raw;
+}
+function lookupFixture(manifest, codec, format) {
+  if (!manifest) return { files: [], mainFile: null, exists: false };
+  const item = manifest.fixtures.find((f) => f.codec === codec && f.format === format);
+  if (!item) return { files: [], mainFile: null, exists: false };
+  const mainFile = item.entries[0] ?? null;
+  return { files: item.entries, mainFile, exists: true };
+}
+function summarizeCatalog(fixtureDir) {
+  const manifest = loadManifest(fixtureDir);
+  if (!manifest) {
+    return {
+      codecs: ALL_CODECS,
+      formats: ALL_FORMATS,
+      fixtureCount: 0,
+      exists: false,
+      reason: `manifest.json not found at ${resolve(fixtureDir, "manifest.json")}`
+    };
+  }
+  let total = 0;
+  for (const item of manifest.fixtures) total += item.entries.length;
+  return {
+    codecs: ALL_CODECS,
+    formats: ALL_FORMATS,
+    fixtureCount: total,
+    exists: true
+  };
+}
+function verifyEntryOnDisk(fixtureDir, entry) {
+  const abs = resolve(fixtureDir, entry.path);
+  if (!existsSync(abs)) {
+    return { ok: false, size: 0, reason: `missing file: ${entry.path}` };
+  }
+  const size = statSync(abs).size;
+  if (size !== entry.size) {
+    return {
+      ok: false,
+      size,
+      reason: `size mismatch for ${entry.path}: manifest=${entry.size} disk=${size}`
+    };
+  }
+  return { ok: true, size };
+}
+export {
+  loadManifest,
+  lookupFixture,
+  summarizeCatalog,
+  verifyEntryOnDisk
+};

package/dist/fixtures/codec.d.ts

@@ -0,0 +1,10 @@
+import type { CodecId } from "../config.js";
+export type CodecSpec = {
+    codec: CodecId;
+    encoder: string;
+    videoArgs: ReadonlyArray<string>;
+    audioArgs: ReadonlyArray<string>;
+    pixelFormat: string;
+};
+export declare const CODEC_SPEC: Record<CodecId, CodecSpec>;
+export declare function containerExtraArgs(format: "flv" | "hls" | "mp4" | "fmp4" | "ts", codec: CodecId): ReadonlyArray<string>;

package/dist/fixtures/format.d.ts

@@ -0,0 +1,13 @@
+import type { CodecId, FormatId } from "../config.js";
+export type FormatLayout = {
+    format: FormatId;
+    mime: string;
+    mainFileName: string;
+    containerArgs: ReadonlyArray<string>;
+    isContainerDirectory: boolean;
+    sideFiles: ReadonlyArray<string>;
+};
+export declare function layoutFor(codec: CodecId, format: FormatId): FormatLayout;
+export declare function singleFileRelative(codec: CodecId, format: FormatId): string;
+export declare function containerRelativeDir(codec: CodecId, format: FormatId): string;
+export declare function containerRelativePath(codec: CodecId, format: FormatId, name: string): string;

package/dist/fixtures/generate.d.ts

@@ -0,0 +1,11 @@
+import { type GenerateOptions } from "../config.js";
+import { type Manifest } from "./catalog.js";
+export type GenerateResult = {
+    fixtureDir: string;
+    manifest: Manifest;
+    generated: number;
+    skipped: number;
+    ffmpegPath: string;
+    ffmpegMissing: boolean;
+};
+export declare function generateFixtures(opts?: GenerateOptions): Promise<GenerateResult>;

package/dist/fixtures/generate.js

@@ -0,0 +1,361 @@
+// src/fixtures/generate.ts
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { spawn } from "node:child_process";
+import { join as join3, resolve } from "node:path";
+
+// src/config.ts
+var DEFAULT_FIXTURE_DIR = "fixtures";
+var DEFAULT_DURATION_SECONDS = 5;
+var ALL_CODECS = ["h264", "hevc"];
+var ALL_FORMATS = ["flv", "hls", "mp4", "fmp4", "ts"];
+
+// src/fixtures/matrix.ts
+import { join as join2 } from "node:path";
+
+// src/fixtures/codec.ts
+var CODEC_SPEC = {
+  h264: {
+    codec: "h264",
+    encoder: "libx264",
+    videoArgs: ["-profile:v", "high", "-preset", "veryfast"],
+    audioArgs: ["-c:a", "aac", "-b:a", "128k"],
+    pixelFormat: "yuv420p"
+  },
+  hevc: {
+    codec: "hevc",
+    encoder: "libx265",
+    // 注意:FLV / TS 容器用 enhanced-rtmp 1cvh tag,不能强行写 hvc1;
+    // MP4 / fMP4 / HLS 走 hvc1。containerArgs 在 buildPlan 时按 format 决定。
+    videoArgs: ["-preset", "veryfast"],
+    audioArgs: ["-c:a", "aac", "-b:a", "128k"],
+    pixelFormat: "yuv420p"
+  }
+};
+function containerExtraArgs(format, codec) {
+  if (codec !== "hevc") return [];
+  if (format === "mp4") return ["-tag:v", "hvc1"];
+  return [];
+}
+
+// src/fixtures/format.ts
+import { join } from "node:path";
+function formatSpecific(format) {
+  if (format === "flv") return ["-f", "flv"];
+  if (format === "hls") {
+    return [
+      "-f",
+      "hls",
+      "-hls_time",
+      "2",
+      "-hls_playlist_type",
+      "vod",
+      "-hls_segment_type",
+      "mpegts",
+      "-hls_flags",
+      "independent_segments"
+    ];
+  }
+  if (format === "mp4") return ["-f", "mp4", "-movflags", "+faststart"];
+  if (format === "fmp4") {
+    return [
+      "-f",
+      "mp4",
+      "-movflags",
+      "frag_keyframe+empty_moov+default_base_moof",
+      "-frag_duration",
+      "2000000"
+    ];
+  }
+  if (format === "ts") return ["-f", "mpegts"];
+  throw new Error(`Unknown format: ${String(format)}`);
+}
+function layoutFor(codec, format) {
+  if (format === "hls") {
+    return {
+      format,
+      mime: "application/vnd.apple.mpegurl",
+      mainFileName: "master.m3u8",
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: true,
+      sideFiles: ["seg-00000.ts", "seg-00001.ts", "seg-00002.ts"]
+    };
+  }
+  if (format === "fmp4") {
+    return {
+      format,
+      mime: "video/iso.segment",
+      mainFileName: "init.mp4",
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: true,
+      sideFiles: ["seg-00000.m4s", "seg-00001.m4s", "seg-00002.m4s"]
+    };
+  }
+  if (format === "flv") {
+    return {
+      format,
+      mime: "video/x-flv",
+      mainFileName: `${codec}.flv`,
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: false,
+      sideFiles: []
+    };
+  }
+  if (format === "mp4") {
+    return {
+      format,
+      mime: "video/mp4",
+      mainFileName: `${codec}.mp4`,
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: false,
+      sideFiles: []
+    };
+  }
+  if (format === "ts") {
+    return {
+      format,
+      mime: "video/mp2t",
+      mainFileName: `${codec}.ts`,
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: false,
+      sideFiles: []
+    };
+  }
+  throw new Error(`Unknown format: ${String(format)}`);
+}
+function singleFileRelative(codec, format) {
+  return join(format, `${codec}.${format}`);
+}
+function containerRelativeDir(codec, format) {
+  return join(format, codec);
+}
+function containerRelativePath(codec, format, name) {
+  return join(containerRelativeDir(codec, format), name);
+}
+
+// src/fixtures/matrix.ts
+function buildPlan(codec, format, durationSeconds) {
+  const layout = layoutFor(codec, format);
+  const spec = CODEC_SPEC[codec];
+  const gop = String(durationSeconds * 25);
+  const videoInput = `testsrc2=size=1280x720:rate=25,format=yuv420p`;
+  const audioInput = `sine=frequency=1000:sample_rate=44100`;
+  const ffmpegOutputArgs = [
+    "-y",
+    "-f",
+    "lavfi",
+    "-i",
+    videoInput,
+    "-f",
+    "lavfi",
+    "-i",
+    audioInput,
+    "-t",
+    String(durationSeconds),
+    "-c:v",
+    spec.encoder,
+    ...spec.videoArgs,
+    "-pix_fmt",
+    spec.pixelFormat,
+    "-g",
+    gop,
+    "-keyint_min",
+    gop,
+    "-sc_threshold",
+    "0",
+    ...containerExtraArgs(format, codec),
+    ...spec.audioArgs,
+    ...layout.containerArgs
+  ];
+  if (layout.isContainerDirectory) {
+    const containerDir2 = containerRelativeDir(codec, format);
+    const mainFile2 = containerRelativePath(codec, format, layout.mainFileName);
+    const files = [
+      mainFile2,
+      ...layout.sideFiles.map((s) => containerRelativePath(codec, format, s))
+    ];
+    return { codec, format, layout, containerDir: containerDir2, mainFile: mainFile2, files, ffmpegOutputArgs };
+  }
+  const mainFile = singleFileRelative(codec, format);
+  const containerDir = join2(mainFile.split("/").slice(0, -1).join("/"));
+  return { codec, format, layout, containerDir, mainFile, files: [mainFile], ffmpegOutputArgs };
+}
+function expandMatrix(opts) {
+  const codecs = opts?.codecs ?? ALL_CODECS;
+  const formats = opts?.formats ?? ALL_FORMATS;
+  const duration = opts?.durationSeconds ?? 5;
+  const plans = [];
+  for (const codec of codecs) {
+    for (const format of formats) {
+      plans.push(buildPlan(codec, format, duration));
+    }
+  }
+  return plans;
+}
+var VOD_SAMPLE_RELATIVE = "mp4/h264.mp4";
+
+// src/fixtures/generate.ts
+var FFMPEG_PROBE_ARGS = ["-version"];
+async function generateFixtures(opts = {}) {
+  const ffmpegPath = opts.ffmpegPath ?? await findFfmpeg();
+  if (!ffmpegPath) {
+    return {
+      fixtureDir: resolve(opts.fixtureDir ?? DEFAULT_FIXTURE_DIR),
+      manifest: emptyManifest(opts.durationSeconds ?? DEFAULT_DURATION_SECONDS),
+      generated: 0,
+      skipped: 0,
+      ffmpegPath: "ffmpeg",
+      ffmpegMissing: true
+    };
+  }
+  const fixtureDir = resolve(opts.fixtureDir ?? DEFAULT_FIXTURE_DIR);
+  mkdirSync(fixtureDir, { recursive: true });
+  const duration = opts.durationSeconds ?? DEFAULT_DURATION_SECONDS;
+  const plans = expandMatrix({
+    codecs: opts.codecs ?? ALL_CODECS,
+    formats: opts.formats ?? ALL_FORMATS,
+    durationSeconds: duration
+  });
+  const manifestItems = [];
+  let generated = 0;
+  let skipped = 0;
+  for (const plan of plans) {
+    const item = await generateOne(
+      plan,
+      fixtureDir,
+      ffmpegPath,
+      opts.quiet ?? false,
+      opts.overwrite ?? false
+    );
+    if (item) {
+      manifestItems.push(item);
+      generated += 1;
+    } else {
+      skipped += 1;
+    }
+  }
+  copyVodSamples(fixtureDir);
+  const manifest = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationSeconds: duration,
+    fixtures: manifestItems
+  };
+  writeFileSync(join3(fixtureDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  return { fixtureDir, manifest, generated, skipped, ffmpegPath, ffmpegMissing: false };
+}
+async function generateOne(plan, fixtureDir, ffmpegPath, quiet, overwrite) {
+  const outDir = join3(fixtureDir, plan.containerDir);
+  mkdirSync(outDir, { recursive: true });
+  const outFile = join3(fixtureDir, plan.mainFile);
+  if (!overwrite && existsSync(outFile)) {
+    return collectExisting(plan, fixtureDir);
+  }
+  if (plan.layout.isContainerDirectory) {
+    for (const f of readdirSync(outDir)) {
+      if (f === plan.layout.mainFileName) continue;
+      rmIfExists(join3(outDir, f));
+    }
+  }
+  const args = plan.ffmpegOutputArgs.concat([outFile]);
+  if (!quiet) {
+    process.stdout.write(`[generate] ${plan.codec}/${plan.format} -> ${plan.mainFile}
+`);
+  }
+  const code = await runFfmpeg(ffmpegPath, args, quiet);
+  if (code !== 0) {
+    throw new Error(`ffmpeg exited with code ${code} for ${plan.codec}/${plan.format}`);
+  }
+  return collectExisting(plan, fixtureDir);
+}
+function collectExisting(plan, fixtureDir) {
+  const entries = [];
+  for (const rel of plan.files) {
+    const abs = join3(fixtureDir, rel);
+    if (!existsSync(abs)) continue;
+    entries.push({ path: rel, size: statSync(abs).size, sha256: hashFile(abs) });
+  }
+  if (plan.layout.isContainerDirectory) {
+    const absDir = join3(fixtureDir, plan.containerDir);
+    if (existsSync(absDir)) {
+      for (const name of readdirSync(absDir).sort()) {
+        if (name === plan.layout.mainFileName) continue;
+        const rel = join3(plan.containerDir, name);
+        if (entries.find((e) => e.path === rel)) continue;
+        const abs = join3(absDir, name);
+        if (!statSync(abs).isFile()) continue;
+        entries.push({ path: rel, size: statSync(abs).size, sha256: hashFile(abs) });
+      }
+    }
+  }
+  return { codec: plan.codec, format: plan.format, entries };
+}
+function copyVodSamples(fixtureDir) {
+  const src = join3(fixtureDir, VOD_SAMPLE_RELATIVE);
+  if (!existsSync(src)) return;
+  const vodDir = join3(fixtureDir, "vod");
+  mkdirSync(vodDir, { recursive: true });
+  for (const name of ["sample-1.mp4", "sample-2.mp4"]) {
+    const dst = join3(vodDir, name);
+    writeFileSync(dst, readFileSync(src));
+  }
+}
+function rmIfExists(abs) {
+  if (!existsSync(abs)) return;
+  try {
+    unlinkSync(abs);
+  } catch {
+  }
+}
+function runFfmpeg(ffmpegPath, args, quiet) {
+  const { promise, resolve: resolve2, reject } = Promise.withResolvers();
+  const proc = spawn(ffmpegPath, args, {
+    stdio: quiet ? ["ignore", "ignore", "ignore"] : "inherit"
+  });
+  proc.once("error", reject);
+  proc.once("exit", (code) => resolve2(code ?? 1));
+  return promise;
+}
+async function findFfmpeg() {
+  const candidates = [
+    "ffmpeg",
+    "/opt/homebrew/bin/ffmpeg",
+    "/usr/local/bin/ffmpeg",
+    "/usr/bin/ffmpeg"
+  ];
+  for (const candidate of candidates) {
+    if (await canRun(candidate)) return candidate;
+  }
+  return null;
+}
+async function canRun(path) {
+  const { promise, resolve: resolve2 } = Promise.withResolvers();
+  const proc = spawn(path, FFMPEG_PROBE_ARGS, { stdio: "ignore" });
+  proc.once("error", () => resolve2(false));
+  proc.once("exit", (code) => resolve2(code === 0));
+  return promise;
+}
+function hashFile(abs) {
+  const hash = createHash("sha256");
+  hash.update(readFileSync(abs));
+  return hash.digest("hex");
+}
+function emptyManifest(duration) {
+  return {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    durationSeconds: duration,
+    fixtures: []
+  };
+}
+export {
+  generateFixtures
+};

package/dist/fixtures/matrix.d.ts

@@ -0,0 +1,18 @@
+import { type CodecId, type FormatId } from "../config.js";
+import { type FormatLayout } from "./format.js";
+export type FixturePlan = {
+    codec: CodecId;
+    format: FormatId;
+    layout: FormatLayout;
+    containerDir: string;
+    mainFile: string;
+    files: ReadonlyArray<string>;
+    ffmpegOutputArgs: ReadonlyArray<string>;
+};
+export declare function buildPlan(codec: CodecId, format: FormatId, durationSeconds: number): FixturePlan;
+export declare function expandMatrix(opts?: {
+    codecs?: ReadonlyArray<CodecId>;
+    formats?: ReadonlyArray<FormatId>;
+    durationSeconds?: number;
+}): ReadonlyArray<FixturePlan>;
+export declare const VOD_SAMPLE_RELATIVE = "mp4/h264.mp4";

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { buildPlan, expandMatrix, VOD_SAMPLE_RELATIVE, type FixturePlan, } from "./fixtures/matrix.js";
+export { loadManifest, lookupFixture, summarizeCatalog, verifyEntryOnDisk, type CatalogSummary, type FixtureLookup, type Manifest, type ManifestEntry, type ManifestItem, } from "./fixtures/catalog.js";
+export { CODEC_SPEC, type CodecSpec } from "./fixtures/codec.js";
+export { layoutFor, containerRelativeDir, containerRelativePath, type FormatLayout, } from "./fixtures/format.js";
+export { ALL_CODECS, ALL_FORMATS, DEFAULT_DURATION_SECONDS, DEFAULT_FIXTURE_DIR, DEFAULT_HLS_SEGMENT_SECONDS, DEFAULT_HOST, DEFAULT_PORT, type CodecId, type FormatId, type GenerateOptions, type ServeOptions, } from "./config.js";
+export { createStreamsServer, type StreamsServerHandle } from "./server/server.js";
+export { generateFixtures, type GenerateResult } from "./fixtures/generate.js";
+export { handleLiveStream, matchLivePath, type LiveStreamOptions } from "./server/live.js";