@gyeonghokim/fisheye.js 0.0.0 → 1.0.1

package/dist/index.js

@@ -1,122 +1,92 @@
-// src/fisheye.ts
-import tgpu from "typegpu";
-import * as d from "typegpu/data";
-import * as std from "typegpu/std";
-var FisheyeUniforms = d.struct({
-  k1: d.f32,
-  k2: d.f32,
-  k3: d.f32,
-  k4: d.f32,
-  fov: d.f32,
-  centerX: d.f32,
-  centerY: d.f32,
-  zoom: d.f32,
-  width: d.f32,
-  height: d.f32,
-  padding: d.f32
-});
-var fisheyeLayout = tgpu.bindGroupLayout({
-  inputTexture: { texture: d.texture2d() },
-  outputTexture: { storageTexture: d.textureStorage2d("rgba8unorm") },
-  uniforms: { uniform: FisheyeUniforms }
-});
-var Fisheye = class _Fisheye {
+import M from "typegpu";
+import * as i from "typegpu/data";
+import * as b from "typegpu/std";
+const D = (globalThis.__TYPEGPU_AUTONAME__ ?? ((s) => s))(i.struct({
+  k1: i.f32,
+  k2: i.f32,
+  k3: i.f32,
+  k4: i.f32,
+  fov: i.f32,
+  centerX: i.f32,
+  centerY: i.f32,
+  zoom: i.f32,
+  width: i.f32,
+  height: i.f32,
+  inputWidth: i.f32,
+  inputHeight: i.f32,
+  padding: i.f32
+}), "FisheyeUniforms"), P = (globalThis.__TYPEGPU_AUTONAME__ ?? ((s) => s))(M.bindGroupLayout({
+  inputTexture: { texture: i.texture2d() },
+  outputTexture: { storageTexture: i.textureStorage2d("rgba8unorm") },
+  uniforms: { uniform: D }
+}), "fisheyeLayout");
+class X {
   config;
   root = null;
   uniformBuffer = null;
   inputTexture = null;
   outputTexture = null;
-  inputView = null;
-  outputView = null;
   bindGroup = null;
   dewarpPipeline = null;
   readbackBuffers = null;
   readbackIndex = 0;
-  readbackHasData = [false, false];
+  readbackHasData = [!1, !1];
   readbackBytesPerRow = 0;
   readbackActualBytesPerRow = 0;
   pixelBuffer = null;
   inputTextureSize = [0, 0];
   outputTextureSize = [0, 0];
-  static createInputView(texture) {
-    return texture.createView(d.texture2d());
-  }
-  static createOutputView(texture) {
-    return texture.createView(d.textureStorage2d("rgba8unorm"));
-  }
-  constructor(options = {}) {
-    this.config = this.applyDefaults(options);
+  uniformInputWidth = 0;
+  uniformInputHeight = 0;
+  constructor(t = {}) {
+    this.config = this.applyDefaults(t);
   }
   /**
    * Apply default values to options
    */
-  applyDefaults(options) {
-    const k1 = options.k1 ?? 0;
+  applyDefaults(t) {
     return {
-      k1,
-      k2: options.k2 ?? 0,
-      k3: options.k3 ?? 0,
-      k4: options.k4 ?? 0,
-      width: options.width ?? 300,
-      height: options.height ?? 150,
-      fov: options.fov ?? 180,
-      centerX: options.centerX ?? 0,
-      centerY: options.centerY ?? 0,
-      zoom: options.zoom ?? 1
+      k1: t.k1 ?? 0,
+      k2: t.k2 ?? 0,
+      k3: t.k3 ?? 0,
+      k4: t.k4 ?? 0,
+      width: t.width ?? 300,
+      height: t.height ?? 150,
+      fov: t.fov ?? 180,
+      centerX: t.centerX ?? 0,
+      centerY: t.centerY ?? 0,
+      zoom: t.zoom ?? 1
     };
   }
   /**
    * Initialize TypeGPU root and resources
    */
   async initialize() {
-    if (this.root) {
-      return;
-    }
-    this.root = await tgpu.init();
-    this.uniformBuffer = this.root.createBuffer(FisheyeUniforms, this.getUniformData()).$usage("uniform");
-    this.dewarpPipeline = this.root["~unstable"].createGuardedComputePipeline(
-      (x, y) => {
+    this.root || (this.root = await M.init(), this.uniformBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(this.root.createBuffer(D, this.getUniformData()).$usage("uniform"), "uniformBuffer"), this.dewarpPipeline = (globalThis.__TYPEGPU_AUTONAME__ ?? ((t) => t))(this.root["~unstable"].createGuardedComputePipeline(
+      ((t) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set(t.f = ((o, r) => {
         "use gpu";
-        const inputTex = fisheyeLayout.$.inputTexture;
-        const outputTex = fisheyeLayout.$.outputTexture;
-        const params = fisheyeLayout.$.uniforms;
-        const inputDims = std.textureDimensions(inputTex);
-        const outputDims = std.textureDimensions(outputTex);
-        const coord = d.vec2i(x, y);
-        if (x >= outputDims.x || y >= outputDims.y) {
+        const e = P.$.uniforms, n = e.width, c = e.height, a = e.inputWidth, p = e.inputHeight, l = i.vec2i(o, r);
+        if (i.f32(o) >= n || i.f32(r) >= c)
           return;
-        }
-        const uv = d.vec2f(
-          (d.f32(coord.x) / d.f32(outputDims.x) - 0.5) * 2,
-          (d.f32(coord.y) / d.f32(outputDims.y) - 0.5) * 2
-        );
-        const centered = uv.sub(d.vec2f(params.centerX, params.centerY));
-        const r = std.length(centered);
-        const theta = std.atan(r);
-        const theta2 = theta * theta;
-        const theta4 = theta2 * theta2;
-        const theta6 = theta4 * theta2;
-        const theta8 = theta4 * theta4;
-        const thetaDistorted = theta * (1 + params.k1 * theta2 + params.k2 * theta4 + params.k3 * theta6 + params.k4 * theta8);
-        const rDistorted = std.tan(thetaDistorted);
-        const rScaled = rDistorted / params.zoom;
-        let distortedUv = centered;
-        if (r > 1e-4) {
-          distortedUv = centered.mul(rScaled / r);
-        }
-        const finalUv = distortedUv.add(d.vec2f(params.centerX, params.centerY)).mul(0.5).add(0.5);
-        if (finalUv.x >= 0 && finalUv.x <= 1 && finalUv.y >= 0 && finalUv.y <= 1) {
-          const sampleCoord = d.vec2i(
-            d.i32(finalUv.x * d.f32(inputDims.x)),
-            d.i32(finalUv.y * d.f32(inputDims.y))
-          );
-          const color = std.textureLoad(inputTex, sampleCoord, 0);
-          std.textureStore(outputTex, coord, color);
-        } else {
-          std.textureStore(outputTex, coord, d.vec4f(0, 0, 0, 1));
-        }
-      }
-    );
+        const x = i.vec2f(
+          (i.f32(l.x) / n - 0.5) * 2,
+          (i.f32(l.y) / c - 0.5) * 2
+        ), m = e.centerX, g = e.centerY, u = x.sub(i.vec2f(m, g)), f = b.length(u), k = Math.SQRT2, U = b.min(e.fov * 0.017453293, 3.1), A = b.tan(U * 0.5) / k, H = b.min(A, 1), G = f * H, d = b.atan(G), h = d * d, y = h * h, T = y * h, R = y * y, B = d * (1 + e.k1 * h + e.k2 * y + e.k3 * T + e.k4 * R) / e.zoom;
+        let v = i.vec2f(u.x, u.y);
+        f > 1e-4 && (v = i.vec2f(u.x * (B / f), u.y * (B / f)));
+        const w = v.add(i.vec2f(m, g)).mul(0.5).add(0.5);
+        if (w.x >= 0 && w.x <= 1 && w.y >= 0 && w.y <= 1) {
+          const I = i.vec2i(i.i32(w.x * a), i.i32(w.y * p)), z = b.textureLoad(P.$.inputTexture, I, 0);
+          b.textureStore(P.$.outputTexture, l, z);
+        } else
+          b.textureStore(P.$.outputTexture, l, i.vec4f(0, 0, 0, 1));
+      }), {
+        v: 1,
+        name: void 0,
+        ast: { params: [{ type: "i", name: "x" }, { type: "i", name: "y" }], body: [0, [[13, "p", [7, [7, "fisheyeLayout", "$"], "uniforms"]], [13, "outputW", [7, "p", "width"]], [13, "outputH", [7, "p", "height"]], [13, "inputW", [7, "p", "inputWidth"]], [13, "inputH", [7, "p", "inputHeight"]], [13, "coord", [6, [7, "d", "vec2i"], ["x", "y"]]], [11, [3, [1, [6, [7, "d", "f32"], ["x"]], ">=", "outputW"], "||", [1, [6, [7, "d", "f32"], ["y"]], ">=", "outputH"]], [0, [[10]]]], [13, "uv", [6, [7, "d", "vec2f"], [[1, [1, [1, [6, [7, "d", "f32"], [[7, "coord", "x"]]], "/", "outputW"], "-", [5, "0.5"]], "*", [5, "2"]], [1, [1, [1, [6, [7, "d", "f32"], [[7, "coord", "y"]]], "/", "outputH"], "-", [5, "0.5"]], "*", [5, "2"]]]]], [13, "centerX", [7, "p", "centerX"]], [13, "centerY", [7, "p", "centerY"]], [13, "centered", [6, [7, "uv", "sub"], [[6, [7, "d", "vec2f"], ["centerX", "centerY"]]]]], [13, "r", [6, [7, "std", "length"], ["centered"]]], [13, "cornerNorm", [7, "Math", "SQRT2"]], [13, "fovRad", [6, [7, "std", "min"], [[1, [7, "p", "fov"], "*", [5, "0.017453293"]], [5, "3.1"]]]], [13, "scaleRaw", [1, [6, [7, "std", "tan"], [[1, "fovRad", "*", [5, "0.5"]]]], "/", "cornerNorm"]], [13, "scale", [6, [7, "std", "min"], ["scaleRaw", [5, "1"]]]], [13, "rScaledForFov", [1, "r", "*", "scale"]], [13, "theta", [6, [7, "std", "atan"], ["rScaledForFov"]]], [13, "theta2", [1, "theta", "*", "theta"]], [13, "theta4", [1, "theta2", "*", "theta2"]], [13, "theta6", [1, "theta4", "*", "theta2"]], [13, "theta8", [1, "theta4", "*", "theta4"]], [13, "thetaDistorted", [1, "theta", "*", [1, [1, [1, [1, [5, "1"], "+", [1, [7, "p", "k1"], "*", "theta2"]], "+", [1, [7, "p", "k2"], "*", "theta4"]], "+", [1, [7, "p", "k3"], "*", "theta6"]], "+", [1, [7, "p", "k4"], "*", "theta8"]]]], [13, "rDistorted", "thetaDistorted"], [13, "rScaled", [1, "rDistorted", "/", [7, "p", "zoom"]]], [12, "distortedUv", [6, [7, "d", "vec2f"], [[7, "centered", "x"], [7, "centered", "y"]]]], [11, [1, "r", ">", [5, "0.0001"]], [0, [[2, "distortedUv", "=", [6, [7, "d", "vec2f"], [[1, [7, "centered", "x"], "*", [1, "rScaled", "/", "r"]], [1, [7, "centered", "y"], "*", [1, "rScaled", "/", "r"]]]]]]]], [13, "finalUv", [6, [7, [6, [7, [6, [7, "distortedUv", "add"], [[6, [7, "d", "vec2f"], ["centerX", "centerY"]]]], "mul"], [[5, "0.5"]]], "add"], [[5, "0.5"]]]], [11, [3, [3, [3, [1, [7, "finalUv", "x"], ">=", [5, "0"]], "&&", [1, [7, "finalUv", "x"], "<=", [5, "1"]]], "&&", [1, [7, "finalUv", "y"], ">=", [5, "0"]]], "&&", [1, [7, "finalUv", "y"], "<=", [5, "1"]]], [0, [[13, "sampleCoord", [6, [7, "d", "vec2i"], [[6, [7, "d", "i32"], [[1, [7, "finalUv", "x"], "*", "inputW"]]], [6, [7, "d", "i32"], [[1, [7, "finalUv", "y"], "*", "inputH"]]]]]], [13, "color", [6, [7, "std", "textureLoad"], [[7, [7, "fisheyeLayout", "$"], "inputTexture"], "sampleCoord", [5, "0"]]]], [6, [7, "std", "textureStore"], [[7, [7, "fisheyeLayout", "$"], "outputTexture"], "coord", "color"]]]], [0, [[6, [7, "std", "textureStore"], [[7, [7, "fisheyeLayout", "$"], "outputTexture"], "coord", [6, [7, "d", "vec4f"], [[5, "0"], [5, "0"], [5, "0"], [5, "1"]]]]]]]]]], externalNames: ["fisheyeLayout", "d", "std", "Math"] },
+        externals: () => ({ fisheyeLayout: P, d: i, std: b, Math })
+      }) && t.f)({})
+    ), "dewarpPipeline"));
   }
   /**
    * Get uniform data from current configuration
@@ -133,6 +103,8 @@ var Fisheye = class _Fisheye {
       zoom: this.config.zoom,
       width: this.config.width,
       height: this.config.height,
+      inputWidth: this.uniformInputWidth,
+      inputHeight: this.uniformInputHeight,
       padding: 0
     };
   }
@@ -140,86 +112,66 @@ var Fisheye = class _Fisheye {
    * Update uniform buffer with current configuration
    */
   updateUniforms() {
-    if (!this.uniformBuffer) {
-      return;
-    }
-    this.uniformBuffer.write(this.getUniformData());
+    this.uniformBuffer && this.uniformBuffer.write(this.getUniformData());
   }
-  async readbackToVideoFrame(device, root, outputTexture, timestamp) {
-    const readbackBuffers = this.readbackBuffers;
-    if (!readbackBuffers) {
+  async readbackToVideoFrame(t, o, r) {
+    const e = this.readbackBuffers;
+    if (!e)
       throw new Error("Readback buffer not initialized");
-    }
-    const outputGpuTexture = root.unwrap(outputTexture);
-    const commandEncoder = device.createCommandEncoder();
-    const writeIndex = this.readbackIndex;
-    const readIndex = 1 - writeIndex;
-    const writeBuffer = readbackBuffers[writeIndex];
-    const readBuffer = readbackBuffers[readIndex];
-    if (!writeBuffer || !readBuffer) {
+    const n = this.readbackIndex, c = 1 - n, a = e[n], p = e[c];
+    if (!a || !p)
       throw new Error("Readback buffer not initialized");
-    }
-    commandEncoder.copyTextureToBuffer(
-      { texture: outputGpuTexture },
-      { buffer: writeBuffer, bytesPerRow: this.readbackBytesPerRow },
+    const l = t.createCommandEncoder();
+    l.copyTextureToBuffer(
+      { texture: o },
+      { buffer: a, bytesPerRow: this.readbackBytesPerRow },
       [this.config.width, this.config.height]
-    );
-    device.queue.submit([commandEncoder.finish()]);
-    this.readbackHasData[writeIndex] = true;
-    this.readbackIndex = readIndex;
-    const bufferToRead = this.readbackHasData[readIndex] ? readBuffer : writeBuffer;
-    await bufferToRead.mapAsync(GPUMapMode.READ);
-    const mappedData = bufferToRead.getMappedRange();
-    const pixelData = this.pixelBuffer ?? new Uint8Array(this.config.width * this.config.height * 4);
-    const srcView = new Uint8Array(mappedData);
-    for (let row = 0; row < this.config.height; row++) {
-      const srcOffset = row * this.readbackBytesPerRow;
-      const dstOffset = row * this.readbackActualBytesPerRow;
-      pixelData.set(
-        srcView.subarray(srcOffset, srcOffset + this.readbackActualBytesPerRow),
-        dstOffset
+    ), t.queue.submit([l.finish()]), await t.queue.onSubmittedWorkDone(), this.readbackHasData[n] = !0, this.readbackIndex = c;
+    const x = this.readbackHasData[c] ? p : a;
+    await x.mapAsync(GPUMapMode.READ);
+    const m = x.getMappedRange(), g = this.pixelBuffer ?? new Uint8Array(this.config.width * this.config.height * 4), u = new Uint8Array(m);
+    for (let f = 0; f < this.config.height; f++) {
+      const k = f * this.readbackBytesPerRow, U = f * this.readbackActualBytesPerRow;
+      g.set(
+        u.subarray(k, k + this.readbackActualBytesPerRow),
+        U
       );
     }
-    bufferToRead.unmap();
-    return new VideoFrame(pixelData, {
+    return x.unmap(), new VideoFrame(g, {
       format: "RGBA",
       codedWidth: this.config.width,
       codedHeight: this.config.height,
-      timestamp
+      timestamp: r
     });
   }
   /**
-   * Create input texture with proper typing
+   * Create input texture (TypeGPU; per official docs: sampled + render for .write(image/VideoFrame)).
    */
-  createInputTexture(root, width, height) {
-    const size = [width, height];
-    const format = "rgba8unorm";
-    return root["~unstable"].createTexture({ size, format }).$usage("sampled");
+  createInputTexture(t, o, r) {
+    const e = [o, r];
+    return t["~unstable"].createTexture({ size: e, format: "rgba8unorm" }).$usage("sampled", "render");
   }
   /**
-   * Create output texture with proper typing (storage only, no render needed for GPGPU)
+   * Create output storage texture (TypeGPU; type-safe with layout.$)
    */
-  createOutputTexture(root, width, height) {
-    const size = [width, height];
-    const format = "rgba8unorm";
-    return root["~unstable"].createTexture({ size, format }).$usage("storage");
+  createOutputTexture(t, o, r) {
+    const e = [o, r];
+    return t["~unstable"].createTexture({ size: e, format: "rgba8unorm" }).$usage("storage");
   }
   /**
    * Calculate bytes per row with proper alignment (256-byte alignment for WebGPU)
    */
-  calculateBytesPerRow(width) {
-    const bytesPerPixel = 4;
-    const unalignedBytesPerRow = width * bytesPerPixel;
-    return Math.ceil(unalignedBytesPerRow / 256) * 256;
+  calculateBytesPerRow(t) {
+    const r = t * 4;
+    return Math.ceil(r / 256) * 256;
   }
   /**
    * Create or recreate readback buffer for GPU to CPU data transfer
    */
-  createReadbackBuffer(device, width, height) {
-    const bytesPerRow = this.calculateBytesPerRow(width);
-    const bufferSize = bytesPerRow * height;
-    return device.createBuffer({
-      size: bufferSize,
+  createReadbackBuffer(t, o, r) {
+    const n = this.calculateBytesPerRow(o) * r;
+    return t.createBuffer({
+      size: n,
       usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
     });
   }
@@ -229,231 +181,114 @@ var Fisheye = class _Fisheye {
    * @param frame - Input VideoFrame with fisheye distortion
    * @returns Dewarped VideoFrame
    */
-  async dewarp(frame) {
-    await this.initialize();
-    if (!this.root || !this.uniformBuffer) {
+  async dewarp(t) {
+    if (await this.initialize(), !this.root || !this.uniformBuffer)
       throw new Error("GPU resources not initialized");
-    }
-    const root = this.root;
-    const device = root.device;
-    let bindGroupDirty = false;
-    if (!this.inputTexture || this.inputTextureSize[0] !== frame.displayWidth || this.inputTextureSize[1] !== frame.displayHeight) {
-      this.inputTexture?.destroy();
-      this.inputTexture = this.createInputTexture(root, frame.displayWidth, frame.displayHeight);
-      this.inputTextureSize = [frame.displayWidth, frame.displayHeight];
-      this.inputView = _Fisheye.createInputView(this.inputTexture);
-      bindGroupDirty = true;
-    }
-    if (!this.outputTexture || this.outputTextureSize[0] !== this.config.width || this.outputTextureSize[1] !== this.config.height) {
-      this.outputTexture?.destroy();
-      this.readbackBuffers?.[0]?.destroy();
-      this.readbackBuffers?.[1]?.destroy();
-      this.outputTexture = this.createOutputTexture(root, this.config.width, this.config.height);
-      this.outputView = _Fisheye.createOutputView(this.outputTexture);
-      this.readbackBytesPerRow = this.calculateBytesPerRow(this.config.width);
-      this.readbackActualBytesPerRow = this.config.width * 4;
-      this.pixelBuffer = new Uint8Array(this.config.width * this.config.height * 4);
-      this.readbackBuffers = [
-        this.createReadbackBuffer(device, this.config.width, this.config.height),
-        this.createReadbackBuffer(device, this.config.width, this.config.height)
-      ];
-      this.readbackIndex = 0;
-      this.readbackHasData = [false, false];
-      this.outputTextureSize = [this.config.width, this.config.height];
-      bindGroupDirty = true;
-    }
-    const inputTexture = this.inputTexture;
-    const outputTexture = this.outputTexture;
-    inputTexture.write(frame);
-    if (bindGroupDirty || !this.bindGroup) {
-      this.bindGroup = root.createBindGroup(fisheyeLayout, {
-        inputTexture: this.inputView ?? _Fisheye.createInputView(inputTexture),
-        outputTexture: this.outputView ?? _Fisheye.createOutputView(outputTexture),
-        uniforms: this.uniformBuffer
-      });
-    }
-    const bindGroup = this.bindGroup;
-    const dewarpPipeline = this.dewarpPipeline;
-    if (!dewarpPipeline) {
-      throw new Error("Compute pipeline not initialized");
-    }
-    dewarpPipeline.with(bindGroup).dispatchThreads(this.config.width, this.config.height);
-    return this.readbackToVideoFrame(device, root, outputTexture, frame.timestamp);
+    const o = this.root, r = o.device;
+    (!this.inputTexture || this.inputTextureSize[0] !== t.displayWidth || this.inputTextureSize[1] !== t.displayHeight) && (this.inputTexture?.destroy(), this.inputTexture = this.createInputTexture(o, t.displayWidth, t.displayHeight), this.inputTextureSize = [t.displayWidth, t.displayHeight], this.bindGroup = null), (!this.outputTexture || this.outputTextureSize[0] !== this.config.width || this.outputTextureSize[1] !== this.config.height) && (this.outputTexture?.destroy(), this.readbackBuffers?.[0]?.destroy(), this.readbackBuffers?.[1]?.destroy(), this.outputTexture = this.createOutputTexture(o, this.config.width, this.config.height), this.readbackBytesPerRow = this.calculateBytesPerRow(this.config.width), this.readbackActualBytesPerRow = this.config.width * 4, this.pixelBuffer = new Uint8Array(this.config.width * this.config.height * 4), this.readbackBuffers = [
+      this.createReadbackBuffer(r, this.config.width, this.config.height),
+      this.createReadbackBuffer(r, this.config.width, this.config.height)
+    ], this.readbackIndex = 0, this.readbackHasData = [!1, !1], this.outputTextureSize = [this.config.width, this.config.height], this.bindGroup = null);
+    const e = this.inputTexture, n = this.outputTexture;
+    if (!e || !n) throw new Error("Textures not initialized");
+    e.write(t), this.uniformInputWidth = t.displayWidth, this.uniformInputHeight = t.displayHeight, this.updateUniforms(), this.bindGroup || (this.bindGroup = o.createBindGroup(P, {
+      inputTexture: e,
+      outputTexture: n,
+      uniforms: this.uniformBuffer
+    }));
+    const c = this.bindGroup, a = this.dewarpPipeline;
+    if (!a || !n)
+      throw new Error("Compute pipeline or output texture not initialized");
+    a.with(c).dispatchThreads(this.config.width, this.config.height);
+    const p = o.unwrap(n);
+    return this.readbackToVideoFrame(r, p, t.timestamp);
   }
   /**
    * Update configuration
    */
-  updateConfig(options) {
-    this.config = this.applyDefaults({ ...this.config, ...options });
-    this.updateUniforms();
-    if (options.width || options.height) {
-      this.outputTexture?.destroy();
-      this.readbackBuffers?.[0]?.destroy();
-      this.readbackBuffers?.[1]?.destroy();
-      this.outputTexture = null;
-      this.readbackBuffers = null;
-      this.readbackIndex = 0;
-      this.readbackHasData = [false, false];
-      this.outputTextureSize = [0, 0];
-      this.outputView = null;
-      this.bindGroup = null;
-      this.readbackBytesPerRow = 0;
-      this.readbackActualBytesPerRow = 0;
-      this.pixelBuffer = null;
-    }
+  updateConfig(t) {
+    this.config = this.applyDefaults({ ...this.config, ...t }), this.updateUniforms(), (t.width || t.height) && (this.outputTexture?.destroy(), this.readbackBuffers?.[0]?.destroy(), this.readbackBuffers?.[1]?.destroy(), this.outputTexture = null, this.readbackBuffers = null, this.readbackIndex = 0, this.readbackHasData = [!1, !1], this.outputTextureSize = [0, 0], this.readbackBytesPerRow = 0, this.readbackActualBytesPerRow = 0, this.pixelBuffer = null);
   }
   /**
    * Clean up GPU resources
    */
   destroy() {
-    this.inputTexture?.destroy();
-    this.outputTexture?.destroy();
-    this.readbackBuffers?.[0]?.destroy();
-    this.readbackBuffers?.[1]?.destroy();
-    this.root?.destroy();
-    this.inputTexture = null;
-    this.outputTexture = null;
-    this.readbackBuffers = null;
-    this.readbackIndex = 0;
-    this.readbackHasData = [false, false];
-    this.uniformBuffer = null;
-    this.root = null;
-    this.inputView = null;
-    this.outputView = null;
-    this.bindGroup = null;
-    this.dewarpPipeline = null;
-    this.readbackBytesPerRow = 0;
-    this.readbackActualBytesPerRow = 0;
-    this.pixelBuffer = null;
-    this.inputTextureSize = [0, 0];
-    this.outputTextureSize = [0, 0];
+    this.inputTexture?.destroy(), this.outputTexture?.destroy(), this.readbackBuffers?.[0]?.destroy(), this.readbackBuffers?.[1]?.destroy(), this.root?.destroy(), this.inputTexture = null, this.outputTexture = null, this.readbackBuffers = null, this.readbackIndex = 0, this.readbackHasData = [!1, !1], this.uniformBuffer = null, this.root = null, this.bindGroup = null, this.dewarpPipeline = null, this.readbackBytesPerRow = 0, this.readbackActualBytesPerRow = 0, this.pixelBuffer = null, this.inputTextureSize = [0, 0], this.outputTextureSize = [0, 0];
   }
-};
-
-// src/utils.ts
-function createVideoFrameFromYUV(data, options) {
+}
+function O(s, t) {
   const {
-    format,
-    width,
-    height,
-    timestamp,
-    duration,
-    displayWidth,
-    displayHeight,
-    colorSpace,
-    transfer
-  } = options;
-  if (width <= 0 || height <= 0) {
+    format: o,
+    width: r,
+    height: e,
+    timestamp: n,
+    duration: c,
+    displayWidth: a,
+    displayHeight: p,
+    colorSpace: l,
+    transfer: x
+  } = t;
+  if (r <= 0 || e <= 0)
     throw new Error("Width and height must be positive integers");
-  }
-  const expectedSize = calculateYUVDataSize(format, width, height);
-  const actualSize = data instanceof ArrayBuffer ? data.byteLength : data.byteLength;
-  if (actualSize < expectedSize) {
+  const m = $(o, r, e), g = (s instanceof ArrayBuffer, s.byteLength);
+  if (g < m)
     throw new Error(
-      `Buffer too small for ${format} format. Expected at least ${expectedSize} bytes, got ${actualSize} bytes`
+      `Buffer too small for ${o} format. Expected at least ${m} bytes, got ${g} bytes`
     );
-  }
-  const init = {
-    format,
-    codedWidth: width,
-    codedHeight: height,
-    timestamp
+  const u = {
+    format: o,
+    codedWidth: r,
+    codedHeight: e,
+    timestamp: n
   };
-  if (duration !== void 0) {
-    init.duration = duration;
+  if (c !== void 0 && (u.duration = c), a !== void 0 && (u.displayWidth = a), p !== void 0 && (u.displayHeight = p), l !== void 0 && (u.colorSpace = l), x) {
+    const f = s instanceof ArrayBuffer ? s : s.buffer;
+    u.transfer = [f];
   }
-  if (displayWidth !== void 0) {
-    init.displayWidth = displayWidth;
-  }
-  if (displayHeight !== void 0) {
-    init.displayHeight = displayHeight;
-  }
-  if (colorSpace !== void 0) {
-    init.colorSpace = colorSpace;
-  }
-  if (transfer) {
-    const buffer = data instanceof ArrayBuffer ? data : data.buffer;
-    init.transfer = [buffer];
-  }
-  return new VideoFrame(data, init);
+  return new VideoFrame(s, u);
 }
-function convertRGBAtoYUV(rgbaData, width, height, format = "I420") {
-  if (format !== "I420") {
-    throw new Error(`Unsupported format: ${format}. Only I420 is currently supported.`);
-  }
-  const lumaSize = width * height;
-  const chromaSize = width / 2 * (height / 2);
-  const yuvSize = lumaSize + chromaSize * 2;
-  const yuvData = new Uint8Array(yuvSize);
-  const Y_R = 0.299;
-  const Y_G = 0.587;
-  const Y_B = 0.114;
-  const U_R = -0.169;
-  const U_G = -0.331;
-  const U_B = 0.5;
-  const V_R = 0.5;
-  const V_G = -0.419;
-  const V_B = -0.081;
-  const yPlane = yuvData.subarray(0, lumaSize);
-  const uPlane = yuvData.subarray(lumaSize, lumaSize + chromaSize);
-  const vPlane = yuvData.subarray(lumaSize + chromaSize, yuvSize);
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      const rgbaIdx = (y * width + x) * 4;
-      const r = rgbaData[rgbaIdx];
-      const g = rgbaData[rgbaIdx + 1];
-      const b = rgbaData[rgbaIdx + 2];
-      const yVal = Y_R * r + Y_G * g + Y_B * b;
-      yPlane[y * width + x] = Math.round(Math.max(0, Math.min(255, yVal)));
+function N(s, t, o, r = "I420") {
+  if (r !== "I420")
+    throw new Error(`Unsupported format: ${r}. Only I420 is currently supported.`);
+  const e = t * o, n = t / 2 * (o / 2), c = e + n * 2, a = new Uint8Array(c), p = 0.299, l = 0.587, x = 0.114, m = -0.169, g = -0.331, u = 0.5, f = 0.5, k = -0.419, U = -0.081, A = a.subarray(0, e), H = a.subarray(e, e + n), G = a.subarray(e + n, c);
+  for (let d = 0; d < o; d++)
+    for (let h = 0; h < t; h++) {
+      const y = (d * t + h) * 4, T = s[y], R = s[y + 1], _ = s[y + 2], S = p * T + l * R + x * _;
+      A[d * t + h] = Math.round(Math.max(0, Math.min(255, S)));
     }
-  }
-  for (let y = 0; y < height / 2; y++) {
-    for (let x = 0; x < width / 2; x++) {
-      let uSum = 0;
-      let vSum = 0;
-      for (let dy = 0; dy < 2; dy++) {
-        for (let dx = 0; dx < 2; dx++) {
-          const srcX = x * 2 + dx;
-          const srcY = y * 2 + dy;
-          const rgbaIdx = (srcY * width + srcX) * 4;
-          const r = rgbaData[rgbaIdx];
-          const g = rgbaData[rgbaIdx + 1];
-          const b = rgbaData[rgbaIdx + 2];
-          const uVal = U_R * r + U_G * g + U_B * b + 128;
-          const vVal = V_R * r + V_G * g + V_B * b + 128;
-          uSum += uVal;
-          vSum += vVal;
+  for (let d = 0; d < o / 2; d++)
+    for (let h = 0; h < t / 2; h++) {
+      let y = 0, T = 0;
+      for (let B = 0; B < 2; B++)
+        for (let v = 0; v < 2; v++) {
+          const w = h * 2 + v, z = ((d * 2 + B) * t + w) * 4, Y = s[z], W = s[z + 1], E = s[z + 2], V = m * Y + g * W + u * E + 128, F = f * Y + k * W + U * E + 128;
+          y += V, T += F;
         }
-      }
-      const uAvg = uSum / 4;
-      const vAvg = vSum / 4;
-      const chromaIdx = y * (width / 2) + x;
-      uPlane[chromaIdx] = Math.round(Math.max(0, Math.min(255, uAvg)));
-      vPlane[chromaIdx] = Math.round(Math.max(0, Math.min(255, vAvg)));
+      const R = y / 4, _ = T / 4, S = d * (t / 2) + h;
+      H[S] = Math.round(Math.max(0, Math.min(255, R))), G[S] = Math.round(Math.max(0, Math.min(255, _)));
     }
-  }
-  return yuvData;
+  return a;
 }
-function calculateYUVDataSize(format, width, height) {
-  const lumaSize = width * height;
-  switch (format) {
+function $(s, t, o) {
+  const r = t * o;
+  switch (s) {
     case "I420":
     case "NV12":
-      return lumaSize + lumaSize / 2;
+      return r + r / 2;
     case "I420A":
-      return lumaSize * 2 + lumaSize / 2;
+      return r * 2 + r / 2;
     case "I422":
-      return lumaSize * 2;
+      return r * 2;
     case "I444":
-      return lumaSize * 3;
+      return r * 3;
     default:
-      throw new Error(`Unsupported YUV format: ${format}`);
+      throw new Error(`Unsupported YUV format: ${s}`);
   }
 }
 export {
-  Fisheye,
-  calculateYUVDataSize,
-  convertRGBAtoYUV,
-  createVideoFrameFromYUV
+  X as Fisheye,
+  $ as calculateYUVDataSize,
+  N as convertRGBAtoYUV,
+  O as createVideoFrameFromYUV
 };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map