avbridge 2.3.0 → 2.6.0

package/dist/index.js

@@ -1,401 +1,524 @@
-import { probe, avbridgeVideoToMediabunny, avbridgeAudioToMediabunny, buildMediabunnySourceFromInput } from './chunk-NV7ILLWH.js';
-export { FALLBACK_AUDIO_CODECS, FALLBACK_VIDEO_CODECS, NATIVE_AUDIO_CODECS, NATIVE_VIDEO_CODECS, UnifiedPlayer, classifyContext as classify, createPlayer, probe, srtToVtt } from './chunk-NV7ILLWH.js';
-import { normalizeSource } from './chunk-2PGRFCWB.js';
-export { AvbridgeError, ERR_ALL_STRATEGIES_EXHAUSTED, ERR_CODEC_NOT_SUPPORTED, ERR_FETCH_FAILED, ERR_LIBAV_NOT_REACHABLE, ERR_MSE_CODEC_NOT_SUPPORTED, ERR_MSE_NOT_SUPPORTED, ERR_PLAYER_NOT_READY, ERR_PROBE_FAILED, ERR_PROBE_FETCH_FAILED, ERR_PROBE_UNKNOWN_CONTAINER, ERR_RANGE_NOT_SUPPORTED, ERR_STRATEGY_FAILED } from './chunk-2PGRFCWB.js';
-import { prepareLibavInput } from './chunk-DCSOQH2N.js';
+import { mimeForFormat, generateFilename, createOutputFormat } from './chunk-SMH6IOP2.js';
+export { remux } from './chunk-SMH6IOP2.js';
+export { FALLBACK_AUDIO_CODECS, FALLBACK_VIDEO_CODECS, NATIVE_AUDIO_CODECS, NATIVE_VIDEO_CODECS, UnifiedPlayer, classifyContext as classify, createPlayer } from './chunk-OGYHFY6K.js';
+export { srtToVtt } from './chunk-5KVLE6YI.js';
+import { probe, buildMediabunnySourceFromInput } from './chunk-SR3MPV4D.js';
+export { probe } from './chunk-SR3MPV4D.js';
+import { AvbridgeError, ERR_CONTAINER_NOT_SUPPORTED, ERR_TRANSCODE_UNSUPPORTED_COMBO, ERR_TRANSCODE_ABORTED, ERR_TRANSCODE_DECODE, ERR_CODEC_NOT_SUPPORTED } from './chunk-CPJLFFCC.js';
+export { AvbridgeError, ERR_ALL_STRATEGIES_EXHAUSTED, ERR_CODEC_NOT_SUPPORTED, ERR_FETCH_FAILED, ERR_LIBAV_NOT_REACHABLE, ERR_MSE_CODEC_NOT_SUPPORTED, ERR_MSE_NOT_SUPPORTED, ERR_PLAYER_NOT_READY, ERR_PROBE_FAILED, ERR_PROBE_FETCH_FAILED, ERR_PROBE_UNKNOWN_CONTAINER, ERR_RANGE_NOT_SUPPORTED, ERR_STRATEGY_FAILED } from './chunk-CPJLFFCC.js';
+import './chunk-LUFA47FP.js';
+import './chunk-X2K3GIWE.js';
+import './chunk-DCSOQH2N.js';
 import './chunk-5DMTJVIU.js';
 import './chunk-5YAWWKA3.js';
 
