avbridge 2.1.0 → 2.1.2

package/dist/element-browser.js

@@ -1,5 +1,3 @@
-import * as bridge from 'libavjs-webcodecs-bridge';
-
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -29902,6 +29900,910 @@ var init_avi = __esm({
   }
 });
 
+// node_modules/libavjs-webcodecs-bridge/dist/libavjs-webcodecs-bridge.mjs
+var libavjs_webcodecs_bridge_exports = {};
+__export(libavjs_webcodecs_bridge_exports, {
+  audioDataToLAFrame: () => audioDataToLAFrame,
+  audioStreamToConfig: () => audioStreamToConfig,
+  configToAudioStream: () => configToAudioStream,
+  configToVideoStream: () => configToVideoStream,
+  encodedAudioChunkToPacket: () => encodedAudioChunkToPacket,
+  encodedVideoChunkToPacket: () => encodedVideoChunkToPacket,
+  laFrameToAudioData: () => laFrameToAudioData,
+  laFrameToVideoFrame: () => laFrameToVideoFrame,
+  packetToEncodedAudioChunk: () => packetToEncodedAudioChunk,
+  packetToEncodedVideoChunk: () => packetToEncodedVideoChunk,
+  videoFrameToLAFrame: () => videoFrameToLAFrame,
+  videoStreamToConfig: () => videoStreamToConfig
+});
+function audioStreamToConfig$1(libav, stream) {
+  return __awaiter$2(this, void 0, void 0, function* () {
+    let codecpar;
+    if (stream.codecpar) {
+      codecpar = yield libav.ff_copyout_codecpar(stream.codecpar);
+    } else {
+      codecpar = stream;
+    }
+    const codecString = yield libav.avcodec_get_name(codecpar.codec_id);
+    const ret = {
+      codec: "unknown",
+      sampleRate: codecpar.sample_rate,
+      numberOfChannels: codecpar.channels
+    };
+    const extradata = codecpar.extradata;
+    switch (codecString) {
+      case "flac":
+        ret.codec = "flac";
+        ret.description = extradata;
+        break;
+      case "mp3":
+        ret.codec = "mp3";
+        break;
+      case "aac": {
+        const profile = codecpar.profile;
+        switch (profile) {
+          case 1:
+          // AAC_LOW
+          default:
+            ret.codec = "mp4a.40.2";
+            break;
+          case 4:
+            ret.codec = "mp4a.40.5";
+            break;
+          case 28:
+            ret.codec = "mp4a.40.29";
+            break;
+        }
+        if (extradata)
+          ret.description = extradata;
+        break;
+      }
+      case "opus":
+        ret.codec = "opus";
+        break;
+      case "vorbis":
+        ret.codec = "vorbis";
+        ret.description = extradata;
+        break;
+      default:
+        if (typeof LibAVWebCodecs !== "undefined") {
+          ret.codec = { libavjs: {
+            codec: codecString,
+            ctx: {
+              channels: codecpar.channels,
+              sample_rate: codecpar.sample_rate
+            }
+          } };
+          if (extradata)
+            ret.description = extradata;
+        }
+        break;
+    }
+    if (ret.codec)
+      return ret;
+    return null;
+  });
+}
+function videoStreamToConfig$1(libav, stream) {
+  return __awaiter$2(this, void 0, void 0, function* () {
+    let codecpar;
+    if (stream.codecpar) {
+      codecpar = yield libav.ff_copyout_codecpar(stream.codecpar);
+    } else {
+      codecpar = stream;
+    }
+    const codecString = yield libav.avcodec_get_name(codecpar.codec_id);
+    const ret = {
+      codec: "unknown",
+      codedWidth: codecpar.width,
+      codedHeight: codecpar.height
+    };
+    const extradata = codecpar.extradata;
+    let profile = codecpar.profile;
+    let level = codecpar.level;
+    switch (codecString) {
+      case "av1": {
+        let codec = "av01";
+        if (profile < 0)
+          profile = 0;
+        codec += `.0${profile}`;
+        if (level < 0)
+          level = 0;
+        let levelS = level.toString();
+        if (levelS.length < 2)
+          levelS = `0${level}`;
+        const tier = "M";
+        codec += `.${levelS}${tier}`;
+        const format = codecpar.format;
+        const desc = yield libav.av_pix_fmt_desc_get(format);
+        let bitDepth = (yield libav.AVPixFmtDescriptor_comp_depth(desc, 0)).toString();
+        if (bitDepth.length < 2)
+          bitDepth = `0${bitDepth}`;
+        codec += `.${bitDepth}`;
+        const nbComponents = yield libav.AVPixFmtDescriptor_nb_components(desc);
+        if (nbComponents < 2)
+          codec += ".1";
+        else
+          codec += ".0";
+        let subX = 0, subY = 0, subP = 0;
+        if (nbComponents < 2) {
+          subX = 1;
+          subY = 1;
+        } else {
+          subX = yield libav.AVPixFmtDescriptor_log2_chroma_w(desc);
+          subY = yield libav.AVPixFmtDescriptor_log2_chroma_h(desc);
+        }
+        codec += `.${subX}${subY}${subP}`;
+        ret.codec = codec;
+        break;
+      }
+      case "h264": {
+        let codec = "avc1";
+        if (extradata && (extradata[0] | extradata[1] | extradata[2]) === 0 && extradata[3] === 1 && (extradata[4] & 31) === 7) {
+          codec += ".";
+          for (let i = 5; i <= 7; i++) {
+            let s = extradata[i].toString(16);
+            if (s.length < 2)
+              s = "0" + s;
+            codec += s;
+          }
+        } else {
+          if (profile < 0)
+            profile = 77;
+          const profileB = profile & 255;
+          let profileS = profileB.toString(16);
+          if (profileS.length < 2)
+            profileS = `0${profileS}`;
+          codec += `.${profileS}`;
+          let constraints = 0;
+          if (profile & 256) {
+            if (profileB === 66) {
+              constraints |= 224;
+            } else if (profileB === 77) {
+              constraints |= 96;
+            } else if (profile === 88) {
+              constraints |= 32;
+            } else {
+              break;
+            }
+          }
+          let constraintsS = constraints.toString(16);
+          if (constraintsS.length < 2)
+            constraintsS = `0${constraintsS}`;
+          codec += constraintsS;
+          if (level < 0)
+            level = 10;
+          let levelS = level.toString(16);
+          if (levelS.length < 2)
+            levelS = `0${levelS}`;
+          codec += levelS;
+        }
+        ret.codec = codec;
+        if (extradata && extradata[0])
+          ret.description = extradata;
+        break;
+      }
+      case "hevc": {
+        let codec;
+        if (extradata && extradata.length > 12) {
+          codec = "hvc1";
+          const dv = new DataView(extradata.buffer);
+          ret.description = extradata;
+          codec += ".";
+          const profileSpace = extradata[1] >> 6;
+          switch (profileSpace) {
+            case 1:
+              codec += "A";
+              break;
+            case 2:
+              codec += "B";
+              break;
+            case 3:
+              codec += "C";
+              break;
+          }
+          const profileIDC = extradata[1] & 31;
+          codec += profileIDC + ".";
+          const profileCompatibility = dv.getUint32(2);
+          let val = profileCompatibility;
+          let reversed = 0;
+          for (let i = 0; i < 32; i++) {
+            reversed |= val & 1;
+            if (i === 31)
+              break;
+            reversed <<= 1;
+            val >>= 1;
+          }
+          codec += reversed.toString(16) + ".";
+          const tierFlag = (extradata[1] & 32) >> 5;
+          if (tierFlag === 0)
+            codec += "L";
+          else
+            codec += "H";
+          const levelIDC = extradata[12];
+          codec += levelIDC;
+          let constraintString = "";
+          for (let i = 11; i >= 6; i--) {
+            const b = extradata[i];
+            if (b || constraintString)
+              constraintString = "." + b.toString(16) + constraintString;
+          }
+          codec += constraintString;
+        } else {
+          if (profile < 0)
+            profile = 0;
+          if (level < 0)
+            level = 0;
+          codec = `hev1.${profile}.4.L${level}.B01`;
+        }
+        ret.codec = codec;
+        break;
+      }
+      case "vp8":
+        ret.codec = "vp8";
+        break;
+      case "vp9": {
+        let codec = "vp09";
+        let profileS = profile.toString();
+        if (profile < 0)
+          profileS = "00";
+        if (profileS.length < 2)
+          profileS = `0${profileS}`;
+        codec += `.${profileS}`;
+        let levelS = level.toString();
+        if (level < 0)
+          levelS = "10";
+        if (levelS.length < 2)
+          levelS = `0${levelS}`;
+        codec += `.${levelS}`;
+        const format = codecpar.format;
+        const desc = yield libav.av_pix_fmt_desc_get(format);
+        let bitDepth = (yield libav.AVPixFmtDescriptor_comp_depth(desc, 0)).toString();
+        if (bitDepth === "0")
+          bitDepth = "08";
+        if (bitDepth.length < 2)
+          bitDepth = `0${bitDepth}`;
+        codec += `.${bitDepth}`;
+        const subX = yield libav.AVPixFmtDescriptor_log2_chroma_w(desc);
+        const subY = yield libav.AVPixFmtDescriptor_log2_chroma_h(desc);
+        let chromaSubsampling = 0;
+        if (subX > 0 && subY > 0) {
+          chromaSubsampling = 1;
+        } else if (subX > 0 || subY > 0) {
+          chromaSubsampling = 2;
+        } else {
+          chromaSubsampling = 3;
+        }
+        codec += `.0${chromaSubsampling}`;
+        codec += ".1.1.1.0";
+        ret.codec = codec;
+        break;
+      }
+      default:
+        if (typeof LibAVWebCodecs !== "undefined") {
+          ret.codec = { libavjs: {
+            codec: codecString,
+            ctx: {
+              pix_fmt: codecpar.format,
+              width: codecpar.width,
+              height: codecpar.height
+            }
+          } };
+          if (extradata)
+            ret.description = extradata;
+        }
+        break;
+    }
+    if (ret.codec)
+      return ret;
+    return null;
+  });
+}
+function times$1(packet, timeBaseSrc) {
+  let pDuration = (packet.durationhi || 0) * 4294967296 + (packet.duration || 0);
+  let pts = (packet.ptshi || 0) * 4294967296 + (packet.pts || 0);
+  if (typeof LibAV !== "undefined" && LibAV.i64tof64) {
+    pDuration = LibAV.i64tof64(packet.duration || 0, packet.durationhi || 0);
+    pts = LibAV.i64tof64(packet.pts || 0, packet.ptshi || 0);
+  }
+  let tbNum = packet.time_base_num || 0;
+  let tbDen = packet.time_base_den || 1e6;
+  if (!tbNum) {
+    if (timeBaseSrc.length) {
+      const timeBase = timeBaseSrc;
+      tbNum = timeBase[0];
+      tbDen = timeBase[1];
+    } else {
+      const timeBase = timeBaseSrc;
+      tbNum = timeBase.time_base_num;
+      tbDen = timeBase.time_base_den;
+    }
+  }
+  const duration = Math.round(pDuration * tbNum / tbDen * 1e6);
+  let timestamp = Math.round(pts * tbNum / tbDen * 1e6);
+  return { timestamp, duration };
+}
+function packetToEncodedAudioChunk$1(packet, timeBaseSrc, opts = {}) {
+  let EAC;
+  if (opts.EncodedAudioChunk)
+    EAC = opts.EncodedAudioChunk;
+  else
+    EAC = EncodedAudioChunk;
+  const { timestamp, duration } = times$1(packet, timeBaseSrc);
+  return new EAC({
+    type: "key",
+    // all audio chunks are keyframes in all audio codecs
+    timestamp,
+    duration,
+    data: packet.data.buffer
+  });
+}
+function packetToEncodedVideoChunk$1(packet, timeBaseSrc, opts = {}) {
+  let EVC;
+  if (opts.EncodedVideoChunk)
+    EVC = opts.EncodedVideoChunk;
+  else
+    EVC = EncodedVideoChunk;
+  const { timestamp, duration } = times$1(packet, timeBaseSrc);
+  return new EVC({
+    type: (packet.flags || 0) & 1 ? "key" : "delta",
+    timestamp,
+    duration,
+    data: packet.data.buffer
+  });
+}
+function configToAudioStream$1(libav, config) {
+  return __awaiter$1(this, void 0, void 0, function* () {
+    const codecLong = config.codec;
+    let codec;
+    if (typeof codecLong === "object")
+      codec = codecLong.libavjs.codec;
+    else
+      codec = codecLong.replace(/\..*/, "");
+    switch (codec) {
+      case "mp4a":
+        codec = "aac";
+        break;
+      case "pcm-u8":
+        codec = "pcm_u8";
+        break;
+      case "pcm-s16":
+        codec = "pcm_s16le";
+        break;
+      case "pcm-s24":
+        codec = "pcm_s24le";
+        break;
+      case "pcm-s32":
+        codec = "pcm_s32le";
+        break;
+      case "pcm-f32":
+        codec = "pcm_f32le";
+        break;
+    }
+    const desc = yield libav.avcodec_descriptor_get_by_name(codec);
+    const codecpar = yield libav.avcodec_parameters_alloc();
+    if (desc) {
+      yield libav.AVCodecParameters_codec_type_s(codecpar, yield libav.AVCodecDescriptor_type(desc));
+      yield libav.AVCodecParameters_codec_id_s(codecpar, yield libav.AVCodecDescriptor_id(desc));
+      if (config.sampleRate) {
+        yield libav.AVCodecParameters_sample_rate_s(codecpar, config.sampleRate);
+      }
+      if (config.numberOfChannels) {
+        yield libav.AVCodecParameters_channels_s(codecpar, config.numberOfChannels);
+      }
+    }
+    let timebaseNum = 1, timebaseDen = 1e6;
+    if (config.sampleRate)
+      timebaseDen = config.sampleRate;
+    return [codecpar, timebaseNum, timebaseDen];
+  });
+}
+function configToVideoStream$1(libav, config) {
+  return __awaiter$1(this, void 0, void 0, function* () {
+    const codecLong = config.codec;
+    let codec;
+    if (typeof codecLong === "object")
+      codec = codecLong.libavjs.codec;
+    else
+      codec = codecLong.replace(/\..*/, "");
+    switch (codec) {
+      case "av01":
+        codec = "av1";
+        break;
+      case "avc1":
+      case "avc3":
+        codec = "h264";
+        break;
+      case "hev1":
+      case "hvc1":
+        codec = "hevc";
+        break;
+      case "vp09":
+        codec = "vp9";
+        break;
+    }
+    const desc = yield libav.avcodec_descriptor_get_by_name(codec);
+    const codecpar = yield libav.avcodec_parameters_alloc();
+    if (desc) {
+      yield libav.AVCodecParameters_codec_type_s(codecpar, yield libav.AVCodecDescriptor_type(desc));
+      yield libav.AVCodecParameters_codec_id_s(codecpar, yield libav.AVCodecDescriptor_id(desc));
+      yield libav.AVCodecParameters_width_s(codecpar, config.width);
+      yield libav.AVCodecParameters_height_s(codecpar, config.height);
+    }
+    let timebaseNum = 1, timebaseDen = 1e6;
+    if (config.framerate) {
+      if (config.framerate === ~~config.framerate) {
+        timebaseDen = config.framerate;
+      } else {
+        const fr1001 = config.framerate * 1001;
+        if (fr1001 === ~~fr1001) {
+          timebaseNum = 1001;
+          timebaseDen = fr1001;
+        } else {
+          timebaseDen = config.framerate;
+          while (timebaseDen !== Math.floor(timebaseDen)) {
+            timebaseNum *= 2;
+            timebaseDen *= 2;
+          }
+        }
+      }
+    }
+    return [codecpar, timebaseNum, timebaseDen];
+  });
+}
+function times(chunk, stream) {
+  const num = stream[1];
+  const den = stream[2];
+  return {
+    timestamp: Math.round(chunk.timestamp * den / num / 1e6),
+    duration: Math.round((chunk.duration || 0) * den / num / 1e6)
+  };
+}
+function encodedChunkToPacket(chunk, stream, streamIndex) {
+  const { timestamp, duration } = times(chunk, stream);
+  let pts, ptshi, dur, durhi;
+  if (typeof LibAV !== "undefined" && LibAV.f64toi64) {
+    [pts, ptshi] = LibAV.f64toi64(timestamp);
+    [dur, durhi] = LibAV.f64toi64(duration);
+  } else {
+    pts = ~~timestamp;
+    ptshi = Math.floor(timestamp / 4294967296);
+    dur = ~~duration;
+    durhi = Math.floor(duration / 4294967296);
+  }
+  const data = new Uint8Array(chunk.byteLength);
+  chunk.copyTo(data.buffer);
+  return {
+    data,
+    pts,
+    ptshi,
+    dts: pts,
+    dtshi: ptshi,
+    time_base_num: stream[1],
+    time_base_den: stream[2],
+    stream_index: streamIndex,
+    flags: 0,
+    duration: dur,
+    durationhi: durhi
+  };
+}
+function encodedAudioChunkToPacket$1(libav, chunk, metadata, stream, streamIndex) {
+  return __awaiter$1(this, void 0, void 0, function* () {
+    return encodedChunkToPacket(chunk, stream, streamIndex);
+  });
+}
+function encodedVideoChunkToPacket$1(libav, chunk, metadata, stream, streamIndex) {
+  return __awaiter$1(this, void 0, void 0, function* () {
+    const ret = encodedChunkToPacket(chunk, stream, streamIndex);
+    if (chunk.type === "key")
+      ret.flags = 1;
+    if (stream[0] && metadata && metadata.decoderConfig && metadata.decoderConfig.description) {
+      const codecpar = stream[0];
+      const oldExtradata = yield libav.AVCodecParameters_extradata(codecpar);
+      if (!oldExtradata) {
+        let description = metadata.decoderConfig.description;
+        if (description.buffer)
+          description = description.slice(0);
+        else
+          description = new Uint8Array(description).slice(0);
+        const extradata = yield libav.malloc(description.length);
+        yield libav.copyin_u8(extradata, description);
+        yield libav.AVCodecParameters_extradata_s(codecpar, extradata);
+        yield libav.AVCodecParameters_extradata_size_s(codecpar, description.length);
+      }
+    }
+    return ret;
+  });
+}
+function videoFrameToLAFrame$1(frame) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const data = new Uint8Array(frame.allocationSize());
+    yield frame.copyTo(data);
+    let libavjs5 = true;
+    if (typeof LibAV !== "undefined" && LibAV && LibAV.VER && parseInt(LibAV.VER) < 5) {
+      libavjs5 = false;
+    }
+    let libavFormat = 5, bpp = 1, planes = 3, cwlog2 = 0, chlog2 = 0;
+    switch (frame.format) {
+      case "I420":
+        libavFormat = 0;
+        cwlog2 = chlog2 = 1;
+        break;
+      case "I420A":
+        libavFormat = 33;
+        planes = 4;
+        cwlog2 = chlog2 = 1;
+        break;
+      case "I422":
+        libavFormat = 4;
+        cwlog2 = 1;
+        break;
+      case "NV12":
+        libavFormat = 23;
+        planes = 2;
+        chlog2 = 1;
+        break;
+      case "RGBA":
+      case "RGBX":
+        libavFormat = 26;
+        planes = 1;
+        bpp = 4;
+        break;
+      case "BGRA":
+      case "BGRX":
+        libavFormat = 28;
+        planes = 1;
+        bpp = 4;
+        break;
+    }
+    const laFrame = {
+      format: libavFormat,
+      data: null,
+      pts: ~~frame.timestamp,
+      ptshi: Math.floor(frame.timestamp / 4294967296),
+      time_base_num: 1,
+      time_base_den: 1e6,
+      width: frame.visibleRect.width,
+      height: frame.visibleRect.height
+    };
+    if (libavjs5) {
+      const layout = [];
+      let offset = 0;
+      for (let p = 0; p < planes; p++) {
+        let w = frame.visibleRect.width;
+        let h = frame.visibleRect.height;
+        if (p === 1 || p === 2) {
+          w >>= cwlog2;
+          h >>= chlog2;
+        }
+        layout.push({ offset, stride: w * bpp });
+        offset += w * h * bpp;
+      }
+      laFrame.data = data;
+      laFrame.layout = layout;
+    } else {
+      laFrame.data = [];
+      let offset = 0;
+      for (let p = 0; p < planes; p++) {
+        const plane = [];
+        laFrame.data.push(plane);
+        let wlog2 = 0, hlog2 = 0;
+        if (p === 1 || p === 2) {
+          wlog2 = cwlog2;
+          hlog2 = chlog2;
+        }
+        for (let y = 0; y < frame.visibleRect.height >>> hlog2; y++) {
+          const w = frame.visibleRect.width * bpp >>> wlog2;
+          plane.push(data.subarray(offset, offset + w));
+          offset += w;
+        }
+      }
+    }
+    return laFrame;
+  });
+}
+function audioDataToLAFrame$1(frame) {
+  return __awaiter(this, void 0, void 0, function* () {
+    let libavFormat = 6;
+    let TypedArray = Int16Array;
+    const planar = /-planar$/.test(frame.format);
+    switch (frame.format) {
+      case "u8":
+      case "u8-planar":
+        libavFormat = planar ? 5 : 0;
+        TypedArray = Uint8Array;
+        break;
+      case "s16":
+      case "s16-planar":
+        libavFormat = planar ? 6 : 1;
+        break;
+      case "s32":
+      case "s32-planar":
+        libavFormat = planar ? 7 : 2;
+        TypedArray = Int32Array;
+        break;
+      case "f32":
+      case "f32-planar":
+        libavFormat = planar ? 8 : 3;
+        TypedArray = Float32Array;
+        break;
+    }
+    const laFrame = {
+      format: libavFormat,
+      data: null,
+      pts: ~~frame.timestamp,
+      ptshi: Math.floor(frame.timestamp / 4294967296),
+      time_base_num: 1,
+      time_base_den: 1e6,
+      sample_rate: frame.sampleRate,
+      nb_samples: frame.numberOfFrames,
+      channels: frame.numberOfChannels
+    };
+    if (planar) {
+      laFrame.data = [];
+      for (let p = 0; p < frame.numberOfChannels; p++) {
+        const plane = new TypedArray(frame.numberOfFrames);
+        laFrame.data.push(plane);
+        yield frame.copyTo(plane.buffer, { planeIndex: p, format: frame.format });
+      }
+    } else {
+      const data = laFrame.data = new TypedArray(frame.numberOfFrames * frame.numberOfChannels);
+      yield frame.copyTo(data.buffer, { planeIndex: 0, format: frame.format });
+    }
+    return laFrame;
+  });
+}
+function i64tof64(lo, hi) {
+  if (!hi && lo >= 0)
+    return lo;
+  if (hi === -1 && lo < 0)
+    return lo;
+  return hi * 4294967296 + lo + (lo < 0 ? 4294967296 : 0);
+}
+function laTimeToWCTime(lo, hi, timeBase) {
+  let ret = i64tof64(lo, hi);
+  if (timeBase)
+    ret = Math.round(ret * 1e6 * timeBase[0] / timeBase[1]);
+  return ret;
+}
+function laFrameToVideoFrame$1(frame, opts = {}) {
+  let VF;
+  if (opts.VideoFrame)
+    VF = opts.VideoFrame;
+  else
+    VF = VideoFrame;
+  let layout;
+  let data;
+  let transfer = [];
+  let timeBase = opts.timeBase;
+  if (!timeBase && frame.time_base_num)
+    timeBase = [frame.time_base_num || 1, frame.time_base_den || 1e6];
+  if (frame.layout) {
+    data = frame.data;
+    layout = frame.layout;
+    if (opts.transfer)
+      transfer.push(data.buffer);
+  } else {
+    layout = [];
+    let size = 0;
+    for (let p = 0; p < frame.data.length; p++) {
+      const plane = frame.data[p];
+      layout.push({
+        offset: size,
+        stride: plane[0].length
+      });
+      size += plane.length * plane[0].length;
+    }
+    data = new Uint8Array(size);
+    let offset = 0;
+    for (let p = 0; p < frame.data.length; p++) {
+      const plane = frame.data[p];
+      const linesize = plane[0].length;
+      for (let y = 0; y < plane.length; y++) {
+        data.set(plane[y], offset);
+        offset += linesize;
+      }
+    }
+    transfer.push(data.buffer);
+  }
+  let format = "I420";
+  switch (frame.format) {
+    case 0:
+      format = "I420";
+      break;
+    case 33:
+      format = "I420A";
+      break;
+    case 4:
+      format = "I422";
+      break;
+    case 23:
+      format = "NV12";
+      break;
+    case 26:
+      format = "RGBA";
+      break;
+    case 28:
+      format = "BGRA";
+      break;
+    default:
+      throw new Error("Unsupported pixel format");
+  }
+  return new VF(data, {
+    format,
+    codedWidth: frame.width,
+    codedHeight: frame.height,
+    timestamp: laTimeToWCTime(frame.pts || 0, frame.ptshi || 0, timeBase),
+    layout,
+    transfer
+  });
+}
+function laFrameToAudioData$1(frame, opts = {}) {
+  let AD;
+  if (opts.AudioData)
+    AD = opts.AudioData;
+  else
+    AD = AudioData;
+  let timeBase = opts.timeBase;
+  if (!timeBase && frame.time_base_num)
+    timeBase = [frame.time_base_num || 1, frame.time_base_den || 1e6];
+  let size = 0;
+  if (frame.data.buffer) {
+    size = frame.data.byteLength;
+  } else {
+    for (let p = 0; p < frame.data.length; p++)
+      size += frame.data[p].byteLength;
+  }
+  const data = new Uint8Array(size);
+  if (frame.data.buffer) {
+    const rd = frame.data;
+    data.set(new Uint8Array(rd.buffer, rd.byteOffset, rd.byteLength));
+  } else {
+    let offset = 0;
+    for (let p = 0; p < frame.data.length; p++) {
+      const rp = frame.data[p];
+      const plane = new Uint8Array(rp.buffer, rp.byteOffset, rp.byteLength);
+      data.set(plane, offset);
+      offset += plane.length;
+    }
+  }
+  let format = "s16";
+  switch (frame.format) {
+    case 0:
+      format = "u8";
+      break;
+    case 1:
+      format = "s16";
+      break;
+    case 2:
+      format = "s32";
+      break;
+    case 3:
+      format = "f32";
+      break;
+    case 5:
+      format = "u8-planar";
+      break;
+    case 6:
+      format = "s16-planar";
+      break;
+    case 7:
+      format = "s32-planar";
+      break;
+    case 8:
+      format = "f32-planar";
+      break;
+    default:
+      throw new Error("Unsupported sample format");
+  }
+  return new AD({
+    format,
+    data,
+    sampleRate: frame.sample_rate,
+    numberOfFrames: frame.nb_samples,
+    numberOfChannels: frame.channels,
+    timestamp: laTimeToWCTime(frame.pts || 0, frame.ptshi || 0, timeBase)
+  });
+}
+var __awaiter$2, __awaiter$1, __awaiter, audioStreamToConfig, videoStreamToConfig, packetToEncodedAudioChunk, packetToEncodedVideoChunk, configToAudioStream, configToVideoStream, encodedAudioChunkToPacket, encodedVideoChunkToPacket, videoFrameToLAFrame, audioDataToLAFrame, laFrameToVideoFrame, laFrameToAudioData;
+var init_libavjs_webcodecs_bridge = __esm({
+  "node_modules/libavjs-webcodecs-bridge/dist/libavjs-webcodecs-bridge.mjs"() {
+    __awaiter$2 = function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    __awaiter$1 = function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    __awaiter = function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    audioStreamToConfig = audioStreamToConfig$1;
+    videoStreamToConfig = videoStreamToConfig$1;
+    packetToEncodedAudioChunk = packetToEncodedAudioChunk$1;
+    packetToEncodedVideoChunk = packetToEncodedVideoChunk$1;
+    configToAudioStream = configToAudioStream$1;
+    configToVideoStream = configToVideoStream$1;
+    encodedAudioChunkToPacket = encodedAudioChunkToPacket$1;
+    encodedVideoChunkToPacket = encodedVideoChunkToPacket$1;
+    videoFrameToLAFrame = videoFrameToLAFrame$1;
+    audioDataToLAFrame = audioDataToLAFrame$1;
+    laFrameToVideoFrame = laFrameToVideoFrame$1;
+    laFrameToAudioData = laFrameToAudioData$1;
+  }
+});
+
 // src/strategies/fallback/libav-import.ts
 var libav_import_exports = {};
 __export(libav_import_exports, {
@@ -29910,7 +30812,8 @@ __export(libav_import_exports, {
 var libavBridge;
 var init_libav_import = __esm({
   "src/strategies/fallback/libav-import.ts"() {
-    libavBridge = bridge;
+    init_libavjs_webcodecs_bridge();
+    libavBridge = libavjs_webcodecs_bridge_exports;
   }
 });
 
@@ -30147,10 +31050,21 @@ async function probe(source) {
   if (MEDIABUNNY_CONTAINERS.has(sniffed)) {
     try {
       return await probeWithMediabunny(normalized, sniffed);
-    } catch (err) {
-      throw new Error(
-        `mediabunny failed to probe a ${sniffed} file: ${err.message}`
+    } catch (mediabunnyErr) {
+      console.warn(
+        `[avbridge] mediabunny rejected ${sniffed} file, falling back to libav:`,
+        mediabunnyErr.message
       );
+      try {
+        const { probeWithLibav: probeWithLibav2 } = await Promise.resolve().then(() => (init_avi(), avi_exports));
+        return await probeWithLibav2(normalized, sniffed);
+      } catch (libavErr) {
+        const mbMsg = mediabunnyErr.message || String(mediabunnyErr);
+        const lvMsg = libavErr instanceof Error ? libavErr.message : String(libavErr);
+        throw new Error(
+          `failed to probe ${sniffed} file. mediabunny: ${mbMsg}. libav fallback: ${lvMsg}.`
+        );
+      }
     }
   }
   try {
@@ -30873,7 +31787,8 @@ async function createRemuxPipeline(ctx, video) {
       if (destroyed || pumpToken !== token) break;
       const vTs = !vNext.done ? vNext.value.timestamp : Number.POSITIVE_INFINITY;
       const aTs = !aNext.done ? aNext.value.timestamp : Number.POSITIVE_INFINITY;
-      if (!vNext.done && vTs <= aTs) {
+      const forceVideoFirst = firstVideo && !vNext.done;
+      if (!vNext.done && (forceVideoFirst || vTs <= aTs)) {
         await videoSource.add(
           vNext.value,
           firstVideo && videoConfig ? { decoderConfig: videoConfig } : void 0
@@ -31011,11 +31926,20 @@ var VideoRenderer = class {
     });
     this.canvas = document.createElement("canvas");
     this.canvas.style.cssText = "position:absolute;left:0;top:0;width:100%;height:100%;background:black;";
-    const parent = target.parentElement;
-    if (parent && getComputedStyle(parent).position === "static") {
-      parent.style.position = "relative";
+    const parent = target.parentElement ?? target.parentNode;
+    if (parent && parent instanceof HTMLElement) {
+      if (getComputedStyle(parent).position === "static") {
+        parent.style.position = "relative";
+      }
+    }
+    if (parent) {
+      parent.insertBefore(this.canvas, target);
+    } else {
+      console.warn(
+        "[avbridge] fallback renderer: target <video> has no parent; appending canvas to document.body as a fallback."
+      );
+      document.body.appendChild(this.canvas);
     }
-    parent?.insertBefore(this.canvas, target);
     target.style.visibility = "hidden";
     const ctx = this.canvas.getContext("2d");
     if (!ctx) throw new Error("video renderer: failed to acquire 2D context");
@@ -31375,7 +32299,7 @@ function pickLibavVariant(ctx) {
 async function startHybridDecoder(opts) {
   const variant = pickLibavVariant(opts.context);
   const libav = await loadLibav(variant);
-  const bridge2 = await loadBridge();
+  const bridge = await loadBridge();
   const { prepareLibavInput: prepareLibavInput2 } = await Promise.resolve().then(() => (init_libav_http_reader(), libav_http_reader_exports));
   const inputHandle = await prepareLibavInput2(libav, opts.filename, opts.source);
   const readPkt = await libav.av_packet_alloc();
@@ -31396,7 +32320,7 @@ async function startHybridDecoder(opts) {
   let videoTimeBase;
   if (videoStream) {
     try {
-      const config = await bridge2.videoStreamToConfig(libav, videoStream);
+      const config = await bridge.videoStreamToConfig(libav, videoStream);
       if (!config) throw new Error("bridge returned null config");
       const supported = await VideoDecoder.isConfigSupported(config);
       if (!supported.supported) throw new Error(`VideoDecoder does not support config: ${JSON.stringify(config)}`);
@@ -31484,7 +32408,7 @@ async function startHybridDecoder(opts) {
             return ts;
           }, videoTimeBase);
           try {
-            const chunk = bridge2.packetToEncodedVideoChunk(pkt, videoStream);
+            const chunk = bridge.packetToEncodedVideoChunk(pkt, videoStream);
             videoDecoder.decode(chunk);
             videoChunksFed++;
           } catch (err) {
@@ -31918,7 +32842,7 @@ init_libav_loader();
 async function startDecoder(opts) {
   const variant = pickLibavVariant(opts.context);
   const libav = await loadLibav(variant);
-  const bridge2 = await loadBridge2();
+  const bridge = await loadBridge2();
   const { prepareLibavInput: prepareLibavInput2 } = await Promise.resolve().then(() => (init_libav_http_reader(), libav_http_reader_exports));
   const inputHandle = await prepareLibavInput2(libav, opts.filename, opts.source);
   const readPkt = await libav.av_packet_alloc();
@@ -32062,7 +32986,7 @@ async function startDecoder(opts) {
         videoTimeBase
       );
       try {
-        const vf = bridge2.laFrameToVideoFrame(f, bridgeOpts);
+        const vf = bridge.laFrameToVideoFrame(f, bridgeOpts);
         opts.renderer.enqueue(vf);
         videoFramesDecoded++;
       } catch (err) {
@@ -33089,11 +34013,15 @@ var AvbridgeVideoElement = class extends HTMLElementCtor {
   constructor() {
     super();
     const root = this.attachShadow({ mode: "open" });
+    const stage = document.createElement("div");
+    stage.setAttribute("part", "stage");
+    stage.style.cssText = "position:relative;width:100%;height:100%;display:block;";
+    root.appendChild(stage);
     this._videoEl = document.createElement("video");
     this._videoEl.setAttribute("part", "video");
     this._videoEl.style.cssText = "width:100%;height:100%;display:block;background:#000;";
     this._videoEl.playsInline = true;
-    root.appendChild(this._videoEl);
+    stage.appendChild(this._videoEl);
     this._videoEl.addEventListener("progress", () => {
       if (this._destroyed) return;
       this._dispatch("progress", { buffered: this._videoEl.buffered });