@better-media/plugin-video-streaming 0.6.0

package/dist/index.mjs

@@ -0,0 +1,606 @@
+import os from 'os';
+import path from 'path';
+import fs4 from 'fs/promises';
+import { randomUUID } from 'crypto';
+import { spawn } from 'child_process';
+
+// src/runtime/runner.ts
+
+// src/constants/presets.ts
+var DEFAULT_STREAMING_PRESETS = [
+  { name: "360p", height: 360, videoBitrate: "800k", audioBitrate: "96k" },
+  { name: "480p", height: 480, videoBitrate: "1400k", audioBitrate: "128k" },
+  { name: "720p", height: 720, videoBitrate: "2500k", audioBitrate: "128k" },
+  { name: "1080p", height: 1080, videoBitrate: "5000k", audioBitrate: "192k" }
+];
+var DEFAULT_VIDEO_MIME_TYPES = [
+  "video/mp4",
+  "video/quicktime",
+  "video/x-msvideo",
+  "video/x-matroska",
+  "video/webm",
+  "video/mpeg",
+  "video/ogg",
+  "video/3gpp",
+  "video/x-flv",
+  "video/x-ms-wmv"
+];
+
+// src/interfaces/options.interface.ts
+function resolveVideoStreamingOptions(opts) {
+  return {
+    formats: opts.formats && opts.formats.length > 0 ? opts.formats : ["hls"],
+    presets: opts.presets && opts.presets.length > 0 ? opts.presets : [...DEFAULT_STREAMING_PRESETS],
+    allowedMimeTypes: opts.allowedMimeTypes ?? [...DEFAULT_VIDEO_MIME_TYPES],
+    derivativePrefix: opts.derivativePrefix ?? "streaming",
+    segmentDuration: opts.segmentDuration ?? 6,
+    persistMediaVersions: opts.persistMediaVersions !== false,
+    skipExistingDerivatives: opts.skipExistingDerivatives !== false,
+    timeoutMs: opts.timeoutMs ?? 6e5
+  };
+}
+async function readBufferForProcessing(context) {
+  const fileContent = context.utilities?.fileContent;
+  if (fileContent?.buffer) return fileContent.buffer;
+  if (fileContent?.tempPath) return fs4.readFile(fileContent.tempPath);
+  return context.storage.get(context.file.key);
+}
+function isReferenceUrlMode(context) {
+  const url = context.storageLocation?.url;
+  return typeof url === "string" && url === context.file.key;
+}
+async function tryImportFfmpeg() {
+  try {
+    const mod = await import('fluent-ffmpeg');
+    return mod.default ?? mod;
+  } catch {
+    return null;
+  }
+}
+async function getFfmpegBinaryPath() {
+  const mod = await tryImportFfmpeg();
+  if (!mod) return null;
+  const configured = mod.getFfmpegPath?.();
+  return typeof configured === "string" && configured.length > 0 ? configured : "ffmpeg";
+}
+function parseTimemarkSecs(timemark) {
+  const parts = timemark.split(":").map(Number);
+  return (parts[0] ?? 0) * 3600 + (parts[1] ?? 0) * 60 + (parts[2] ?? 0);
+}
+function parseDurationSecs(stderr) {
+  const match = stderr.match(/Duration:\s*(\d{2}:\d{2}:\d{2}(?:\.\d+)?)/);
+  return match ? parseTimemarkSecs(match[1]) : 0;
+}
+function buildScaleFilter(preset) {
+  if (preset.width && preset.height) return `scale=${preset.width}:${preset.height}`;
+  if (preset.width) return `scale=${preset.width}:-2`;
+  if (preset.height) return `scale=-2:${preset.height}`;
+  return "scale=-2:-2";
+}
+async function collectFiles(dir, base) {
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    const rel = path.join(base, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await collectFiles(full, rel));
+    } else {
+      results.push(rel);
+    }
+  }
+  return results;
+}
+async function transcodeHLS(inputPath, outputDir, presets, segmentDuration, onProgress) {
+  const ffmpeg = await tryImportFfmpeg();
+  if (!ffmpeg) throw new FfmpegNotFoundError();
+  await Promise.all(
+    presets.map((p) => fs4.mkdir(path.join(outputDir, p.name), { recursive: true }))
+  );
+  let duration = 0;
+  await Promise.all(
+    presets.map(
+      (preset) => new Promise((resolve, reject) => {
+        const variantDir = path.join(outputDir, preset.name);
+        const playlistPath = path.join(variantDir, "index.m3u8");
+        const segmentPattern = path.join(variantDir, "seg%03d.ts");
+        const cmd = ffmpeg(inputPath).videoCodec(preset.videoCodec ?? "libx264").audioCodec(preset.audioCodec ?? "aac").videoFilters(buildScaleFilter(preset)).outputOptions([
+          `-b:v ${preset.videoBitrate ?? "1000k"}`,
+          `-b:a ${preset.audioBitrate ?? "128k"}`,
+          "-f hls",
+          `-hls_time ${segmentDuration}`,
+          "-hls_playlist_type vod",
+          "-hls_flags independent_segments",
+          `-hls_segment_filename ${segmentPattern}`
+        ]).output(playlistPath);
+        cmd.on("error", (err) => reject(err));
+        cmd.on("end", () => resolve());
+        cmd.on("codecData", (data) => {
+          if (data.duration) {
+            duration = parseTimemarkSecs(data.duration);
+          }
+        });
+        cmd.on("progress", (progress) => {
+          onProgress?.({
+            preset: preset.name,
+            percent: typeof progress.percent === "number" ? Math.min(100, Math.round(progress.percent)) : void 0,
+            currentTimeSecs: progress.timemark ? parseTimemarkSecs(progress.timemark) : void 0
+          });
+        });
+        cmd.run();
+      })
+    )
+  );
+  const masterLines = ["#EXTM3U", "#EXT-X-VERSION:3"];
+  for (const preset of presets) {
+    const bandwidth = parseInt((preset.videoBitrate ?? "1000k").replace(/\D/g, ""), 10) * 1e3;
+    const resolution = preset.width && preset.height ? `RESOLUTION=${preset.width}x${preset.height}` : "";
+    const attrs = [`BANDWIDTH=${bandwidth}`, resolution].filter(Boolean).join(",");
+    masterLines.push(`#EXT-X-STREAM-INF:${attrs}`, `${preset.name}/index.m3u8`);
+  }
+  await fs4.writeFile(path.join(outputDir, "master.m3u8"), masterLines.join("\n") + "\n", "utf8");
+  const files = await collectFiles(outputDir, "");
+  return { duration, files };
+}
+async function transcodeDASH(inputPath, outputDir, presets, segmentDuration, onProgress) {
+  const ffmpegPath = await getFfmpegBinaryPath();
+  if (!ffmpegPath) throw new FfmpegNotFoundError();
+  const masterPath = path.join(outputDir, "master.mpd");
+  const args = ["-y", "-i", inputPath];
+  for (let i = 0; i < presets.length; i++) {
+    args.push("-map", "0:v:0", "-map", "0:a:0");
+  }
+  for (let i = 0; i < presets.length; i++) {
+    const p = presets[i];
+    args.push(
+      `-c:v:${i}`,
+      p.videoCodec ?? "libx264",
+      `-c:a:${i}`,
+      p.audioCodec ?? "aac",
+      `-filter:v:${i}`,
+      buildScaleFilter(p),
+      `-b:v:${i}`,
+      p.videoBitrate ?? "1000k",
+      `-b:a:${i}`,
+      p.audioBitrate ?? "128k"
+    );
+  }
+  args.push(
+    "-f",
+    "dash",
+    "-seg_duration",
+    String(segmentDuration),
+    "-use_template",
+    "1",
+    "-use_timeline",
+    "1",
+    "-init_seg_name",
+    "init-stream$RepresentationID$.mp4",
+    "-media_seg_name",
+    "chunk-stream$RepresentationID$-$Number%05d$.m4s",
+    masterPath
+  );
+  const duration = await new Promise((resolve, reject) => {
+    const proc = spawn(ffmpegPath, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderrBuf = "";
+    let totalDuration = 0;
+    proc.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderrBuf += text;
+      if (onProgress) {
+        if (totalDuration === 0) {
+          const dm = text.match(/Duration:\s*(\d{2}:\d{2}:\d{2}(?:\.\d+)?)/);
+          if (dm) totalDuration = parseTimemarkSecs(dm[1]);
+        }
+        for (const segment of text.split(/[\r\n]/).filter(Boolean)) {
+          const pm = segment.match(/time=(\d{2}:\d{2}:\d{2}(?:\.\d+)?)/);
+          if (pm) {
+            const currentTimeSecs = parseTimemarkSecs(pm[1]);
+            const percent = totalDuration > 0 ? Math.min(100, Math.round(currentTimeSecs / totalDuration * 100)) : void 0;
+            onProgress({ currentTimeSecs, percent });
+          }
+        }
+      }
+    });
+    proc.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        reject(new FfmpegNotFoundError());
+      } else {
+        reject(err);
+      }
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`ffmpeg DASH transcode failed (exit ${code})
+${stderrBuf.slice(-2e3)}`));
+      } else {
+        resolve(parseDurationSecs(stderrBuf));
+      }
+    });
+  });
+  const files = await collectFiles(outputDir, "");
+  return { duration, files };
+}
+var FfmpegNotFoundError = class extends Error {
+  constructor() {
+    super(
+      "fluent-ffmpeg could not be imported. Install it: pnpm add fluent-ffmpeg. Also ensure the ffmpeg binary is available in PATH."
+    );
+    this.name = "FfmpegNotFoundError";
+  }
+};
+var STREAMING_CONTENT_TYPES = {
+  ".m3u8": "application/x-mpegURL",
+  ".ts": "video/MP2T",
+  ".mpd": "application/dash+xml",
+  ".m4s": "video/iso.segment",
+  ".mp4": "video/mp4"
+};
+function inferContentType(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  return STREAMING_CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+async function uploadDirectory(storage, tempDir, storagePrefix, skipExisting) {
+  const uploaded = [];
+  await walkAndUpload(storage, tempDir, tempDir, storagePrefix, skipExisting, uploaded);
+  return uploaded;
+}
+async function walkAndUpload(storage, rootDir, currentDir, storagePrefix, skipExisting, acc) {
+  const entries = await fs4.readdir(currentDir, { withFileTypes: true });
+  await Promise.all(
+    entries.map(async (entry) => {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walkAndUpload(storage, rootDir, fullPath, storagePrefix, skipExisting, acc);
+        return;
+      }
+      const relative = path.relative(rootDir, fullPath);
+      const storageKey = `${storagePrefix}/${relative.split(path.sep).join("/")}`;
+      if (skipExisting && await storage.exists(storageKey)) {
+        acc.push({ storageKey, size: 0 });
+        return;
+      }
+      const buffer = await fs4.readFile(fullPath);
+      await storage.put(storageKey, buffer, { contentType: inferContentType(entry.name) });
+      acc.push({ storageKey, size: buffer.length });
+    })
+  );
+}
+
+// src/runtime/next-version.ts
+async function nextMediaVersionStart(database, mediaId) {
+  const rows = await database.findMany({
+    model: "media_versions",
+    where: [{ field: "mediaId", value: mediaId }],
+    sortBy: { field: "versionNumber", direction: "desc" },
+    limit: 1
+  });
+  const max = rows[0]?.versionNumber;
+  return typeof max === "number" && Number.isFinite(max) ? max + 1 : 1;
+}
+
+// src/runtime/runner.ts
+function withTimeout(promise, ms, label) {
+  if (!Number.isFinite(ms) || ms <= 0) return promise;
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    promise.then(
+      (v) => {
+        clearTimeout(t);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(t);
+        reject(e);
+      }
+    );
+  });
+}
+function masterKeyForFormat(prefix, recordId, format) {
+  return format === "hls" ? `${prefix}/${recordId}/hls/master.m3u8` : `${prefix}/${recordId}/dash/master.mpd`;
+}
+function variantPlaylistKey(prefix, recordId, format, presetName) {
+  return format === "hls" ? `${prefix}/${recordId}/hls/${presetName}/index.m3u8` : `${prefix}/${recordId}/dash/${presetName}/stream.mpd`;
+}
+async function runVideoStreaming(context, api, opts) {
+  const resolved = resolveVideoStreamingOptions(opts);
+  if (isReferenceUrlMode(context)) {
+    api.emitMetadata({ skipped: "reference-url" });
+    return;
+  }
+  const mime = context.file.mimeType;
+  if (!mime || !resolved.allowedMimeTypes.includes(mime)) {
+    api.emitMetadata({ skipped: "mime-not-allowed", mimeType: mime });
+    return;
+  }
+  if (resolved.skipExistingDerivatives) {
+    const firstMasterKey = masterKeyForFormat(
+      resolved.derivativePrefix,
+      context.recordId,
+      resolved.formats[0]
+    );
+    if (await context.storage.exists(firstMasterKey)) {
+      api.emitMetadata({ skipped: "already-processed", key: firstMasterKey });
+      return;
+    }
+  }
+  let buffer;
+  try {
+    buffer = await withTimeout(
+      readBufferForProcessing(context),
+      resolved.timeoutMs,
+      "readBufferForProcessing"
+    );
+  } catch (err) {
+    api.emitMetadata({
+      error: "read-failed",
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
+  if (buffer == null) {
+    api.emitMetadata({ skipped: "no-file-content" });
+    return;
+  }
+  const tempInputDir = path.join(os.tmpdir(), randomUUID());
+  await fs4.mkdir(tempInputDir, { recursive: true });
+  const ext = context.file.extension ?? ".mp4";
+  const inputPath = path.join(tempInputDir, `input${ext}`);
+  await fs4.writeFile(inputPath, buffer);
+  const presets = opts.resolvePreset ? await Promise.all(
+    resolved.presets.map(
+      (preset, index) => Promise.resolve(opts.resolvePreset(context, preset, index))
+    )
+  ) : resolved.presets;
+  const streamingVariants = [];
+  let videoDuration = 0;
+  const tempDirs = [tempInputDir];
+  try {
+    for (const format of resolved.formats) {
+      const tempOutputDir = path.join(os.tmpdir(), randomUUID());
+      await fs4.mkdir(tempOutputDir, { recursive: true });
+      tempDirs.push(tempOutputDir);
+      const storagePrefix = `${resolved.derivativePrefix}/${context.recordId}/${format}`;
+      let duration = 0;
+      try {
+        const transcode = format === "hls" ? transcodeHLS : transcodeDASH;
+        const transcodeOnProgress = opts.onProgress ? (event) => opts.onProgress({ format, ...event }) : void 0;
+        const result = await withTimeout(
+          transcode(
+            inputPath,
+            tempOutputDir,
+            presets,
+            resolved.segmentDuration,
+            transcodeOnProgress
+          ),
+          resolved.timeoutMs,
+          `transcode-${format}`
+        );
+        duration = result.duration;
+        if (duration > 0) videoDuration = duration;
+      } catch (err) {
+        if (err instanceof FfmpegNotFoundError) {
+          api.emitMetadata({ error: "ffmpeg-not-found", message: err.message });
+          return;
+        }
+        api.emitMetadata({
+          error: "transcode-failed",
+          format,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        continue;
+      }
+      try {
+        await uploadDirectory(
+          context.storage,
+          tempOutputDir,
+          storagePrefix,
+          resolved.skipExistingDerivatives
+        );
+      } catch (err) {
+        api.emitMetadata({
+          error: "upload-failed",
+          format,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        continue;
+      }
+      const masterKey = masterKeyForFormat(resolved.derivativePrefix, context.recordId, format);
+      streamingVariants.push({ key: masterKey, format });
+      if (resolved.persistMediaVersions) {
+        let versionCounter = await nextMediaVersionStart(context.database, context.recordId);
+        const variantRows = format === "hls" ? presets.map((p) => ({
+          storageKey: variantPlaylistKey(
+            resolved.derivativePrefix,
+            context.recordId,
+            format,
+            p.name
+          ),
+          mimeType: "application/x-mpegURL"
+        })) : [];
+        const rowsToInsert = [
+          {
+            storageKey: masterKey,
+            mimeType: format === "hls" ? "application/x-mpegURL" : "application/dash+xml"
+          },
+          ...variantRows
+        ];
+        for (const row of rowsToInsert) {
+          try {
+            await context.database.create({
+              model: "media_versions",
+              data: {
+                id: randomUUID(),
+                mediaId: context.recordId,
+                storageKey: row.storageKey,
+                mimeType: row.mimeType,
+                isOriginal: false,
+                type: "compressed",
+                versionNumber: versionCounter,
+                createdAt: /* @__PURE__ */ new Date()
+              }
+            });
+            versionCounter += 1;
+          } catch (err) {
+            api.emitMetadata({
+              error: "media-versions-persist-failed",
+              key: row.storageKey,
+              message: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
+      }
+    }
+  } finally {
+    await Promise.allSettled(tempDirs.map((d) => fs4.rm(d, { recursive: true, force: true })));
+  }
+  if (streamingVariants.length === 0) return;
+  api.emitProcessing({
+    variants: { streaming: streamingVariants },
+    "video-streaming": {
+      formats: resolved.formats,
+      presets: presets.map((p) => p.name),
+      duration: videoDuration || void 0,
+      segmentDuration: resolved.segmentDuration
+    }
+  });
+}
+
+// src/playback/resolve-streaming-urls.ts
+var HLS_MIME = "application/x-mpegURL";
+var DASH_MIME = "application/dash+xml";
+async function resolveStreamingUrls(recordId, options) {
+  const { database, storage, expiresIn, derivativePrefix = "streaming" } = options;
+  if (!storage.getUrl) {
+    throw new Error(
+      "resolveStreamingUrls requires storage.getUrl to be implemented. The memory adapter does not support URL generation \u2014 use createStreamingProxy instead."
+    );
+  }
+  const rows = await database.findMany({
+    model: "media_versions",
+    where: [
+      { field: "mediaId", value: recordId },
+      { field: "mimeType", value: [HLS_MIME, DASH_MIME], operator: "in" }
+    ],
+    select: ["storageKey", "mimeType"]
+  });
+  const keyPrefix = `${derivativePrefix}/${recordId}/`;
+  const masters = rows.filter(
+    (r) => r.storageKey.startsWith(keyPrefix) && (r.storageKey.endsWith("master.m3u8") || r.storageKey.endsWith("master.mpd"))
+  );
+  const result = {};
+  for (const row of masters) {
+    const url = await storage.getUrl(
+      row.storageKey,
+      expiresIn !== void 0 ? { expiresIn } : void 0
+    );
+    if (row.mimeType === HLS_MIME) {
+      result.hls = url;
+    } else if (row.mimeType === DASH_MIME) {
+      result.dash = url;
+    }
+  }
+  return result;
+}
+
+// src/playback/resolve-streaming-status.ts
+async function resolveStreamingStatus(recordId, options) {
+  const { storage, derivativePrefix = "streaming" } = options;
+  const [hls, dash] = await Promise.all([
+    storage.exists(`${derivativePrefix}/${recordId}/hls/master.m3u8`),
+    storage.exists(`${derivativePrefix}/${recordId}/dash/master.mpd`)
+  ]);
+  return { hls, dash, ready: hls || dash };
+}
+var CONTENT_TYPES = {
+  ".m3u8": "application/x-mpegURL",
+  ".mpd": "application/dash+xml",
+  ".ts": "video/MP2T",
+  ".mp4": "video/mp4",
+  ".m4s": "video/iso.segment"
+};
+var PLAYLIST_EXTS = /* @__PURE__ */ new Set([".m3u8", ".mpd"]);
+var DEFAULT_CACHE_PLAYLIST = "no-cache, no-store";
+var DEFAULT_CACHE_SEGMENT = "public, max-age=31536000, immutable";
+function createStreamingProxy(options) {
+  const {
+    storage,
+    authenticate,
+    cacheControl,
+    corsOrigin = "*",
+    derivativePrefix = "streaming"
+  } = options;
+  const playlistCache = cacheControl?.playlist ?? DEFAULT_CACHE_PLAYLIST;
+  const segmentCache = cacheControl?.segment ?? DEFAULT_CACHE_SEGMENT;
+  return {
+    async handle({ recordId, filePath, req, method = "GET" }) {
+      if (filePath.includes("..")) {
+        return new Response("Bad Request", { status: 400 });
+      }
+      const storageKey = `${derivativePrefix}/${recordId}/${filePath}`;
+      if (authenticate) {
+        try {
+          await authenticate(req, { recordId, storageKey });
+        } catch {
+          return new Response("Forbidden", { status: 403 });
+        }
+      }
+      const exists = await storage.exists(storageKey);
+      if (!exists) {
+        return new Response("Not Found", { status: 404 });
+      }
+      const ext = path.extname(filePath);
+      const contentType = CONTENT_TYPES[ext] ?? "application/octet-stream";
+      const cacheHeader = PLAYLIST_EXTS.has(ext) ? playlistCache : segmentCache;
+      const headers = new Headers({
+        "Content-Type": contentType,
+        "Cache-Control": cacheHeader,
+        "Access-Control-Allow-Origin": corsOrigin,
+        "Access-Control-Allow-Methods": "GET, HEAD",
+        "Access-Control-Expose-Headers": "Content-Length, Content-Type"
+      });
+      if (method.toUpperCase() === "HEAD") {
+        return new Response(null, { status: 200, headers });
+      }
+      if (storage.getStream) {
+        const stream = await storage.getStream(storageKey);
+        if (stream == null) {
+          return new Response("Not Found", { status: 404 });
+        }
+        return new Response(stream, { status: 200, headers });
+      }
+      const buffer = await storage.get(storageKey);
+      if (buffer == null) {
+        return new Response("Not Found", { status: 404 });
+      }
+      return new Response(new Uint8Array(buffer), { status: 200, headers });
+    }
+  };
+}
+
+// src/index.ts
+function videoStreamingPlugin(opts = {}) {
+  return {
+    name: "video-streaming",
+    runtimeManifest: {
+      id: "better-media-video-streaming",
+      version: "1.0.0",
+      trustLevel: "untrusted",
+      capabilities: ["file.read", "metadata.write.own", "processing.write.own"],
+      namespace: "video-streaming"
+    },
+    executionMode: "background",
+    intensive: true,
+    apply(runtime) {
+      runtime.hooks["process:run"].tap(
+        "video-streaming",
+        async (context, api) => runVideoStreaming(context, api, opts),
+        { mode: "background" }
+      );
+    }
+  };
+}
+
+export { DEFAULT_STREAMING_PRESETS, DEFAULT_VIDEO_MIME_TYPES, createStreamingProxy, resolveStreamingStatus, resolveStreamingUrls, videoStreamingPlugin };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map