-function isAnnexB(bytes) {
-  if (bytes.length < 3) return false;
-  if (bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 1) return true;
-  if (bytes.length >= 4 && bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 0 && bytes[3] === 1) return true;
-  return false;
+// src/convert/transcode-libav.ts
+function isLibavTranscodeContainer(container) {
+  return container === "avi" || container === "asf" || container === "flv" || container === "rm";
 }
-function* iterateAnnexBNalus(bytes) {
-  const length = bytes.length;
-  let i = 0;
-  let nalStart = -1;
-  while (i < length) {
-    let scLen = 0;
-    if (i + 3 < length && bytes[i] === 0 && bytes[i + 1] === 0 && bytes[i + 2] === 0 && bytes[i + 3] === 1) {
-      scLen = 4;
-    } else if (i + 2 < length && bytes[i] === 0 && bytes[i + 1] === 0 && bytes[i + 2] === 1) {
-      scLen = 3;
-    }
-    if (scLen > 0) {
-      if (nalStart >= 0) {
-        yield bytes.subarray(nalStart, i);
-      }
-      nalStart = i + scLen;
-      i += scLen;
-    } else {
-      i += 1;
-    }
-  }
-  if (nalStart >= 0 && nalStart < length) {
-    yield bytes.subarray(nalStart, length);
-  }
-}
-function annexBToAvcc(annexB) {
-  const nalus = [];
-  let total = 0;
-  for (const nal of iterateAnnexBNalus(annexB)) {
-    nalus.push(nal);
-    total += 4 + nal.length;
-  }
-  const out = new Uint8Array(total);
-  let off = 0;
-  for (const nal of nalus) {
-    const len = nal.length;
-    out[off++] = len >>> 24 & 255;
-    out[off++] = len >>> 16 & 255;
-    out[off++] = len >>> 8 & 255;
-    out[off++] = len & 255;
-    out.set(nal, off);
-    off += len;
-  }
-  return out;
-}
-
-// src/convert/remux.ts
-var MEDIABUNNY_CONTAINERS = /* @__PURE__ */ new Set([
-  "mp4",
-  "mov",
-  "mkv",
-  "webm",
-  "ogg",
-  "wav",
-  "mp3",
-  "flac",
-  "adts"
-]);
-async function remux(source, options = {}) {
+async function transcodeViaLibav(ctx, options) {
   const outputFormat = options.outputFormat ?? "mp4";
-  options.signal?.throwIfAborted();
-  const ctx = await 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 = 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 = 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 (outputFormat !== "mp4" && outputFormat !== "webm" && outputFormat !== "mkv") {
+    throw new AvbridgeError(
+      ERR_TRANSCODE_UNSUPPORTED_COMBO,
+      `legacy-container transcode supports MP4, WebM, and MKV output (got "${outputFormat}").`,
+      `Use outputFormat: "mp4", "webm", or "mkv".`
     );
   }
-  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 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
+  const videoCodec = options.videoCodec ?? (outputFormat === "webm" ? "vp9" : "h264");
+  const audioCodec = options.audioCodec ?? (outputFormat === "webm" ? "opus" : "aac");
+  const quality = options.quality ?? "medium";
+  options.signal?.throwIfAborted();
+  const [
+    mb,
+    { openLibavDemux, sanitizePacketTimestamp, sanitizeFrameTimestamp, libavFrameToInterleavedFloat32 },
+    { normalizeSource },
+    { createOutputFormat: createOutputFormat2, mimeForFormat: mimeForFormat2, generateFilename: generateFilename2 }
+  ] = await Promise.all([
+    import('mediabunny'),
+    import('./libav-demux-OWZ4T2YW.js'),
+    import('./source-4TZ6KMNV.js'),
+    import('./remux-WBYIZBBX.js')
+  ]);
+  const normalized = await normalizeSource(ctx.source);
+  const demux = await openLibavDemux({
+    source: normalized,
+    filename: ctx.name ?? "input.bin",
+    context: ctx
+    // transport config is not yet threaded through ConvertOptions; add
+    // later if URL-source transcode with signed URLs becomes a need.
   });
-  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);
+    let throwIfAborted2 = function() {
+      if (ac?.aborted) {
+        throw new AvbridgeError(
+          ERR_TRANSCODE_ABORTED,
+          "transcode: aborted by caller.",
+          void 0
+        );
+      }
+    }, throwIfDrainError2 = function() {
+      if (drainError) {
+        const msg = drainError.message;
+        throw new AvbridgeError(
+          ERR_TRANSCODE_DECODE,
+          `transcode: video decoder error: ${msg}`,
+          "This usually indicates the WebCodecs decoder rejected a malformed packet."
+        );
+      }
+    };
+    var throwIfAborted = throwIfAborted2, throwIfDrainError = throwIfDrainError2;
+    options.signal?.throwIfAborted();
+    if (!demux.videoStream && !demux.audioStream) {
+      throw new Error("transcode: source has no decodable tracks");
     }
-  }
-  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-27RDIN2I.js');
-    const routing = await import('./variant-routing-434STYAB.js');
-    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 normalizeSource(ctx.source);
-  const filename = ctx.name ?? `remux-input-${Date.now()}`;
-  const handle = await prepareLibavInput(libav, filename, normalized);
-  try {
-    return await doLibavRemux(libav, filename, ctx, outputFormat, options);
-  } finally {
-    await handle.detach().catch(() => {
+    if (options.outputStream) {
+      throw new AvbridgeError(
+        ERR_TRANSCODE_UNSUPPORTED_COMBO,
+        "outputStream is not yet supported for the libav-backed transcode path.",
+        "Remove the outputStream option to receive the transcoded blob in memory. Streaming output for this path is on the roadmap."
+      );
+    }
+    const bufferTarget = new mb.BufferTarget();
+    const output = new mb.Output({
+      format: createOutputFormat2(mb, outputFormat),
+      target: bufferTarget
     });
-  }
-}
-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 ? avbridgeVideoToMediabunny(videoTrackInfo.codec) : null;
-  const mbAudioCodec = audioTrackInfo ? 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 bridge = await loadBridge();
+    let videoDecoder = null;
+    let videoSoftDec = null;
+    let videoSource = null;
+    let videoBsfCtx = null;
+    let videoBsfPkt = null;
+    let videoWidth = 0;
+    let videoHeight = 0;
+    let videoTimeBase;
+    const frameQueue = [];
+    const MAX_QUEUE = 16;
+    let draining = false;
+    let drainError = null;
+    let activeDrain = null;
+    const drain = () => {
+      if (draining) return activeDrain ?? Promise.resolve();
+      draining = true;
+      const run = (async () => {
+        try {
+          while (frameQueue.length > 0 && !drainError) {
+            const frame = frameQueue.shift();
+            try {
+              const sample = new mb.VideoSample(frame, {
+                timestamp: (frame.timestamp ?? 0) / 1e6
+                // µs → s
+              });
+              await videoSource.add(sample);
+            } finally {
+              frame.close();
+            }
+          }
+        } catch (err) {
+          drainError = err;
+          while (frameQueue.length > 0) {
+            try {
+              frameQueue.shift().close();
+            } catch {
+            }
+          }
+        } finally {
+          draining = false;
+          activeDrain = null;
+        }
+      })();
+      activeDrain = run;
+      return run;
+    };
+    if (demux.videoStream && !options.dropVideo) {
+      try {
+        const bitDepth = ctx.videoTracks[0]?.bitDepth ?? 8;
+        if (bitDepth > 8) {
+          throw new AvbridgeError(
+            ERR_TRANSCODE_UNSUPPORTED_COMBO,
+            `transcode: 10-bit video is not supported in this release (source bit depth: ${bitDepth}).`,
+            `Phase 1 transcode handles 8-bit video only. 10-bit support is on the roadmap.`
+          );
+        }
+        if (demux.videoStream.time_base_num && demux.videoStream.time_base_den) {
+          videoTimeBase = [demux.videoStream.time_base_num, demux.videoStream.time_base_den];
+        }
+        let config = null;
+        try {
+          config = await bridge.videoStreamToConfig(demux.libav, demux.videoStream);
+        } catch {
+          config = null;
+        }
+        const supported = config ? await VideoDecoder.isConfigSupported(config).catch(() => ({ supported: false })) : { supported: false };
+        videoWidth = config?.codedWidth ?? ctx.videoTracks[0]?.width ?? 0;
+        videoHeight = config?.codedHeight ?? ctx.videoTracks[0]?.height ?? 0;
+        if (config && supported.supported) {
+          videoDecoder = new VideoDecoder({
+            output: (frame) => {
+              if (frameQueue.length >= MAX_QUEUE) {
+                frame.close();
+                return;
+              }
+              frameQueue.push(frame);
+              void drain();
+            },
+            error: (err) => {
+              drainError = err;
+            }
+          });
+          videoDecoder.configure(config);
+        } else {
+          const libavSoft = demux.libav;
+          const [, c, pkt, frame] = await libavSoft.ff_init_decoder(
+            demux.videoStream.codec_id,
+            { codecpar: demux.videoStream.codecpar }
+          );
+          videoSoftDec = { c, pkt, frame };
+        }
+        videoSource = new mb.VideoSampleSource({
+          codec: avbridgeVideoToMediabunny(videoCodec),
+          bitrate: qualityToMediabunny(mb, quality, options.videoBitrate),
+          ...options.frameRate !== void 0 ? { frameRate: options.frameRate } : {},
+          ...options.hardwareAcceleration !== void 0 ? { hardwareAcceleration: options.hardwareAcceleration } : {},
+          // Progress reporting: media-time-based via each encoded packet.
+          onEncodedPacket: options.onProgress ? (packet) => {
+            const t = packet.timestamp;
+            if (Number.isFinite(t) && ctx.duration && ctx.duration > 0) {
+              const pct = Math.min(100, t / ctx.duration * 100);
+              options.onProgress({ percent: pct, bytesWritten: 0 });
+            }
+          } : void 0
+        });
+        const videoMeta = {};
+        if (options.width !== void 0) videoMeta.width = options.width;
+        else if (videoWidth > 0) videoMeta.width = videoWidth;
+        if (options.height !== void 0) videoMeta.height = options.height;
+        else if (videoHeight > 0) videoMeta.height = videoHeight;
+        if (options.frameRate !== void 0) videoMeta.frameRate = options.frameRate;
+        output.addVideoTrack(videoSource, videoMeta);
+        if (ctx.videoTracks[0]?.codec === "mpeg4") {
+          const runtime = demux.libav;
+          try {
+            videoBsfCtx = await runtime.av_bsf_list_parse_str_js("mpeg4_unpack_bframes");
+            if (videoBsfCtx != null && videoBsfCtx >= 0) {
+              const parIn = await runtime.AVBSFContext_par_in(videoBsfCtx);
+              await runtime.avcodec_parameters_copy(parIn, demux.videoStream.codecpar);
+              await runtime.av_bsf_init(videoBsfCtx);
+              videoBsfPkt = await demux.libav.av_packet_alloc();
+            } else {
+              videoBsfCtx = null;
+            }
+          } catch {
+            videoBsfCtx = null;
+          }
+        }
+      } catch (err) {
+        if (err instanceof AvbridgeError) throw err;
+        throw new AvbridgeError(
+          ERR_CODEC_NOT_SUPPORTED,
+          `transcode: video decoder init failed: ${err.message}`,
+          `The source's video codec may not be supported by this browser's WebCodecs implementation.`
+        );
+      }
     }
-    const videoPackets = videoStream ? packets[videoStream.index] ?? [] : [];
-    const audioPackets = audioStream ? packets[audioStream.index] ?? [] : [];
-    if (videoSource) {
-      for (const pkt of videoPackets) {
+    let audioDec = null;
+    let audioSource = null;
+    let audioTimeBase;
+    const includeAudio = demux.audioStream && !options.dropAudio;
+    if (includeAudio) {
+      try {
+        const libav = demux.libav;
+        const [, c, pkt, frame] = await libav.ff_init_decoder(
+          demux.audioStream.codec_id,
+          { codecpar: demux.audioStream.codecpar }
+        );
+        audioDec = { c, pkt, frame };
+        if (demux.audioStream.time_base_num && demux.audioStream.time_base_den) {
+          audioTimeBase = [
+            demux.audioStream.time_base_num,
+            demux.audioStream.time_base_den
+          ];
+        }
+        audioSource = new mb.AudioSampleSource({
+          codec: avbridgeAudioToMediabunny(audioCodec),
+          bitrate: qualityToMediabunny(mb, quality, options.audioBitrate)
+        });
+        output.addAudioTrack(audioSource);
+      } catch (err) {
+        const codecName = ctx.audioTracks[0]?.codec ?? "unknown";
+        throw new AvbridgeError(
+          ERR_CODEC_NOT_SUPPORTED,
+          `transcode: no decoder available for audio codec "${codecName}" in this libav variant (${err.message}).`,
+          `The file may still play via createPlayer() (fallback strategy). Pass { dropAudio: true } to transcode video-only.`
+        );
+      }
+    } else if (options.dropAudio) {
+    }
+    if (!videoSource && !audioSource) {
+      throw new AvbridgeError(
+        ERR_TRANSCODE_UNSUPPORTED_COMBO,
+        "transcode: no video or audio track to encode (did you set both dropVideo and dropAudio?).",
+        "Remove dropVideo or dropAudio to include at least one track."
+      );
+    }
+    await output.start();
+    const videoFps = ctx.videoTracks[0]?.fps && ctx.videoTracks[0].fps > 0 ? ctx.videoTracks[0].fps : 30;
+    const videoFrameStepUs = Math.max(1, Math.round(1e6 / videoFps));
+    let syntheticVideoUs = 0;
+    let syntheticAudioUs = 0;
+    const libavFull = demux.libav;
+    async function applyBSF(packets) {
+      if (!videoBsfCtx || !videoBsfPkt) return packets;
+      const out = [];
+      for (const pkt of packets) {
+        await libavFull.ff_copyin_packet(videoBsfPkt, pkt);
+        const sendErr = await libavFull.av_bsf_send_packet(videoBsfCtx, videoBsfPkt);
+        if (sendErr < 0) {
+          out.push(pkt);
+          continue;
+        }
+        while (true) {
+          const recvErr = await libavFull.av_bsf_receive_packet(videoBsfCtx, videoBsfPkt);
+          if (recvErr < 0) break;
+          out.push(await libavFull.ff_copyout_packet(videoBsfPkt));
+        }
+      }
+      return out;
+    }
+    const ac = options.signal;
+    const onVideoPacketsWebCodecs = videoDecoder ? async (pkts) => {
+      throwIfAborted2();
+      throwIfDrainError2();
+      while (!ac?.aborted && (videoDecoder.decodeQueueSize > 16 || frameQueue.length >= MAX_QUEUE - 2)) {
+        await new Promise((r) => setTimeout(r, 10));
+      }
+      throwIfAborted2();
+      const processed = await applyBSF(pkts);
+      const bridgeAny = bridge;
+      for (const pkt of processed) {
         sanitizePacketTimestamp(pkt, () => {
           const ts = syntheticVideoUs;
           syntheticVideoUs += videoFrameStepUs;
           return ts;
         }, videoTimeBase);
-        if (videoTrackInfo && (videoTrackInfo.codec === "h264" || videoTrackInfo.codec === "h265") && isAnnexB(pkt.data)) {
-          pkt.data = annexBToAvcc(pkt.data);
+        try {
+          const chunk = bridgeAny.packetToEncodedVideoChunk(pkt, demux.videoStream);
+          videoDecoder.decode(chunk);
+        } catch (err) {
+          throw new AvbridgeError(
+            ERR_TRANSCODE_DECODE,
+            `transcode: packet \u2192 EncodedVideoChunk failed: ${err.message}`,
+            void 0
+          );
         }
-        const mbPacket = libavPacketToMediAbunny(mb, pkt);
-        await videoSource.add(
-          mbPacket,
-          firstVideoMeta ? { decoderConfig: buildVideoDecoderConfig(videoTrackInfo) } : void 0
+      }
+    } : void 0;
+    const onVideoPacketsSoftware = videoSoftDec ? async (pkts) => {
+      throwIfAborted2();
+      throwIfDrainError2();
+      while (!ac?.aborted && frameQueue.length >= MAX_QUEUE - 2) {
+        await new Promise((r) => setTimeout(r, 10));
+      }
+      throwIfAborted2();
+      const libavSoft = demux.libav;
+      let frames;
+      try {
+        frames = await libavSoft.ff_decode_multi(
+          videoSoftDec.c,
+          videoSoftDec.pkt,
+          videoSoftDec.frame,
+          pkts,
+          { ignoreErrors: true }
         );
-        firstVideoMeta = false;
+      } catch (err) {
+        throw new AvbridgeError(
+          ERR_TRANSCODE_DECODE,
+          `transcode: software video decode failed: ${err.message}`,
+          void 0
+        );
+      }
+      for (const f of frames) {
+        sanitizeFrameTimestamp(f, () => {
+          const ts = syntheticVideoUs;
+          syntheticVideoUs += videoFrameStepUs;
+          return ts;
+        }, videoTimeBase);
+        try {
+          const vf = bridge.laFrameToVideoFrame(f, { timeBase: [1, 1e6] });
+          if (frameQueue.length >= MAX_QUEUE) {
+            vf.close();
+          } else {
+            frameQueue.push(vf);
+            void drain();
+          }
+        } catch (err) {
+          throw new AvbridgeError(
+            ERR_TRANSCODE_DECODE,
+            `transcode: laFrameToVideoFrame failed: ${err.message}`,
+            void 0
+          );
+        }
+      }
+    } : void 0;
+    await demux.pump({
+      signal: ac,
+      onVideoPackets: onVideoPacketsWebCodecs ?? onVideoPacketsSoftware,
+      onAudioPackets: audioDec ? async (pkts) => {
+        throwIfAborted2();
+        await decodeAudioBatch(pkts, false);
+      } : void 0,
+      onEof: async () => {
+        if (videoDecoder && videoDecoder.state === "configured") {
+          try {
+            await videoDecoder.flush();
+          } catch {
+          }
+        }
+        if (videoSoftDec) {
+          const libavSoft = demux.libav;
+          try {
+            const tail = await libavSoft.ff_decode_multi(
+              videoSoftDec.c,
+              videoSoftDec.pkt,
+              videoSoftDec.frame,
+              [],
+              { fin: true, ignoreErrors: true }
+            );
+            for (const f of tail) {
+              sanitizeFrameTimestamp(f, () => {
+                const ts = syntheticVideoUs;
+                syntheticVideoUs += videoFrameStepUs;
+                return ts;
+              }, videoTimeBase);
+              try {
+                const vf = bridge.laFrameToVideoFrame(f, { timeBase: [1, 1e6] });
+                frameQueue.push(vf);
+                void drain();
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        await drain();
+        if (audioDec) {
+          await decodeAudioBatch([], true);
+        }
       }
+    });
+    throwIfAborted2();
+    throwIfDrainError2();
+    videoSource?.close();
+    audioSource?.close();
+    await output.finalize();
+    if (!bufferTarget.buffer) {
+      throw new Error("transcode: mediabunny produced no output buffer");
     }
-    if (audioSource) {
-      for (const pkt of audioPackets) {
-        sanitizePacketTimestamp(pkt, () => {
+    const mimeType = mimeForFormat2(outputFormat);
+    const blob = new Blob([bufferTarget.buffer], { type: mimeType });
+    options.onProgress?.({ percent: 100, bytesWritten: blob.size });
+    return {
+      blob,
+      mimeType,
+      container: outputFormat,
+      videoCodec: videoSource ? videoCodec : void 0,
+      audioCodec: audioSource ? audioCodec : void 0,
+      duration: ctx.duration,
+      filename: generateFilename2(ctx.name, outputFormat)
+    };
+    async function decodeAudioBatch(pkts, flush) {
+      if (!audioDec || !audioSource) return;
+      const libav = demux.libav;
+      let frames;
+      try {
+        frames = await libav.ff_decode_multi(
+          audioDec.c,
+          audioDec.pkt,
+          audioDec.frame,
+          pkts,
+          flush ? { fin: true, ignoreErrors: true } : { ignoreErrors: true }
+        );
+      } catch (err) {
+        throw new AvbridgeError(
+          ERR_TRANSCODE_DECODE,
+          `transcode: audio decode failed: ${err.message}`,
+          void 0
+        );
+      }
+      for (const f of frames) {
+        sanitizeFrameTimestamp(f, () => {
           const ts = syntheticAudioUs;
-          const sampleRate = audioTrackInfo?.sampleRate ?? 44100;
-          syntheticAudioUs += Math.round(1024 * 1e6 / sampleRate);
+          const samples = f.nb_samples ?? 1024;
+          const sampleRate = f.sample_rate ?? 44100;
+          syntheticAudioUs += Math.round(samples * 1e6 / sampleRate);
           return ts;
         }, audioTimeBase);
-        const mbPacket = libavPacketToMediAbunny(mb, pkt);
-        await audioSource.add(
-          mbPacket,
-          firstAudioMeta ? { decoderConfig: buildAudioDecoderConfig(audioTrackInfo) } : void 0
-        );
-        firstAudioMeta = false;
+        const pcm = libavFrameToInterleavedFloat32(f);
+        if (!pcm) continue;
+        const sample = new mb.AudioSample({
+          data: pcm.data,
+          format: "f32",
+          numberOfChannels: pcm.channels,
+          sampleRate: pcm.sampleRate,
+          timestamp: (f.pts ?? 0) / 1e6
+        });
+        await audioSource.add(sample);
       }
     }
-    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;
+  } finally {
+    try {
+      await demux.destroy();
+    } catch {
     }
   }
-  await output.finalize();
-  try {
-    await libav.av_packet_free?.(readPkt);
-  } catch {
-  }
+}
+async function loadBridge() {
   try {
-    await libav.avformat_close_input_js(fmt_ctx);
-  } catch {
-  }
-  if (!target.buffer) {
-    throw new Error("Remux failed: mediabunny produced no output buffer.");
+    const wrapper = await import('./libav-import-6MGLCXVQ.js');
+    return wrapper.libavBridge;
+  } catch (err) {
+    throw new Error(`failed to load libavjs-webcodecs-bridge: ${err.message}`);
   }
-  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;
+function avbridgeVideoToMediabunny(c) {
+  switch (c) {
+    case "h264":
+      return "avc";
+    case "h265":
+      return "hevc";
+    case "vp9":
+      return "vp9";
+    case "av1":
+      return "av1";
   }
-  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 avbridgeAudioToMediabunny(c) {
+  switch (c) {
+    case "aac":
+      return "aac";
+    case "opus":
+      return "opus";
+    case "flac":
+      return "flac";
   }
 }
-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 qualityToMediabunny(mb, quality, override) {
+  if (override !== void 0) return override;
+  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;
   }
 }
-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([
+var MEDIABUNNY_CONTAINERS = /* @__PURE__ */ new Set([
   "mp4",
   "mov",
   "mkv",
@@ -415,9 +538,14 @@ async function transcode(source, options = {}) {
   options.signal?.throwIfAborted();
   const ctx = await 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.`
+  if (isLibavTranscodeContainer(ctx.container)) {
+    return transcodeViaLibav(ctx, options);
+  }
+  if (!MEDIABUNNY_CONTAINERS.has(ctx.container)) {
+    throw new AvbridgeError(
+      ERR_CONTAINER_NOT_SUPPORTED,
+      `Cannot transcode "${ctx.container}" sources. transcode() supports mediabunny-readable containers (MP4, MKV, WebM, OGG, MP3, FLAC, WAV, MOV) and legacy containers via the libav path (AVI, ASF, FLV).`,
+      `If this is a legacy container we don't yet support, use createPlayer() to play it. Transcode support for more containers is on the roadmap.`
     );
   }
   return doTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, options);
@@ -444,7 +572,7 @@ async function attemptTranscode(ctx, outputFormat, videoCodec, audioCodec, quali
   });
   const videoOptions = options.dropVideo ? { discard: true } : {
     codec: avbridgeVideoToMediabunny2(videoCodec),
-    bitrate: options.videoBitrate ?? qualityToMediabunny(mb, quality),
+    bitrate: options.videoBitrate ?? qualityToMediabunny2(mb, quality),
     forceTranscode: true,
     ...options.width !== void 0 ? { width: options.width } : {},
     ...options.height !== void 0 ? { height: options.height } : {},
@@ -454,7 +582,7 @@ async function attemptTranscode(ctx, outputFormat, videoCodec, audioCodec, quali
   };
   const audioOptions = options.dropAudio ? { discard: true } : {
     codec: avbridgeAudioToMediabunny2(audioCodec),
-    bitrate: options.audioBitrate ?? qualityToMediabunny(mb, quality),
+    bitrate: options.audioBitrate ?? qualityToMediabunny2(mb, quality),
     forceTranscode: true
   };
   const conversion = await mb.Conversion.init({
@@ -617,7 +745,7 @@ function avbridgeAudioToMediabunny2(c) {
       return "flac";
   }
 }
-function qualityToMediabunny(mb, quality) {
+function qualityToMediabunny2(mb, quality) {
   switch (quality) {
     case "low":
       return mb.QUALITY_LOW;
@@ -630,6 +758,6 @@ function qualityToMediabunny(mb, quality) {
   }
 }
 
-export { remux, transcode };
+export { transcode };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map