avbridge 1.0.0

package/dist/index.cjs

@@ -0,0 +1,576 @@
+'use strict';
+
+var chunkF7YS2XOA_cjs = require('./chunk-F7YS2XOA.cjs');
+var chunkY5FYF5KG_cjs = require('./chunk-Y5FYF5KG.cjs');
+var chunkL4NPOJ36_cjs = require('./chunk-L4NPOJ36.cjs');
+require('./chunk-Z2FJ5TJC.cjs');
+require('./chunk-NZU7W256.cjs');
+
+// src/convert/remux.ts
+var MEDIABUNNY_CONTAINERS = /* @__PURE__ */ new Set([
+  "mp4",
+  "mov",
+  "mkv",
+  "webm",
+  "ogg",
+  "wav",
+  "mp3",
+  "flac",
+  "adts"
+]);
+async function remux(source, options = {}) {
+  const outputFormat = options.outputFormat ?? "mp4";
+  options.signal?.throwIfAborted();
+  const ctx = await chunkF7YS2XOA_cjs.probe(source);
+  options.signal?.throwIfAborted();
+  validateRemuxEligibility(ctx, options.strict ?? false);
+  if (MEDIABUNNY_CONTAINERS.has(ctx.container)) {
+    return remuxViaMediAbunny(ctx, outputFormat, options);
+  }
+  return remuxViaLibav(ctx, outputFormat, options);
+}
+function validateRemuxEligibility(ctx, strict) {
+  const video = ctx.videoTracks[0];
+  const audio = ctx.audioTracks[0];
+  if (video) {
+    const mbCodec = chunkF7YS2XOA_cjs.avbridgeVideoToMediabunny(video.codec);
+    if (!mbCodec) {
+      throw new Error(
+        `Cannot remux: video codec "${video.codec}" is not supported for remuxing. Use transcode() to re-encode to a modern codec.`
+      );
+    }
+  }
+  if (audio) {
+    const mbCodec = chunkF7YS2XOA_cjs.avbridgeAudioToMediabunny(audio.codec);
+    if (!mbCodec) {
+      throw new Error(
+        `Cannot remux: audio codec "${audio.codec}" is not supported for remuxing. Use transcode() to re-encode to a modern codec.`
+      );
+    }
+  }
+  if (strict && video?.codec === "h264" && audio?.codec === "mp3") {
+    throw new Error(
+      `Cannot remux in strict mode: H.264 + MP3 is a best-effort combination that may produce playback issues in some browsers. Set strict: false to allow, or use transcode() to re-encode audio to AAC.`
+    );
+  }
+  if (!video && !audio) {
+    throw new Error("Cannot remux: source has no video or audio tracks.");
+  }
+}
+async function remuxViaMediAbunny(ctx, outputFormat, options) {
+  const mb = await import('mediabunny');
+  const input = new mb.Input({
+    source: await chunkF7YS2XOA_cjs.buildMediabunnySourceFromInput(mb, ctx.source),
+    formats: mb.ALL_FORMATS
+  });
+  const target = new mb.BufferTarget();
+  const output = new mb.Output({
+    format: createOutputFormat(mb, outputFormat),
+    target
+  });
+  const conversion = await mb.Conversion.init({
+    input,
+    output,
+    showWarnings: false
+  });
+  if (!conversion.isValid) {
+    const reasons = conversion.discardedTracks.map((d) => `${d.track.type} track discarded: ${d.reason}`).join("; ");
+    throw new Error(`Cannot remux: mediabunny rejected the conversion. ${reasons}`);
+  }
+  if (options.onProgress) {
+    const onProgress = options.onProgress;
+    conversion.onProgress = (p) => {
+      onProgress({ percent: p * 100, bytesWritten: 0 });
+    };
+  }
+  let abortHandler;
+  if (options.signal) {
+    options.signal.throwIfAborted();
+    abortHandler = () => void conversion.cancel();
+    options.signal.addEventListener("abort", abortHandler, { once: true });
+  }
+  try {
+    await conversion.execute();
+  } finally {
+    if (abortHandler && options.signal) {
+      options.signal.removeEventListener("abort", abortHandler);
+    }
+  }
+  if (!target.buffer) {
+    throw new Error("Remux failed: mediabunny produced no output buffer.");
+  }
+  const mimeType = mimeForFormat(outputFormat);
+  const blob = new Blob([target.buffer], { type: mimeType });
+  const filename = generateFilename(ctx.name, outputFormat);
+  options.onProgress?.({ percent: 100, bytesWritten: blob.size });
+  return {
+    blob,
+    mimeType,
+    container: outputFormat,
+    videoCodec: ctx.videoTracks[0]?.codec,
+    audioCodec: ctx.audioTracks[0]?.codec,
+    duration: ctx.duration,
+    filename
+  };
+}
+async function remuxViaLibav(ctx, outputFormat, options) {
+  let loadLibav;
+  let pickLibavVariant;
+  try {
+    const loader = await import('./libav-loader-ZHOERPHW.cjs');
+    const routing = await import('./variant-routing-GOHB2RZN.cjs');
+    loadLibav = loader.loadLibav;
+    pickLibavVariant = routing.pickLibavVariant;
+  } catch {
+    throw new Error(
+      `Cannot remux ${ctx.container.toUpperCase()} source: libav.js is not available. Install @libav.js/variant-webcodecs and libavjs-webcodecs-bridge, or build the custom avbridge variant with scripts/build-libav.sh.`
+    );
+  }
+  const variant = pickLibavVariant(ctx);
+  const libav = await loadLibav(variant);
+  const normalized = await chunkY5FYF5KG_cjs.normalizeSource(ctx.source);
+  const filename = ctx.name ?? `remux-input-${Date.now()}`;
+  const handle = await chunkL4NPOJ36_cjs.prepareLibavInput(libav, filename, normalized);
+  try {
+    return await doLibavRemux(libav, filename, ctx, outputFormat, options);
+  } finally {
+    await handle.detach().catch(() => {
+    });
+  }
+}
+async function doLibavRemux(libav, filename, ctx, outputFormat, options) {
+  const mb = await import('mediabunny');
+  const readPkt = await libav.av_packet_alloc();
+  const [fmt_ctx, streams] = await libav.ff_init_demuxer_file(filename);
+  const videoStream = streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_VIDEO) ?? null;
+  const audioStream = streams.find((s) => s.codec_type === libav.AVMEDIA_TYPE_AUDIO) ?? null;
+  const videoTrackInfo = ctx.videoTracks[0];
+  const audioTrackInfo = ctx.audioTracks[0];
+  const mbVideoCodec = videoTrackInfo ? chunkF7YS2XOA_cjs.avbridgeVideoToMediabunny(videoTrackInfo.codec) : null;
+  const mbAudioCodec = audioTrackInfo ? chunkF7YS2XOA_cjs.avbridgeAudioToMediabunny(audioTrackInfo.codec) : null;
+  const target = new mb.BufferTarget();
+  const output = new mb.Output({
+    format: createOutputFormat(mb, outputFormat),
+    target
+  });
+  let videoSource = null;
+  let audioSource = null;
+  if (mbVideoCodec && videoStream) {
+    videoSource = new mb.EncodedVideoPacketSource(mbVideoCodec);
+    output.addVideoTrack(videoSource);
+  }
+  if (mbAudioCodec && audioStream) {
+    audioSource = new mb.EncodedAudioPacketSource(mbAudioCodec);
+    output.addAudioTrack(audioSource);
+  }
+  await output.start();
+  const videoFps = videoTrackInfo?.fps && videoTrackInfo.fps > 0 ? videoTrackInfo.fps : 30;
+  const videoFrameStepUs = Math.max(1, Math.round(1e6 / videoFps));
+  let syntheticVideoUs = 0;
+  let syntheticAudioUs = 0;
+  const videoTimeBase = videoStream?.time_base_num && videoStream?.time_base_den ? [videoStream.time_base_num, videoStream.time_base_den] : void 0;
+  const audioTimeBase = audioStream?.time_base_num && audioStream?.time_base_den ? [audioStream.time_base_num, audioStream.time_base_den] : void 0;
+  let totalPackets = 0;
+  const durationUs = ctx.duration ? ctx.duration * 1e6 : 0;
+  let firstVideoMeta = true;
+  let firstAudioMeta = true;
+  while (true) {
+    options.signal?.throwIfAborted();
+    let readErr;
+    let packets;
+    try {
+      [readErr, packets] = await libav.ff_read_frame_multi(fmt_ctx, readPkt, {
+        limit: 64 * 1024
+      });
+    } catch (err) {
+      throw new Error(`libav demux failed: ${err.message}`);
+    }
+    const videoPackets = videoStream ? packets[videoStream.index] ?? [] : [];
+    const audioPackets = audioStream ? packets[audioStream.index] ?? [] : [];
+    if (videoSource) {
+      for (const pkt of videoPackets) {
+        sanitizePacketTimestamp(pkt, () => {
+          const ts = syntheticVideoUs;
+          syntheticVideoUs += videoFrameStepUs;
+          return ts;
+        }, videoTimeBase);
+        const mbPacket = libavPacketToMediAbunny(mb, pkt);
+        await videoSource.add(
+          mbPacket,
+          firstVideoMeta ? { decoderConfig: buildVideoDecoderConfig(videoTrackInfo) } : void 0
+        );
+        firstVideoMeta = false;
+      }
+    }
+    if (audioSource) {
+      for (const pkt of audioPackets) {
+        sanitizePacketTimestamp(pkt, () => {
+          const ts = syntheticAudioUs;
+          const sampleRate = audioTrackInfo?.sampleRate ?? 44100;
+          syntheticAudioUs += Math.round(1024 * 1e6 / sampleRate);
+          return ts;
+        }, audioTimeBase);
+        const mbPacket = libavPacketToMediAbunny(mb, pkt);
+        await audioSource.add(
+          mbPacket,
+          firstAudioMeta ? { decoderConfig: buildAudioDecoderConfig(audioTrackInfo) } : void 0
+        );
+        firstAudioMeta = false;
+      }
+    }
+    totalPackets += videoPackets.length + audioPackets.length;
+    if (options.onProgress && durationUs > 0) {
+      const lastVideoTs = videoPackets.length > 0 ? videoPackets[videoPackets.length - 1].pts ?? 0 : 0;
+      const lastAudioTs = audioPackets.length > 0 ? audioPackets[audioPackets.length - 1].pts ?? 0 : 0;
+      const currentUs = Math.max(lastVideoTs, lastAudioTs);
+      const percent = Math.min(99, currentUs / durationUs * 100);
+      options.onProgress({ percent, bytesWritten: 0 });
+    }
+    if (readErr === libav.AVERROR_EOF) break;
+    if (readErr && readErr !== 0 && readErr !== -libav.EAGAIN) {
+      console.warn("[avbridge] remux: ff_read_frame_multi returned", readErr);
+      break;
+    }
+  }
+  await output.finalize();
+  try {
+    await libav.av_packet_free?.(readPkt);
+  } catch {
+  }
+  try {
+    await libav.avformat_close_input_js(fmt_ctx);
+  } catch {
+  }
+  if (!target.buffer) {
+    throw new Error("Remux failed: mediabunny produced no output buffer.");
+  }
+  const mimeType = mimeForFormat(outputFormat);
+  const blob = new Blob([target.buffer], { type: mimeType });
+  const outputFilename = generateFilename(ctx.name, outputFormat);
+  options.onProgress?.({ percent: 100, bytesWritten: blob.size });
+  return {
+    blob,
+    mimeType,
+    container: outputFormat,
+    videoCodec: videoTrackInfo?.codec,
+    audioCodec: audioTrackInfo?.codec,
+    duration: ctx.duration,
+    filename: outputFilename
+  };
+}
+function sanitizePacketTimestamp(pkt, nextUs, fallbackTimeBase) {
+  const lo = pkt.pts ?? 0;
+  const hi = pkt.ptshi ?? 0;
+  const isInvalid = hi === -2147483648 && lo === 0 || !Number.isFinite(lo);
+  if (isInvalid) {
+    const us2 = nextUs();
+    pkt.pts = us2;
+    pkt.ptshi = 0;
+    pkt.time_base_num = 1;
+    pkt.time_base_den = 1e6;
+    return;
+  }
+  const tb = fallbackTimeBase ?? [1, 1e6];
+  const pts64 = hi * 4294967296 + lo;
+  const us = Math.round(pts64 * 1e6 * tb[0] / tb[1]);
+  if (Number.isFinite(us) && Math.abs(us) <= Number.MAX_SAFE_INTEGER) {
+    pkt.pts = us;
+    pkt.ptshi = us < 0 ? -1 : 0;
+    pkt.time_base_num = 1;
+    pkt.time_base_den = 1e6;
+    return;
+  }
+  const fallback = nextUs();
+  pkt.pts = fallback;
+  pkt.ptshi = 0;
+  pkt.time_base_num = 1;
+  pkt.time_base_den = 1e6;
+}
+function createOutputFormat(mb, format) {
+  switch (format) {
+    case "mp4":
+      return new mb.Mp4OutputFormat({ fastStart: "in-memory" });
+    case "webm":
+      return new mb.WebMOutputFormat();
+    case "mkv":
+      return new mb.MkvOutputFormat();
+    default:
+      return new mb.Mp4OutputFormat({ fastStart: "in-memory" });
+  }
+}
+function mimeForFormat(format) {
+  switch (format) {
+    case "mp4":
+      return "video/mp4";
+    case "webm":
+      return "video/webm";
+    case "mkv":
+      return "video/x-matroska";
+    default:
+      return "application/octet-stream";
+  }
+}
+function generateFilename(originalName, format) {
+  const ext = format === "mkv" ? "mkv" : format;
+  if (!originalName) return `output.${ext}`;
+  const base = originalName.replace(/\.[^.]+$/, "");
+  return `${base}.${ext}`;
+}
+var _seqCounter = 0;
+function libavPacketToMediAbunny(mb, pkt) {
+  const KEY_FRAME_FLAG = 1;
+  const timestampSec = (pkt.pts ?? 0) / 1e6;
+  const durationSec = (pkt.duration ?? 0) / 1e6;
+  const type = pkt.flags & KEY_FRAME_FLAG ? "key" : "delta";
+  return new mb.EncodedPacket(pkt.data, type, timestampSec, durationSec, _seqCounter++);
+}
+function buildVideoDecoderConfig(track) {
+  return {
+    codec: track.codecString ?? track.codec,
+    codedWidth: track.width,
+    codedHeight: track.height
+  };
+}
+function buildAudioDecoderConfig(track) {
+  return {
+    codec: track.codecString ?? track.codec,
+    numberOfChannels: track.channels,
+    sampleRate: track.sampleRate
+  };
+}
+
+// src/convert/transcode.ts
+var MEDIABUNNY_CONTAINERS2 = /* @__PURE__ */ new Set([
+  "mp4",
+  "mov",
+  "mkv",
+  "webm",
+  "ogg",
+  "wav",
+  "mp3",
+  "flac",
+  "adts"
+]);
+async function transcode(source, options = {}) {
+  const outputFormat = options.outputFormat ?? "mp4";
+  const videoCodec = options.videoCodec ?? defaultVideoCodec(outputFormat);
+  const audioCodec = options.audioCodec ?? defaultAudioCodec(outputFormat);
+  const quality = options.quality ?? "medium";
+  validateCodecCompatibility(outputFormat, videoCodec, audioCodec);
+  options.signal?.throwIfAborted();
+  const ctx = await chunkF7YS2XOA_cjs.probe(source);
+  options.signal?.throwIfAborted();
+  if (!MEDIABUNNY_CONTAINERS2.has(ctx.container)) {
+    throw new Error(
+      `Cannot transcode "${ctx.container}" sources in v1. transcode() only supports inputs that mediabunny can read (MP4, MKV, WebM, OGG, MP3, FLAC, WAV, MOV). For AVI/ASF/FLV sources, use the player's playback strategies instead.`
+    );
+  }
+  return doTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, options);
+}
+async function attemptTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, options) {
+  const mb = await import('mediabunny');
+  const input = new mb.Input({
+    source: await chunkF7YS2XOA_cjs.buildMediabunnySourceFromInput(mb, ctx.source),
+    formats: mb.ALL_FORMATS
+  });
+  const target = new mb.BufferTarget();
+  const output = new mb.Output({
+    format: createOutputFormat(mb, outputFormat),
+    target
+  });
+  const videoOptions = options.dropVideo ? { discard: true } : {
+    codec: avbridgeVideoToMediabunny2(videoCodec),
+    bitrate: options.videoBitrate ?? qualityToMediabunny(mb, quality),
+    forceTranscode: true,
+    ...options.width !== void 0 ? { width: options.width } : {},
+    ...options.height !== void 0 ? { height: options.height } : {},
+    ...options.width !== void 0 && options.height !== void 0 ? { fit: "contain" } : {},
+    ...options.frameRate !== void 0 ? { frameRate: options.frameRate } : {},
+    ...options.hardwareAcceleration !== void 0 ? { hardwareAcceleration: options.hardwareAcceleration } : {}
+  };
+  const audioOptions = options.dropAudio ? { discard: true } : {
+    codec: avbridgeAudioToMediabunny2(audioCodec),
+    bitrate: options.audioBitrate ?? qualityToMediabunny(mb, quality),
+    forceTranscode: true
+  };
+  const conversion = await mb.Conversion.init({
+    input,
+    output,
+    video: videoOptions,
+    audio: audioOptions,
+    showWarnings: false
+  });
+  if (!conversion.isValid) {
+    const reasons = conversion.discardedTracks.map((d) => `${d.track.type} track discarded: ${d.reason}`).join("; ");
+    throw new Error(
+      `Cannot transcode: mediabunny rejected the conversion. ${reasons || "(no reason given)"}`
+    );
+  }
+  if (options.onProgress) {
+    const onProgress = options.onProgress;
+    conversion.onProgress = (p) => {
+      onProgress({ percent: p * 100, bytesWritten: 0 });
+    };
+  }
+  let abortHandler;
+  if (options.signal) {
+    options.signal.throwIfAborted();
+    abortHandler = () => void conversion.cancel();
+    options.signal.addEventListener("abort", abortHandler, { once: true });
+  }
+  try {
+    await conversion.execute();
+  } finally {
+    if (abortHandler && options.signal) {
+      options.signal.removeEventListener("abort", abortHandler);
+    }
+  }
+  if (!target.buffer) {
+    throw new Error("Transcode failed: mediabunny produced no output buffer.");
+  }
+  return target.buffer;
+}
+function isLikelyEncoderInitError(err) {
+  if (!err) return false;
+  const msg = err instanceof Error ? err.message : String(err);
+  const lower = msg.toLowerCase();
+  return lower.includes("encoding error") || lower.includes("encoder") || lower.includes("encode failed");
+}
+function describeError(err) {
+  if (!err) return "(unknown)";
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+var MAX_ENCODER_RETRIES = 2;
+async function doTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, options) {
+  const notes = [];
+  let buffer = null;
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_ENCODER_RETRIES; attempt++) {
+    try {
+      buffer = await attemptTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, options);
+      if (attempt > 0) {
+        notes.push(
+          `Encoder failed ${attempt} time${attempt === 1 ? "" : "s"} before succeeding (known headless Chromium WebCodecs encoder init issue): ${describeError(lastError)}`
+        );
+      }
+      break;
+    } catch (err) {
+      lastError = err;
+      if (options.signal?.aborted) throw err;
+      if (!isLikelyEncoderInitError(err)) throw err;
+      if (attempt === MAX_ENCODER_RETRIES) throw err;
+      await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
+    }
+  }
+  if (!buffer) {
+    throw new Error("Transcode failed: no buffer produced (this should be unreachable).");
+  }
+  const mimeType = mimeForFormat(outputFormat);
+  const blob = new Blob([buffer], { type: mimeType });
+  const filename = generateFilename(ctx.name, outputFormat);
+  options.onProgress?.({ percent: 100, bytesWritten: blob.size });
+  return {
+    blob,
+    mimeType,
+    container: outputFormat,
+    videoCodec: options.dropVideo ? void 0 : videoCodec,
+    audioCodec: options.dropAudio ? void 0 : audioCodec,
+    duration: ctx.duration,
+    filename,
+    ...notes.length > 0 ? { notes } : {}
+  };
+}
+function defaultVideoCodec(format) {
+  switch (format) {
+    case "webm":
+      return "vp9";
+    case "mp4":
+    case "mkv":
+    default:
+      return "h264";
+  }
+}
+function defaultAudioCodec(format) {
+  switch (format) {
+    case "webm":
+      return "opus";
+    case "mp4":
+    case "mkv":
+    default:
+      return "aac";
+  }
+}
+function validateCodecCompatibility(format, videoCodec, audioCodec) {
+  if (format === "webm") {
+    if (videoCodec !== "vp9" && videoCodec !== "av1") {
+      throw new Error(
+        `WebM does not support video codec "${videoCodec}". Use "vp9" or "av1", or change outputFormat to "mp4" or "mkv".`
+      );
+    }
+    if (audioCodec !== "opus") {
+      throw new Error(
+        `WebM does not support audio codec "${audioCodec}". Use "opus", or change outputFormat to "mp4" or "mkv".`
+      );
+    }
+  }
+}
+function avbridgeVideoToMediabunny2(c) {
+  switch (c) {
+    case "h264":
+      return "avc";
+    case "h265":
+      return "hevc";
+    case "vp9":
+      return "vp9";
+    case "av1":
+      return "av1";
+  }
+}
+function avbridgeAudioToMediabunny2(c) {
+  switch (c) {
+    case "aac":
+      return "aac";
+    case "opus":
+      return "opus";
+    case "flac":
+      return "flac";
+  }
+}
+function qualityToMediabunny(mb, quality) {
+  switch (quality) {
+    case "low":
+      return mb.QUALITY_LOW;
+    case "medium":
+      return mb.QUALITY_MEDIUM;
+    case "high":
+      return mb.QUALITY_HIGH;
+    case "very-high":
+      return mb.QUALITY_VERY_HIGH;
+  }
+}
+
+Object.defineProperty(exports, "UnifiedPlayer", {
+  enumerable: true,
+  get: function () { return chunkF7YS2XOA_cjs.UnifiedPlayer; }
+});
+Object.defineProperty(exports, "classify", {
+  enumerable: true,
+  get: function () { return chunkF7YS2XOA_cjs.classifyContext; }
+});
+Object.defineProperty(exports, "createPlayer", {
+  enumerable: true,
+  get: function () { return chunkF7YS2XOA_cjs.createPlayer; }
+});
+Object.defineProperty(exports, "probe", {
+  enumerable: true,
+  get: function () { return chunkF7YS2XOA_cjs.probe; }
+});
+Object.defineProperty(exports, "srtToVtt", {
+  enumerable: true,
+  get: function () { return chunkF7YS2XOA_cjs.srtToVtt; }
+});
+exports.remux = remux;
+exports.transcode = transcode;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map