@gyeonghokim/fisheye.js 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GyeongHoKim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# fisheye.js
+
+> Modern fisheye dewarping library for the web, using **General Purpose GPU**
+
+fisheye.js is a javascript library for drawing VideoFrame to the canvas with [simple radial lens distortion](<https://en.wikipedia.org/wiki/Distortion_(optics)>) using **GPGPU** WebGPU(WebGL if your browser does not support WebGPU).
+
+## Features
+
+- ESM support: You can just `import { Fisheye } from @gyeonghokim/fisheye.js;` in your WebAPP
+- TypeGPU: WebGPU backend with type-safe shader programing(with [typegpu](https://www.npmjs.com/package/typegpu))
+- GPGPU: we do not use canvas element, read from GPU buffer directly(efficient more than other libraries)
+- WebCodecs API: Modern Video processing with WebCodecs' [VideoFrame](https://developer.mozilla.org/en-US/docs/Web/API/VideoFrame)
+- Installation from modern package managers(npm)
+
+## Getting Started(Typescript Example)
+
+```bash
+npm install @gyeonghokim/fisheye.js
+# optional
+npm install --save-dev @webgpu/types
+```
+
+if you installed `@webgpu/types`,
+
+```json
+{
+  "compilerOptions": {
+    "types": ["@webgpu/types"]
+  }
+}
+```
+
+> Why should I install webgpu types?
+> This library does not render your binary, it just dewarp the VideoFrame.
+> You should make **your own YUV renderer**, or you can install `@gyeonghokim/yuv-player`.
+
+in your code,
+
+```ts
+import { Fisheye } from "@gyeonghokim/fisheye.js";
+
+const dewarper = new Fisheye({
+  k1: 0.5,
+  k2: 0.0,
+  k3: 0.0,
+  k4: 0.0,
+  width: 1920,
+  height: 1080,
+  fov: 180, // Field of view in degrees
+  centerX: 0, // X offset of lens center (-1.0 to 1.0)
+  centerY: 0, // Y offset of lens center (-1.0 to 1.0)
+  zoom: 1.0, // Zoom factor
+});
+
+const renderLoop = (timestamp: DOMHighResTimestamp) => {
+  // your render logic
+  const dewarpedVideoFrame: VideoFrame = await dewarper.dewarp(yourVideoFrame);
+  yourYUVPlayer.draw(dewarpedVideoFrame);
+  requestAnimationFrame(renderLoop);
+};
+```
+
+## API
+
+### `new Fisheye(options?: FisheyeOptions)`
+
+Creates a new Fisheye dewarper instance.
+
+**Options:**
+
+- `k1` (number, optional): Fisheye distortion coefficient k1. Typical range: -1.0 to 1.0. Default: `0.5`.
+- `k2` (number, optional): Fisheye distortion coefficient k2. Default: `0`.
+- `k3` (number, optional): Fisheye distortion coefficient k3. Default: `0`.
+- `k4` (number, optional): Fisheye distortion coefficient k4. Default: `0`.
+- `width` (number, optional): Output canvas width. Default: `640`
+- `height` (number, optional): Output canvas height. Default: `480`
+- `fov` (number, optional): Field of view in degrees. Default: `180`
+- `centerX` (number, optional): X offset of the lens center (normalized, -1.0 to 1.0). Default: `0`
+- `centerY` (number, optional): Y offset of the lens center (normalized, -1.0 to 1.0). Default: `0`
+- `zoom` (number, optional): Zoom factor. Default: `1.0`
+
+**Fisheye model (OpenCV):**
+We follow the OpenCV fisheye camera model described here:
+https://docs.opencv.org/4.x/db/d58/group__calib3d__fisheye.html
+
+```
+theta = atan(r)
+theta_d = theta * (1 + k1*theta^2 + k2*theta^4 + k3*theta^6 + k4*theta^8)
+r_d = tan(theta_d)
+```
+
+### `dewarp(frame: VideoFrame): Promise<VideoFrame>`
+
+Dewarps a VideoFrame with fisheye distortion.
+
+**Parameters:**
+
+- `frame`: Input VideoFrame with fisheye distortion
+
+**Returns:** Promise that resolves to a dewarped VideoFrame
+
+### `updateConfig(options: Partial<FisheyeOptions>): void`
+
+Updates the dewarper configuration. You can update any subset of the original options.
+
+### `destroy(): void`
+
+Cleans up GPU resources. Call this when you're done using the dewarper.
+
+## Working with YUV Binary Data
+
+If you receive raw YUV binary data from a camera or server, you can use the `createVideoFrameFromYUV` utility to create a VideoFrame:
+
+```ts
+import { Fisheye, createVideoFrameFromYUV } from "@gyeonghokim/fisheye.js";
+
+const dewarper = new Fisheye({ distortion: 0.5, width: 1920, height: 1080 });
+
+// Example: Receiving NV12 data from a server
+const response = await fetch("/api/camera/frame");
+const yuvBuffer = await response.arrayBuffer();
+
+const frame = createVideoFrameFromYUV(new Uint8Array(yuvBuffer), {
+  format: "NV12",  // YUV format
+  width: 1920,
+  height: 1080,
+  timestamp: performance.now() * 1000,  // microseconds
+});
+
+const dewarpedFrame = await dewarper.dewarp(frame);
+frame.close();  // Don't forget to close the original frame
+```
+
+### `createVideoFrameFromYUV(data, options)`
+
+Creates a VideoFrame from YUV binary data.
+
+**Parameters:**
+
+- `data`: YUV binary data (`ArrayBuffer`, `TypedArray`, or `DataView`)
+- `options`: Configuration object
+  - `format` (required): YUV pixel format
+  - `width` (required): Frame width in pixels
+  - `height` (required): Frame height in pixels
+  - `timestamp` (required): Timestamp in microseconds
+  - `duration` (optional): Duration in microseconds
+  - `displayWidth` (optional): Display width (defaults to width)
+  - `displayHeight` (optional): Display height (defaults to height)
+  - `colorSpace` (optional): Color space configuration
+  - `transfer` (optional): If `true`, transfers buffer ownership for zero-copy performance
+
+**Supported YUV Formats:**
+
+| Format | Description | Data Size |
+|--------|-------------|-----------|
+| `I420` | YUV 4:2:0 planar (Y, U, V planes) | width × height × 1.5 |
+| `NV12` | YUV 4:2:0 semi-planar (Y plane, interleaved UV) | width × height × 1.5 |
+| `I420A` | YUV 4:2:0 planar with alpha | width × height × 2.5 |
+| `I422` | YUV 4:2:2 planar | width × height × 2 |
+| `I444` | YUV 4:4:4 planar | width × height × 3 |
+
+### `calculateYUVDataSize(format, width, height)`
+
+Calculates the expected byte size for YUV data.
+
+```ts
+import { calculateYUVDataSize } from "@gyeonghokim/fisheye.js";
+
+const size = calculateYUVDataSize("NV12", 1920, 1080);  // 3110400 bytes
+```
+
+## Development
+
+This project uses:
+
+- **Biome** for linting and formatting
+- **Husky** for git hooks
+- **Commitlint** for conventional commit messages
+- **Semantic Release** for automated versioning and publishing
+- **TypeScript** for type safety
+- **WebGPU** for GPU-accelerated processing
+
+### Scripts
+
+```bash
+npm run build      # Build the library
+npm run dev        # Build in watch mode
+npm run lint       # Run linter
+npm run lint:fix   # Fix linting issues
+npm run format     # Format code
+npm run type-check # Check TypeScript types
+```
+
+### Commit Message Format
+
+This project follows the [Conventional Commits](https://www.conventionalcommits.org/) specification:
+
+```
+<type>: <description>
+
+[optional body]
+
+[optional footer]
+```
+
+Types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, `chore`, `revert`
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,266 @@
+/**
+ * Options for configuring the Fisheye dewarper
+ */
+interface FisheyeOptions {
+    /**
+     * Fisheye distortion coefficient k1.
+     */
+    k1?: number;
+    /**
+     * Fisheye distortion coefficient k2.
+     */
+    k2?: number;
+    /**
+     * Fisheye distortion coefficient k3.
+     */
+    k3?: number;
+    /**
+     * Fisheye distortion coefficient k4.
+     */
+    k4?: number;
+    /**
+     * Canvas width for output
+     * @default 300
+     */
+    width?: number;
+    /**
+     * Canvas height for output
+     * @default 150
+     */
+    height?: number;
+    /**
+     * Field of view in degrees
+     * @default 180
+     */
+    fov?: number;
+    /**
+     * X offset of the lens center (normalized, -1.0 to 1.0)
+     * @default 0
+     */
+    centerX?: number;
+    /**
+     * Y offset of the lens center (normalized, -1.0 to 1.0)
+     * @default 0
+     */
+    centerY?: number;
+    /**
+     * Zoom factor
+     * @default 1.0
+     */
+    zoom?: number;
+}
+/**
+ * Internal configuration after applying defaults
+ */
+interface FisheyeConfig extends Required<FisheyeOptions> {
+}
+
+/**
+ * Fisheye dewarper using WebGPU via TypeGPU (Pure GPGPU)
+ *
+ * @example
+ * ```ts
+ * const dewarper = new Fisheye({
+ *   distortion: 0.5,
+ *   width: 1920,
+ *   height: 1080,
+ * });
+ *
+ * const dewarpedFrame = await dewarper.dewarp(videoFrame);
+ * ```
+ */
+declare class Fisheye {
+    private config;
+    private root;
+    private uniformBuffer;
+    private inputTexture;
+    private outputTexture;
+    private inputView;
+    private outputView;
+    private bindGroup;
+    private dewarpPipeline;
+    private readbackBuffers;
+    private readbackIndex;
+    private readbackHasData;
+    private readbackBytesPerRow;
+    private readbackActualBytesPerRow;
+    private pixelBuffer;
+    private inputTextureSize;
+    private outputTextureSize;
+    private static createInputView;
+    private static createOutputView;
+    constructor(options?: FisheyeOptions);
+    /**
+     * Apply default values to options
+     */
+    private applyDefaults;
+    /**
+     * Initialize TypeGPU root and resources
+     */
+    private initialize;
+    /**
+     * Get uniform data from current configuration
+     */
+    private getUniformData;
+    /**
+     * Update uniform buffer with current configuration
+     */
+    private updateUniforms;
+    private readbackToVideoFrame;
+    /**
+     * Create input texture with proper typing
+     */
+    private createInputTexture;
+    /**
+     * Create output texture with proper typing (storage only, no render needed for GPGPU)
+     */
+    private createOutputTexture;
+    /**
+     * Calculate bytes per row with proper alignment (256-byte alignment for WebGPU)
+     */
+    private calculateBytesPerRow;
+    /**
+     * Create or recreate readback buffer for GPU to CPU data transfer
+     */
+    private createReadbackBuffer;
+    /**
+     * Dewarp a VideoFrame
+     *
+     * @param frame - Input VideoFrame with fisheye distortion
+     * @returns Dewarped VideoFrame
+     */
+    dewarp(frame: VideoFrame): Promise<VideoFrame>;
+    /**
+     * Update configuration
+     */
+    updateConfig(options: Partial<FisheyeOptions>): void;
+    /**
+     * Clean up GPU resources
+     */
+    destroy(): void;
+}
+
+/**
+ * Supported YUV pixel formats for VideoFrame creation
+ */
+type YUVFormat = "I420" | "I420A" | "I422" | "I444" | "NV12";
+/**
+ * Options for creating a VideoFrame from YUV data
+ */
+interface CreateVideoFrameOptions {
+    /**
+     * YUV pixel format
+     * - I420: YUV 4:2:0 planar (Y plane, U plane, V plane)
+     * - I420A: YUV 4:2:0 planar with alpha
+     * - I422: YUV 4:2:2 planar
+     * - I444: YUV 4:4:4 planar
+     * - NV12: YUV 4:2:0 semi-planar (Y plane, interleaved UV plane)
+     */
+    format: YUVFormat;
+    /**
+     * Width of the video frame in pixels
+     */
+    width: number;
+    /**
+     * Height of the video frame in pixels
+     */
+    height: number;
+    /**
+     * Timestamp in microseconds
+     */
+    timestamp: number;
+    /**
+     * Duration in microseconds (optional)
+     */
+    duration?: number;
+    /**
+     * Display width (optional, defaults to width)
+     */
+    displayWidth?: number;
+    /**
+     * Display height (optional, defaults to height)
+     */
+    displayHeight?: number;
+    /**
+     * Color space configuration (optional)
+     */
+    colorSpace?: VideoColorSpaceInit;
+    /**
+     * Transfer ownership of the buffer for zero-copy (optional)
+     * If true, the input buffer will be detached after VideoFrame creation
+     */
+    transfer?: boolean;
+}
+/**
+ * Create a VideoFrame from YUV binary data
+ *
+ * @param data - YUV binary data (ArrayBuffer, TypedArray, or DataView)
+ * @param options - Configuration options including format, dimensions, and timestamp
+ * @returns A new VideoFrame object
+ *
+ * @example
+ * ```ts
+ * // Create VideoFrame from I420 (YUV 4:2:0) data
+ * const yuvData = new Uint8Array(width * height * 1.5); // I420 size
+ * const frame = createVideoFrameFromYUV(yuvData, {
+ *   format: "I420",
+ *   width: 1920,
+ *   height: 1080,
+ *   timestamp: 0,
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Create VideoFrame from NV12 data with zero-copy transfer
+ * const nv12Data = new Uint8Array(width * height * 1.5);
+ * const frame = createVideoFrameFromYUV(nv12Data, {
+ *   format: "NV12",
+ *   width: 1920,
+ *   height: 1080,
+ *   timestamp: 0,
+ *   transfer: true, // Transfer buffer ownership for better performance
+ * });
+ * ```
+ */
+declare function createVideoFrameFromYUV(data: BufferSource, options: CreateVideoFrameOptions): VideoFrame;
+/**
+ * Convert RGBA image data to YUV format (I420 by default)
+ *
+ * Uses ITU-R BT.601 color space conversion:
+ * - Y = 0.299*R + 0.587*G + 0.114*B
+ * - U = -0.169*R - 0.331*G + 0.5*B + 128
+ * - V = 0.5*R - 0.419*G - 0.081*B + 128
+ *
+ * For I420 format:
+ * - Y plane: full resolution (width * height)
+ * - U plane: quarter resolution ((width/2) * (height/2))
+ * - V plane: quarter resolution ((width/2) * (height/2))
+ *
+ * @param rgbaData - RGBA pixel data (Uint8ClampedArray from ImageData)
+ * @param width - Image width in pixels
+ * @param height - Image height in pixels
+ * @param format - YUV format to convert to (default: "I420")
+ * @returns YUV data as Uint8Array
+ *
+ * @example
+ * ```ts
+ * const canvas = document.createElement('canvas');
+ * const ctx = canvas.getContext('2d');
+ * ctx.drawImage(image, 0, 0);
+ * const imageData = ctx.getImageData(0, 0, width, height);
+ * const yuvData = convertRGBAtoYUV(imageData.data, width, height);
+ * ```
+ */
+declare function convertRGBAtoYUV(rgbaData: Uint8ClampedArray, width: number, height: number, format?: YUVFormat): Uint8Array;
+/**
+ * Calculate the expected byte size for YUV data based on format and dimensions
+ *
+ * @param format - YUV pixel format
+ * @param width - Frame width in pixels
+ * @param height - Frame height in pixels
+ * @returns Expected byte size
+ */
+declare function calculateYUVDataSize(format: YUVFormat, width: number, height: number): number;
+
+export { type CreateVideoFrameOptions, Fisheye, type FisheyeConfig, type FisheyeOptions, type YUVFormat, calculateYUVDataSize, convertRGBAtoYUV, createVideoFrameFromYUV };

package/dist/index.js

@@ -0,0 +1,459 @@
+// 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 {
+  config;
+  root = null;
+  uniformBuffer = null;
+  inputTexture = null;
+  outputTexture = null;
+  inputView = null;
+  outputView = null;
+  bindGroup = null;
+  dewarpPipeline = null;
+  readbackBuffers = null;
+  readbackIndex = 0;
+  readbackHasData = [false, false];
+  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);
+  }
+  /**
+   * Apply default values to options
+   */
+  applyDefaults(options) {
+    const k1 = options.k1 ?? 0;
+    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
+    };
+  }
+  /**
+   * 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) => {
+        "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) {
+          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));
+        }
+      }
+    );
+  }
+  /**
+   * Get uniform data from current configuration
+   */
+  getUniformData() {
+    return {
+      k1: this.config.k1,
+      k2: this.config.k2,
+      k3: this.config.k3,
+      k4: this.config.k4,
+      fov: this.config.fov,
+      centerX: this.config.centerX,
+      centerY: this.config.centerY,
+      zoom: this.config.zoom,
+      width: this.config.width,
+      height: this.config.height,
+      padding: 0
+    };
+  }
+  /**
+   * Update uniform buffer with current configuration
+   */
+  updateUniforms() {
+    if (!this.uniformBuffer) {
+      return;
+    }
+    this.uniformBuffer.write(this.getUniformData());
+  }
+  async readbackToVideoFrame(device, root, outputTexture, timestamp) {
+    const readbackBuffers = this.readbackBuffers;
+    if (!readbackBuffers) {
+      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) {
+      throw new Error("Readback buffer not initialized");
+    }
+    commandEncoder.copyTextureToBuffer(
+      { texture: outputGpuTexture },
+      { buffer: writeBuffer, 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
+      );
+    }
+    bufferToRead.unmap();
+    return new VideoFrame(pixelData, {
+      format: "RGBA",
+      codedWidth: this.config.width,
+      codedHeight: this.config.height,
+      timestamp
+    });
+  }
+  /**
+   * Create input texture with proper typing
+   */
+  createInputTexture(root, width, height) {
+    const size = [width, height];
+    const format = "rgba8unorm";
+    return root["~unstable"].createTexture({ size, format }).$usage("sampled");
+  }
+  /**
+   * Create output texture with proper typing (storage only, no render needed for GPGPU)
+   */
+  createOutputTexture(root, width, height) {
+    const size = [width, height];
+    const format = "rgba8unorm";
+    return root["~unstable"].createTexture({ size, format }).$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;
+  }
+  /**
+   * 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,
+      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+    });
+  }
+  /**
+   * Dewarp a VideoFrame
+   *
+   * @param frame - Input VideoFrame with fisheye distortion
+   * @returns Dewarped VideoFrame
+   */
+  async dewarp(frame) {
+    await this.initialize();
+    if (!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);
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * 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];
+  }
+};
+
+// src/utils.ts
+function createVideoFrameFromYUV(data, options) {
+  const {
+    format,
+    width,
+    height,
+    timestamp,
+    duration,
+    displayWidth,
+    displayHeight,
+    colorSpace,
+    transfer
+  } = options;
+  if (width <= 0 || height <= 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) {
+    throw new Error(
+      `Buffer too small for ${format} format. Expected at least ${expectedSize} bytes, got ${actualSize} bytes`
+    );
+  }
+  const init = {
+    format,
+    codedWidth: width,
+    codedHeight: height,
+    timestamp
+  };
+  if (duration !== void 0) {
+    init.duration = duration;
+  }
+  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);
+}
+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)));
+    }
+  }
+  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;
+        }
+      }
+      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)));
+    }
+  }
+  return yuvData;
+}
+function calculateYUVDataSize(format, width, height) {
+  const lumaSize = width * height;
+  switch (format) {
+    case "I420":
+    case "NV12":
+      return lumaSize + lumaSize / 2;
+    case "I420A":
+      return lumaSize * 2 + lumaSize / 2;
+    case "I422":
+      return lumaSize * 2;
+    case "I444":
+      return lumaSize * 3;
+    default:
+      throw new Error(`Unsupported YUV format: ${format}`);
+  }
+}
+export {
+  Fisheye,
+  calculateYUVDataSize,
+  convertRGBAtoYUV,
+  createVideoFrameFromYUV
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fisheye.ts","../src/utils.ts"],"sourcesContent":["import tgpu, { type TgpuBuffer, type TgpuTexture } from \"typegpu\";\nimport * as d from \"typegpu/data\";\nimport * as std from \"typegpu/std\";\nimport type { FisheyeConfig, FisheyeOptions } from \"./types\";\n\n/**\n * Uniform struct for fisheye dewarping parameters\n */\nconst FisheyeUniforms = d.struct({\n  k1: d.f32,\n  k2: d.f32,\n  k3: d.f32,\n  k4: d.f32,\n  fov: d.f32,\n  centerX: d.f32,\n  centerY: d.f32,\n  zoom: d.f32,\n  width: d.f32,\n  height: d.f32,\n  padding: d.f32,\n});\n\ntype TgpuRootType = Awaited<ReturnType<typeof tgpu.init>>;\n\n/**\n * Bind group layout for fisheye dewarping compute shader\n */\nconst fisheyeLayout = tgpu.bindGroupLayout({\n  inputTexture: { texture: d.texture2d() },\n  outputTexture: { storageTexture: d.textureStorage2d(\"rgba8unorm\") },\n  uniforms: { uniform: FisheyeUniforms },\n});\n\n// Type definitions for textures with proper usage flags\ntype SampledTextureProps = {\n  size: readonly [number, number];\n  format: \"rgba8unorm\";\n};\n\ntype StorageTextureProps = {\n  size: readonly [number, number];\n  format: \"rgba8unorm\";\n};\n\ntype InputTextureType = TgpuTexture<SampledTextureProps> & {\n  usableAsSampled: true;\n};\n\ntype OutputTextureType = TgpuTexture<StorageTextureProps> & {\n  usableAsStorage: true;\n};\n\ntype UniformBufferType = TgpuBuffer<typeof FisheyeUniforms> & {\n  usableAsUniform: true;\n};\n\n/**\n * Fisheye dewarper using WebGPU via TypeGPU (Pure GPGPU)\n *\n * @example\n * ```ts\n * const dewarper = new Fisheye({\n *   distortion: 0.5,\n *   width: 1920,\n *   height: 1080,\n * });\n *\n * const dewarpedFrame = await dewarper.dewarp(videoFrame);\n * ```\n */\nexport class Fisheye {\n  private config: FisheyeConfig;\n  private root: TgpuRootType | null = null;\n  private uniformBuffer: UniformBufferType | null = null;\n  private inputTexture: InputTextureType | null = null;\n  private outputTexture: OutputTextureType | null = null;\n  private inputView: ReturnType<typeof Fisheye.createInputView> | null = null;\n  private outputView: ReturnType<typeof Fisheye.createOutputView> | null = null;\n  private bindGroup: ReturnType<TgpuRootType[\"createBindGroup\"]> | null = null;\n  private dewarpPipeline: ReturnType<\n    TgpuRootType[\"~unstable\"][\"createGuardedComputePipeline\"]\n  > | null = null;\n  private readbackBuffers: [GPUBuffer | null, GPUBuffer | null] | null = null;\n  private readbackIndex = 0;\n  private readbackHasData: [boolean, boolean] = [false, false];\n  private readbackBytesPerRow = 0;\n  private readbackActualBytesPerRow = 0;\n  private pixelBuffer: Uint8Array | null = null;\n  private inputTextureSize: [number, number] = [0, 0];\n  private outputTextureSize: [number, number] = [0, 0];\n\n  private static createInputView(texture: InputTextureType) {\n    return texture.createView(d.texture2d());\n  }\n\n  private static createOutputView(texture: OutputTextureType) {\n    return texture.createView(d.textureStorage2d(\"rgba8unorm\"));\n  }\n\n  constructor(options: FisheyeOptions = {}) {\n    this.config = this.applyDefaults(options);\n  }\n\n  /**\n   * Apply default values to options\n   */\n  private applyDefaults(options: FisheyeOptions): FisheyeConfig {\n    const k1 = options.k1 ?? 0;\n    return {\n      k1,\n      k2: options.k2 ?? 0,\n      k3: options.k3 ?? 0,\n      k4: options.k4 ?? 0,\n      width: options.width ?? 300,\n      height: options.height ?? 150,\n      fov: options.fov ?? 180,\n      centerX: options.centerX ?? 0,\n      centerY: options.centerY ?? 0,\n      zoom: options.zoom ?? 1.0,\n    };\n  }\n\n  /**\n   * Initialize TypeGPU root and resources\n   */\n  private async initialize(): Promise<void> {\n    if (this.root) {\n      return;\n    }\n\n    this.root = await tgpu.init();\n\n    // Create uniform buffer with TypeGPU for type-safe data handling\n    this.uniformBuffer = this.root\n      .createBuffer(FisheyeUniforms, this.getUniformData())\n      .$usage(\"uniform\");\n\n    this.dewarpPipeline = this.root[\"~unstable\"].createGuardedComputePipeline(\n      (x: number, y: number) => {\n        \"use gpu\";\n\n        const inputTex = fisheyeLayout.$.inputTexture;\n        const outputTex = fisheyeLayout.$.outputTexture;\n        const params = fisheyeLayout.$.uniforms;\n\n        const inputDims = std.textureDimensions(inputTex);\n        const outputDims = std.textureDimensions(outputTex);\n        const coord = d.vec2i(x, y);\n\n        // Early exit if outside texture bounds\n        if (x >= outputDims.x || y >= outputDims.y) {\n          return;\n        }\n\n        // Normalize coordinates to [-1, 1]\n        const uv = d.vec2f(\n          (d.f32(coord.x) / d.f32(outputDims.x) - 0.5) * 2.0,\n          (d.f32(coord.y) / d.f32(outputDims.y) - 0.5) * 2.0,\n        );\n\n        // Apply center offset\n        const centered = uv.sub(d.vec2f(params.centerX, params.centerY));\n\n        // Calculate radius from center\n        const r = std.length(centered);\n\n        // Fisheye distortion (OpenCV model): theta_d = theta * (1 + k1*theta^2 + k2*theta^4 + k3*theta^6 + k4*theta^8)\n        const theta = std.atan(r);\n        const theta2 = theta * theta;\n        const theta4 = theta2 * theta2;\n        const theta6 = theta4 * theta2;\n        const theta8 = theta4 * theta4;\n        const thetaDistorted =\n          theta *\n          (1.0 + params.k1 * theta2 + params.k2 * theta4 + params.k3 * theta6 + params.k4 * theta8);\n        const rDistorted = std.tan(thetaDistorted);\n\n        // Apply zoom\n        const rScaled = rDistorted / params.zoom;\n\n        // Convert back to texture coordinates\n        let distortedUv = centered;\n        if (r > 0.0001) {\n          distortedUv = centered.mul(rScaled / r);\n        }\n\n        // Add center offset back and denormalize\n        const finalUv = distortedUv.add(d.vec2f(params.centerX, params.centerY)).mul(0.5).add(0.5);\n\n        // Sample from input texture if within bounds\n        if (finalUv.x >= 0.0 && finalUv.x <= 1.0 && finalUv.y >= 0.0 && finalUv.y <= 1.0) {\n          const sampleCoord = d.vec2i(\n            d.i32(finalUv.x * d.f32(inputDims.x)),\n            d.i32(finalUv.y * d.f32(inputDims.y)),\n          );\n          const color = std.textureLoad(inputTex, sampleCoord, 0);\n          std.textureStore(outputTex, coord, color);\n        } else {\n          // Black for out of bounds\n          std.textureStore(outputTex, coord, d.vec4f(0.0, 0.0, 0.0, 1.0));\n        }\n      },\n    );\n  }\n\n  /**\n   * Get uniform data from current configuration\n   */\n  private getUniformData(): d.Infer<typeof FisheyeUniforms> {\n    return {\n      k1: this.config.k1,\n      k2: this.config.k2,\n      k3: this.config.k3,\n      k4: this.config.k4,\n      fov: this.config.fov,\n      centerX: this.config.centerX,\n      centerY: this.config.centerY,\n      zoom: this.config.zoom,\n      width: this.config.width,\n      height: this.config.height,\n      padding: 0,\n    };\n  }\n\n  /**\n   * Update uniform buffer with current configuration\n   */\n  private updateUniforms(): void {\n    if (!this.uniformBuffer) {\n      return;\n    }\n    this.uniformBuffer.write(this.getUniformData());\n  }\n\n  private async readbackToVideoFrame(\n    device: GPUDevice,\n    root: TgpuRootType,\n    outputTexture: OutputTextureType,\n    timestamp: number,\n  ): Promise<VideoFrame> {\n    const readbackBuffers = this.readbackBuffers;\n\n    if (!readbackBuffers) {\n      throw new Error(\"Readback buffer not initialized\");\n    }\n\n    const outputGpuTexture = root.unwrap(outputTexture);\n    const commandEncoder = device.createCommandEncoder();\n    const writeIndex = this.readbackIndex;\n    const readIndex = 1 - writeIndex;\n    const writeBuffer = readbackBuffers[writeIndex];\n    const readBuffer = readbackBuffers[readIndex];\n\n    if (!writeBuffer || !readBuffer) {\n      throw new Error(\"Readback buffer not initialized\");\n    }\n\n    commandEncoder.copyTextureToBuffer(\n      { texture: outputGpuTexture },\n      { buffer: writeBuffer, bytesPerRow: this.readbackBytesPerRow },\n      [this.config.width, this.config.height],\n    );\n    device.queue.submit([commandEncoder.finish()]);\n\n    this.readbackHasData[writeIndex] = true;\n    this.readbackIndex = readIndex;\n\n    const bufferToRead = this.readbackHasData[readIndex] ? readBuffer : writeBuffer;\n\n    await bufferToRead.mapAsync(GPUMapMode.READ);\n    const mappedData = bufferToRead.getMappedRange();\n\n    const pixelData =\n      this.pixelBuffer ?? new Uint8Array(this.config.width * this.config.height * 4);\n    const srcView = new Uint8Array(mappedData);\n\n    for (let row = 0; row < this.config.height; row++) {\n      const srcOffset = row * this.readbackBytesPerRow;\n      const dstOffset = row * this.readbackActualBytesPerRow;\n      pixelData.set(\n        srcView.subarray(srcOffset, srcOffset + this.readbackActualBytesPerRow),\n        dstOffset,\n      );\n    }\n\n    bufferToRead.unmap();\n\n    return new VideoFrame(pixelData, {\n      format: \"RGBA\",\n      codedWidth: this.config.width,\n      codedHeight: this.config.height,\n      timestamp,\n    });\n  }\n\n  /**\n   * Create input texture with proper typing\n   */\n  private createInputTexture(root: TgpuRootType, width: number, height: number): InputTextureType {\n    const size: readonly [number, number] = [width, height];\n    const format: \"rgba8unorm\" = \"rgba8unorm\";\n    return root[\"~unstable\"].createTexture({ size, format }).$usage(\"sampled\");\n  }\n\n  /**\n   * Create output texture with proper typing (storage only, no render needed for GPGPU)\n   */\n  private createOutputTexture(\n    root: TgpuRootType,\n    width: number,\n    height: number,\n  ): OutputTextureType {\n    const size: readonly [number, number] = [width, height];\n    const format: \"rgba8unorm\" = \"rgba8unorm\";\n    return root[\"~unstable\"].createTexture({ size, format }).$usage(\"storage\");\n  }\n\n  /**\n   * Calculate bytes per row with proper alignment (256-byte alignment for WebGPU)\n   */\n  private calculateBytesPerRow(width: number): number {\n    const bytesPerPixel = 4; // RGBA8\n    const unalignedBytesPerRow = width * bytesPerPixel;\n    // WebGPU requires 256-byte alignment for buffer copies\n    return Math.ceil(unalignedBytesPerRow / 256) * 256;\n  }\n\n  /**\n   * Create or recreate readback buffer for GPU to CPU data transfer\n   */\n  private createReadbackBuffer(device: GPUDevice, width: number, height: number): GPUBuffer {\n    const bytesPerRow = this.calculateBytesPerRow(width);\n    const bufferSize = bytesPerRow * height;\n\n    return device.createBuffer({\n      size: bufferSize,\n      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,\n    });\n  }\n\n  /**\n   * Dewarp a VideoFrame\n   *\n   * @param frame - Input VideoFrame with fisheye distortion\n   * @returns Dewarped VideoFrame\n   */\n  async dewarp(frame: VideoFrame): Promise<VideoFrame> {\n    await this.initialize();\n\n    if (!this.root || !this.uniformBuffer) {\n      throw new Error(\"GPU resources not initialized\");\n    }\n\n    // Capture root for type narrowing\n    const root = this.root;\n    const device = root.device;\n\n    let bindGroupDirty = false;\n\n    // Create or recreate input texture if dimensions changed\n    if (\n      !this.inputTexture ||\n      this.inputTextureSize[0] !== frame.displayWidth ||\n      this.inputTextureSize[1] !== frame.displayHeight\n    ) {\n      this.inputTexture?.destroy();\n      this.inputTexture = this.createInputTexture(root, frame.displayWidth, frame.displayHeight);\n      this.inputTextureSize = [frame.displayWidth, frame.displayHeight];\n      this.inputView = Fisheye.createInputView(this.inputTexture);\n      bindGroupDirty = true;\n    }\n\n    // Create or recreate output texture and readback buffer if config dimensions changed\n    if (\n      !this.outputTexture ||\n      this.outputTextureSize[0] !== this.config.width ||\n      this.outputTextureSize[1] !== this.config.height\n    ) {\n      this.outputTexture?.destroy();\n      this.readbackBuffers?.[0]?.destroy();\n      this.readbackBuffers?.[1]?.destroy();\n\n      this.outputTexture = this.createOutputTexture(root, this.config.width, this.config.height);\n      this.outputView = Fisheye.createOutputView(this.outputTexture);\n      this.readbackBytesPerRow = this.calculateBytesPerRow(this.config.width);\n      this.readbackActualBytesPerRow = this.config.width * 4;\n      this.pixelBuffer = new Uint8Array(this.config.width * this.config.height * 4);\n      this.readbackBuffers = [\n        this.createReadbackBuffer(device, this.config.width, this.config.height),\n        this.createReadbackBuffer(device, this.config.width, this.config.height),\n      ];\n      this.readbackIndex = 0;\n      this.readbackHasData = [false, false];\n      this.outputTextureSize = [this.config.width, this.config.height];\n      bindGroupDirty = true;\n    }\n\n    // Capture for type narrowing\n    const inputTexture = this.inputTexture;\n    const outputTexture = this.outputTexture;\n\n    // Write VideoFrame to input texture\n    inputTexture.write(frame);\n\n    if (bindGroupDirty || !this.bindGroup) {\n      this.bindGroup = root.createBindGroup(fisheyeLayout, {\n        inputTexture: this.inputView ?? Fisheye.createInputView(inputTexture),\n        outputTexture: this.outputView ?? Fisheye.createOutputView(outputTexture),\n        uniforms: this.uniformBuffer,\n      });\n    }\n\n    const bindGroup = this.bindGroup;\n    const dewarpPipeline = this.dewarpPipeline;\n\n    if (!dewarpPipeline) {\n      throw new Error(\"Compute pipeline not initialized\");\n    }\n\n    // Execute the compute shader\n    dewarpPipeline.with(bindGroup).dispatchThreads(this.config.width, this.config.height);\n\n    return this.readbackToVideoFrame(device, root, outputTexture, frame.timestamp);\n  }\n\n  /**\n   * Update configuration\n   */\n  updateConfig(options: Partial<FisheyeOptions>): void {\n    this.config = this.applyDefaults({ ...this.config, ...options });\n    this.updateUniforms();\n\n    // Recreate output texture and readback buffer if size changed\n    if (options.width || options.height) {\n      this.outputTexture?.destroy();\n      this.readbackBuffers?.[0]?.destroy();\n      this.readbackBuffers?.[1]?.destroy();\n      this.outputTexture = null;\n      this.readbackBuffers = null;\n      this.readbackIndex = 0;\n      this.readbackHasData = [false, false];\n      this.outputTextureSize = [0, 0];\n      this.outputView = null;\n      this.bindGroup = null;\n      this.readbackBytesPerRow = 0;\n      this.readbackActualBytesPerRow = 0;\n      this.pixelBuffer = null;\n    }\n  }\n\n  /**\n   * Clean up GPU resources\n   */\n  destroy(): void {\n    this.inputTexture?.destroy();\n    this.outputTexture?.destroy();\n    this.readbackBuffers?.[0]?.destroy();\n    this.readbackBuffers?.[1]?.destroy();\n    this.root?.destroy();\n\n    this.inputTexture = null;\n    this.outputTexture = null;\n    this.readbackBuffers = null;\n    this.readbackIndex = 0;\n    this.readbackHasData = [false, false];\n    this.uniformBuffer = null;\n    this.root = null;\n    this.inputView = null;\n    this.outputView = null;\n    this.bindGroup = null;\n    this.dewarpPipeline = null;\n    this.readbackBytesPerRow = 0;\n    this.readbackActualBytesPerRow = 0;\n    this.pixelBuffer = null;\n    this.inputTextureSize = [0, 0];\n    this.outputTextureSize = [0, 0];\n  }\n}\n","/**\n * Supported YUV pixel formats for VideoFrame creation\n */\nexport type YUVFormat = \"I420\" | \"I420A\" | \"I422\" | \"I444\" | \"NV12\";\n\n/**\n * Extended VideoFrameBufferInit with transfer support\n * (transfer is part of the spec but may not be in all TypeScript definitions)\n */\ninterface VideoFrameBufferInitExtended extends VideoFrameBufferInit {\n  transfer?: ArrayBuffer[];\n}\n\n/**\n * Options for creating a VideoFrame from YUV data\n */\nexport interface CreateVideoFrameOptions {\n  /**\n   * YUV pixel format\n   * - I420: YUV 4:2:0 planar (Y plane, U plane, V plane)\n   * - I420A: YUV 4:2:0 planar with alpha\n   * - I422: YUV 4:2:2 planar\n   * - I444: YUV 4:4:4 planar\n   * - NV12: YUV 4:2:0 semi-planar (Y plane, interleaved UV plane)\n   */\n  format: YUVFormat;\n\n  /**\n   * Width of the video frame in pixels\n   */\n  width: number;\n\n  /**\n   * Height of the video frame in pixels\n   */\n  height: number;\n\n  /**\n   * Timestamp in microseconds\n   */\n  timestamp: number;\n\n  /**\n   * Duration in microseconds (optional)\n   */\n  duration?: number;\n\n  /**\n   * Display width (optional, defaults to width)\n   */\n  displayWidth?: number;\n\n  /**\n   * Display height (optional, defaults to height)\n   */\n  displayHeight?: number;\n\n  /**\n   * Color space configuration (optional)\n   */\n  colorSpace?: VideoColorSpaceInit;\n\n  /**\n   * Transfer ownership of the buffer for zero-copy (optional)\n   * If true, the input buffer will be detached after VideoFrame creation\n   */\n  transfer?: boolean;\n}\n\n/**\n * Create a VideoFrame from YUV binary data\n *\n * @param data - YUV binary data (ArrayBuffer, TypedArray, or DataView)\n * @param options - Configuration options including format, dimensions, and timestamp\n * @returns A new VideoFrame object\n *\n * @example\n * ```ts\n * // Create VideoFrame from I420 (YUV 4:2:0) data\n * const yuvData = new Uint8Array(width * height * 1.5); // I420 size\n * const frame = createVideoFrameFromYUV(yuvData, {\n *   format: \"I420\",\n *   width: 1920,\n *   height: 1080,\n *   timestamp: 0,\n * });\n * ```\n *\n * @example\n * ```ts\n * // Create VideoFrame from NV12 data with zero-copy transfer\n * const nv12Data = new Uint8Array(width * height * 1.5);\n * const frame = createVideoFrameFromYUV(nv12Data, {\n *   format: \"NV12\",\n *   width: 1920,\n *   height: 1080,\n *   timestamp: 0,\n *   transfer: true, // Transfer buffer ownership for better performance\n * });\n * ```\n */\nexport function createVideoFrameFromYUV(\n  data: BufferSource,\n  options: CreateVideoFrameOptions,\n): VideoFrame {\n  const {\n    format,\n    width,\n    height,\n    timestamp,\n    duration,\n    displayWidth,\n    displayHeight,\n    colorSpace,\n    transfer,\n  } = options;\n\n  // Validate dimensions\n  if (width <= 0 || height <= 0) {\n    throw new Error(\"Width and height must be positive integers\");\n  }\n\n  // Calculate expected data size based on format\n  const expectedSize = calculateYUVDataSize(format, width, height);\n  const actualSize = data instanceof ArrayBuffer ? data.byteLength : data.byteLength;\n\n  if (actualSize < expectedSize) {\n    throw new Error(\n      `Buffer too small for ${format} format. Expected at least ${expectedSize} bytes, got ${actualSize} bytes`,\n    );\n  }\n\n  // Build VideoFrame init options\n  const init: VideoFrameBufferInitExtended = {\n    format,\n    codedWidth: width,\n    codedHeight: height,\n    timestamp,\n  };\n\n  if (duration !== undefined) {\n    init.duration = duration;\n  }\n\n  if (displayWidth !== undefined) {\n    init.displayWidth = displayWidth;\n  }\n\n  if (displayHeight !== undefined) {\n    init.displayHeight = displayHeight;\n  }\n\n  if (colorSpace !== undefined) {\n    init.colorSpace = colorSpace;\n  }\n\n  // Handle buffer transfer for zero-copy\n  if (transfer) {\n    const buffer = data instanceof ArrayBuffer ? data : data.buffer;\n    init.transfer = [buffer];\n  }\n\n  return new VideoFrame(data, init);\n}\n\n/**\n * Convert RGBA image data to YUV format (I420 by default)\n *\n * Uses ITU-R BT.601 color space conversion:\n * - Y = 0.299*R + 0.587*G + 0.114*B\n * - U = -0.169*R - 0.331*G + 0.5*B + 128\n * - V = 0.5*R - 0.419*G - 0.081*B + 128\n *\n * For I420 format:\n * - Y plane: full resolution (width * height)\n * - U plane: quarter resolution ((width/2) * (height/2))\n * - V plane: quarter resolution ((width/2) * (height/2))\n *\n * @param rgbaData - RGBA pixel data (Uint8ClampedArray from ImageData)\n * @param width - Image width in pixels\n * @param height - Image height in pixels\n * @param format - YUV format to convert to (default: \"I420\")\n * @returns YUV data as Uint8Array\n *\n * @example\n * ```ts\n * const canvas = document.createElement('canvas');\n * const ctx = canvas.getContext('2d');\n * ctx.drawImage(image, 0, 0);\n * const imageData = ctx.getImageData(0, 0, width, height);\n * const yuvData = convertRGBAtoYUV(imageData.data, width, height);\n * ```\n */\nexport function convertRGBAtoYUV(\n  rgbaData: Uint8ClampedArray,\n  width: number,\n  height: number,\n  format: YUVFormat = \"I420\",\n): Uint8Array {\n  if (format !== \"I420\") {\n    throw new Error(`Unsupported format: ${format}. Only I420 is currently supported.`);\n  }\n\n  const lumaSize = width * height;\n  const chromaSize = (width / 2) * (height / 2);\n  const yuvSize = lumaSize + chromaSize * 2; // Y + U + V\n  const yuvData = new Uint8Array(yuvSize);\n\n  // BT.601 coefficients\n  const Y_R = 0.299;\n  const Y_G = 0.587;\n  const Y_B = 0.114;\n  const U_R = -0.169;\n  const U_G = -0.331;\n  const U_B = 0.5;\n  const V_R = 0.5;\n  const V_G = -0.419;\n  const V_B = -0.081;\n\n  // Convert RGB to YUV and downsample chroma for I420\n  const yPlane = yuvData.subarray(0, lumaSize);\n  const uPlane = yuvData.subarray(lumaSize, lumaSize + chromaSize);\n  const vPlane = yuvData.subarray(lumaSize + chromaSize, yuvSize);\n\n  // First pass: convert to YUV and store Y plane\n  for (let y = 0; y < height; y++) {\n    for (let x = 0; x < width; x++) {\n      const rgbaIdx = (y * width + x) * 4;\n      const r = rgbaData[rgbaIdx];\n      const g = rgbaData[rgbaIdx + 1];\n      const b = rgbaData[rgbaIdx + 2];\n\n      // Calculate Y (luma)\n      const yVal = Y_R * r + Y_G * g + Y_B * b;\n      yPlane[y * width + x] = Math.round(Math.max(0, Math.min(255, yVal)));\n\n      // Calculate U and V for chroma downsampling\n      // We'll accumulate these in the second pass\n    }\n  }\n\n  // Second pass: downsample U and V planes (average 2x2 blocks)\n  for (let y = 0; y < height / 2; y++) {\n    for (let x = 0; x < width / 2; x++) {\n      // Sample 2x2 block from original image\n      let uSum = 0;\n      let vSum = 0;\n\n      for (let dy = 0; dy < 2; dy++) {\n        for (let dx = 0; dx < 2; dx++) {\n          const srcX = x * 2 + dx;\n          const srcY = y * 2 + dy;\n          const rgbaIdx = (srcY * width + srcX) * 4;\n          const r = rgbaData[rgbaIdx];\n          const g = rgbaData[rgbaIdx + 1];\n          const b = rgbaData[rgbaIdx + 2];\n\n          // Calculate U and V\n          const uVal = U_R * r + U_G * g + U_B * b + 128;\n          const vVal = V_R * r + V_G * g + V_B * b + 128;\n\n          uSum += uVal;\n          vSum += vVal;\n        }\n      }\n\n      // Average the 2x2 block\n      const uAvg = uSum / 4;\n      const vAvg = vSum / 4;\n\n      const chromaIdx = y * (width / 2) + x;\n      uPlane[chromaIdx] = Math.round(Math.max(0, Math.min(255, uAvg)));\n      vPlane[chromaIdx] = Math.round(Math.max(0, Math.min(255, vAvg)));\n    }\n  }\n\n  return yuvData;\n}\n\n/**\n * Calculate the expected byte size for YUV data based on format and dimensions\n *\n * @param format - YUV pixel format\n * @param width - Frame width in pixels\n * @param height - Frame height in pixels\n * @returns Expected byte size\n */\nexport function calculateYUVDataSize(format: YUVFormat, width: number, height: number): number {\n  const lumaSize = width * height;\n\n  switch (format) {\n    case \"I420\":\n    case \"NV12\":\n      // 4:2:0 - chroma is half resolution in both dimensions\n      // Y: width * height, U: (width/2) * (height/2), V: (width/2) * (height/2)\n      return lumaSize + lumaSize / 2;\n\n    case \"I420A\":\n      // 4:2:0 with alpha\n      // Y: width * height, U: (width/2) * (height/2), V: (width/2) * (height/2), A: width * height\n      return lumaSize * 2 + lumaSize / 2;\n\n    case \"I422\":\n      // 4:2:2 - chroma is half resolution horizontally only\n      // Y: width * height, U: (width/2) * height, V: (width/2) * height\n      return lumaSize * 2;\n\n    case \"I444\":\n      // 4:4:4 - full resolution for all planes\n      // Y: width * height, U: width * height, V: width * height\n      return lumaSize * 3;\n\n    default:\n      throw new Error(`Unsupported YUV format: ${format}`);\n  }\n}\n"],"mappings":";AAAA,OAAO,UAAiD;AACxD,YAAY,OAAO;AACnB,YAAY,SAAS;AAMrB,IAAM,kBAAoB,SAAO;AAAA,EAC/B,IAAM;AAAA,EACN,IAAM;AAAA,EACN,IAAM;AAAA,EACN,IAAM;AAAA,EACN,KAAO;AAAA,EACP,SAAW;AAAA,EACX,SAAW;AAAA,EACX,MAAQ;AAAA,EACR,OAAS;AAAA,EACT,QAAU;AAAA,EACV,SAAW;AACb,CAAC;AAOD,IAAM,gBAAgB,KAAK,gBAAgB;AAAA,EACzC,cAAc,EAAE,SAAW,YAAU,EAAE;AAAA,EACvC,eAAe,EAAE,gBAAkB,mBAAiB,YAAY,EAAE;AAAA,EAClE,UAAU,EAAE,SAAS,gBAAgB;AACvC,CAAC;AAuCM,IAAM,UAAN,MAAM,SAAQ;AAAA,EACX;AAAA,EACA,OAA4B;AAAA,EAC5B,gBAA0C;AAAA,EAC1C,eAAwC;AAAA,EACxC,gBAA0C;AAAA,EAC1C,YAA+D;AAAA,EAC/D,aAAiE;AAAA,EACjE,YAAgE;AAAA,EAChE,iBAEG;AAAA,EACH,kBAA+D;AAAA,EAC/D,gBAAgB;AAAA,EAChB,kBAAsC,CAAC,OAAO,KAAK;AAAA,EACnD,sBAAsB;AAAA,EACtB,4BAA4B;AAAA,EAC5B,cAAiC;AAAA,EACjC,mBAAqC,CAAC,GAAG,CAAC;AAAA,EAC1C,oBAAsC,CAAC,GAAG,CAAC;AAAA,EAEnD,OAAe,gBAAgB,SAA2B;AACxD,WAAO,QAAQ,WAAa,YAAU,CAAC;AAAA,EACzC;AAAA,EAEA,OAAe,iBAAiB,SAA4B;AAC1D,WAAO,QAAQ,WAAa,mBAAiB,YAAY,CAAC;AAAA,EAC5D;AAAA,EAEA,YAAY,UAA0B,CAAC,GAAG;AACxC,SAAK,SAAS,KAAK,cAAc,OAAO;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA,EAKQ,cAAc,SAAwC;AAC5D,UAAM,KAAK,QAAQ,MAAM;AACzB,WAAO;AAAA,MACL;AAAA,MACA,IAAI,QAAQ,MAAM;AAAA,MAClB,IAAI,QAAQ,MAAM;AAAA,MAClB,IAAI,QAAQ,MAAM;AAAA,MAClB,OAAO,QAAQ,SAAS;AAAA,MACxB,QAAQ,QAAQ,UAAU;AAAA,MAC1B,KAAK,QAAQ,OAAO;AAAA,MACpB,SAAS,QAAQ,WAAW;AAAA,MAC5B,SAAS,QAAQ,WAAW;AAAA,MAC5B,MAAM,QAAQ,QAAQ;AAAA,IACxB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,aAA4B;AACxC,QAAI,KAAK,MAAM;AACb;AAAA,IACF;AAEA,SAAK,OAAO,MAAM,KAAK,KAAK;AAG5B,SAAK,gBAAgB,KAAK,KACvB,aAAa,iBAAiB,KAAK,eAAe,CAAC,EACnD,OAAO,SAAS;AAEnB,SAAK,iBAAiB,KAAK,KAAK,WAAW,EAAE;AAAA,MAC3C,CAAC,GAAW,MAAc;AACxB;AAEA,cAAM,WAAW,cAAc,EAAE;AACjC,cAAM,YAAY,cAAc,EAAE;AAClC,cAAM,SAAS,cAAc,EAAE;AAE/B,cAAM,YAAgB,sBAAkB,QAAQ;AAChD,cAAM,aAAiB,sBAAkB,SAAS;AAClD,cAAM,QAAU,QAAM,GAAG,CAAC;AAG1B,YAAI,KAAK,WAAW,KAAK,KAAK,WAAW,GAAG;AAC1C;AAAA,QACF;AAGA,cAAM,KAAO;AAAA,WACR,MAAI,MAAM,CAAC,IAAM,MAAI,WAAW,CAAC,IAAI,OAAO;AAAA,WAC5C,MAAI,MAAM,CAAC,IAAM,MAAI,WAAW,CAAC,IAAI,OAAO;AAAA,QACjD;AAGA,cAAM,WAAW,GAAG,IAAM,QAAM,OAAO,SAAS,OAAO,OAAO,CAAC;AAG/D,cAAM,IAAQ,WAAO,QAAQ;AAG7B,cAAM,QAAY,SAAK,CAAC;AACxB,cAAM,SAAS,QAAQ;AACvB,cAAM,SAAS,SAAS;AACxB,cAAM,SAAS,SAAS;AACxB,cAAM,SAAS,SAAS;AACxB,cAAM,iBACJ,SACC,IAAM,OAAO,KAAK,SAAS,OAAO,KAAK,SAAS,OAAO,KAAK,SAAS,OAAO,KAAK;AACpF,cAAM,aAAiB,QAAI,cAAc;AAGzC,cAAM,UAAU,aAAa,OAAO;AAGpC,YAAI,cAAc;AAClB,YAAI,IAAI,MAAQ;AACd,wBAAc,SAAS,IAAI,UAAU,CAAC;AAAA,QACxC;AAGA,cAAM,UAAU,YAAY,IAAM,QAAM,OAAO,SAAS,OAAO,OAAO,CAAC,EAAE,IAAI,GAAG,EAAE,IAAI,GAAG;AAGzF,YAAI,QAAQ,KAAK,KAAO,QAAQ,KAAK,KAAO,QAAQ,KAAK,KAAO,QAAQ,KAAK,GAAK;AAChF,gBAAM,cAAgB;AAAA,YAClB,MAAI,QAAQ,IAAM,MAAI,UAAU,CAAC,CAAC;AAAA,YAClC,MAAI,QAAQ,IAAM,MAAI,UAAU,CAAC,CAAC;AAAA,UACtC;AACA,gBAAM,QAAY,gBAAY,UAAU,aAAa,CAAC;AACtD,UAAI,iBAAa,WAAW,OAAO,KAAK;AAAA,QAC1C,OAAO;AAEL,UAAI,iBAAa,WAAW,OAAS,QAAM,GAAK,GAAK,GAAK,CAAG,CAAC;AAAA,QAChE;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,iBAAkD;AACxD,WAAO;AAAA,MACL,IAAI,KAAK,OAAO;AAAA,MAChB,IAAI,KAAK,OAAO;AAAA,MAChB,IAAI,KAAK,OAAO;AAAA,MAChB,IAAI,KAAK,OAAO;AAAA,MAChB,KAAK,KAAK,OAAO;AAAA,MACjB,SAAS,KAAK,OAAO;AAAA,MACrB,SAAS,KAAK,OAAO;AAAA,MACrB,MAAM,KAAK,OAAO;AAAA,MAClB,OAAO,KAAK,OAAO;AAAA,MACnB,QAAQ,KAAK,OAAO;AAAA,MACpB,SAAS;AAAA,IACX;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKQ,iBAAuB;AAC7B,QAAI,CAAC,KAAK,eAAe;AACvB;AAAA,IACF;AACA,SAAK,cAAc,MAAM,KAAK,eAAe,CAAC;AAAA,EAChD;AAAA,EAEA,MAAc,qBACZ,QACA,MACA,eACA,WACqB;AACrB,UAAM,kBAAkB,KAAK;AAE7B,QAAI,CAAC,iBAAiB;AACpB,YAAM,IAAI,MAAM,iCAAiC;AAAA,IACnD;AAEA,UAAM,mBAAmB,KAAK,OAAO,aAAa;AAClD,UAAM,iBAAiB,OAAO,qBAAqB;AACnD,UAAM,aAAa,KAAK;AACxB,UAAM,YAAY,IAAI;AACtB,UAAM,cAAc,gBAAgB,UAAU;AAC9C,UAAM,aAAa,gBAAgB,SAAS;AAE5C,QAAI,CAAC,eAAe,CAAC,YAAY;AAC/B,YAAM,IAAI,MAAM,iCAAiC;AAAA,IACnD;AAEA,mBAAe;AAAA,MACb,EAAE,SAAS,iBAAiB;AAAA,MAC5B,EAAE,QAAQ,aAAa,aAAa,KAAK,oBAAoB;AAAA,MAC7D,CAAC,KAAK,OAAO,OAAO,KAAK,OAAO,MAAM;AAAA,IACxC;AACA,WAAO,MAAM,OAAO,CAAC,eAAe,OAAO,CAAC,CAAC;AAE7C,SAAK,gBAAgB,UAAU,IAAI;AACnC,SAAK,gBAAgB;AAErB,UAAM,eAAe,KAAK,gBAAgB,SAAS,IAAI,aAAa;AAEpE,UAAM,aAAa,SAAS,WAAW,IAAI;AAC3C,UAAM,aAAa,aAAa,eAAe;AAE/C,UAAM,YACJ,KAAK,eAAe,IAAI,WAAW,KAAK,OAAO,QAAQ,KAAK,OAAO,SAAS,CAAC;AAC/E,UAAM,UAAU,IAAI,WAAW,UAAU;AAEzC,aAAS,MAAM,GAAG,MAAM,KAAK,OAAO,QAAQ,OAAO;AACjD,YAAM,YAAY,MAAM,KAAK;AAC7B,YAAM,YAAY,MAAM,KAAK;AAC7B,gBAAU;AAAA,QACR,QAAQ,SAAS,WAAW,YAAY,KAAK,yBAAyB;AAAA,QACtE;AAAA,MACF;AAAA,IACF;AAEA,iBAAa,MAAM;AAEnB,WAAO,IAAI,WAAW,WAAW;AAAA,MAC/B,QAAQ;AAAA,MACR,YAAY,KAAK,OAAO;AAAA,MACxB,aAAa,KAAK,OAAO;AAAA,MACzB;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKQ,mBAAmB,MAAoB,OAAe,QAAkC;AAC9F,UAAM,OAAkC,CAAC,OAAO,MAAM;AACtD,UAAM,SAAuB;AAC7B,WAAO,KAAK,WAAW,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC,EAAE,OAAO,SAAS;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA,EAKQ,oBACN,MACA,OACA,QACmB;AACnB,UAAM,OAAkC,CAAC,OAAO,MAAM;AACtD,UAAM,SAAuB;AAC7B,WAAO,KAAK,WAAW,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC,EAAE,OAAO,SAAS;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA,EAKQ,qBAAqB,OAAuB;AAClD,UAAM,gBAAgB;AACtB,UAAM,uBAAuB,QAAQ;AAErC,WAAO,KAAK,KAAK,uBAAuB,GAAG,IAAI;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA,EAKQ,qBAAqB,QAAmB,OAAe,QAA2B;AACxF,UAAM,cAAc,KAAK,qBAAqB,KAAK;AACnD,UAAM,aAAa,cAAc;AAEjC,WAAO,OAAO,aAAa;AAAA,MACzB,MAAM;AAAA,MACN,OAAO,eAAe,WAAW,eAAe;AAAA,IAClD,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,OAAO,OAAwC;AACnD,UAAM,KAAK,WAAW;AAEtB,QAAI,CAAC,KAAK,QAAQ,CAAC,KAAK,eAAe;AACrC,YAAM,IAAI,MAAM,+BAA+B;AAAA,IACjD;AAGA,UAAM,OAAO,KAAK;AAClB,UAAM,SAAS,KAAK;AAEpB,QAAI,iBAAiB;AAGrB,QACE,CAAC,KAAK,gBACN,KAAK,iBAAiB,CAAC,MAAM,MAAM,gBACnC,KAAK,iBAAiB,CAAC,MAAM,MAAM,eACnC;AACA,WAAK,cAAc,QAAQ;AAC3B,WAAK,eAAe,KAAK,mBAAmB,MAAM,MAAM,cAAc,MAAM,aAAa;AACzF,WAAK,mBAAmB,CAAC,MAAM,cAAc,MAAM,aAAa;AAChE,WAAK,YAAY,SAAQ,gBAAgB,KAAK,YAAY;AAC1D,uBAAiB;AAAA,IACnB;AAGA,QACE,CAAC,KAAK,iBACN,KAAK,kBAAkB,CAAC,MAAM,KAAK,OAAO,SAC1C,KAAK,kBAAkB,CAAC,MAAM,KAAK,OAAO,QAC1C;AACA,WAAK,eAAe,QAAQ;AAC5B,WAAK,kBAAkB,CAAC,GAAG,QAAQ;AACnC,WAAK,kBAAkB,CAAC,GAAG,QAAQ;AAEnC,WAAK,gBAAgB,KAAK,oBAAoB,MAAM,KAAK,OAAO,OAAO,KAAK,OAAO,MAAM;AACzF,WAAK,aAAa,SAAQ,iBAAiB,KAAK,aAAa;AAC7D,WAAK,sBAAsB,KAAK,qBAAqB,KAAK,OAAO,KAAK;AACtE,WAAK,4BAA4B,KAAK,OAAO,QAAQ;AACrD,WAAK,cAAc,IAAI,WAAW,KAAK,OAAO,QAAQ,KAAK,OAAO,SAAS,CAAC;AAC5E,WAAK,kBAAkB;AAAA,QACrB,KAAK,qBAAqB,QAAQ,KAAK,OAAO,OAAO,KAAK,OAAO,MAAM;AAAA,QACvE,KAAK,qBAAqB,QAAQ,KAAK,OAAO,OAAO,KAAK,OAAO,MAAM;AAAA,MACzE;AACA,WAAK,gBAAgB;AACrB,WAAK,kBAAkB,CAAC,OAAO,KAAK;AACpC,WAAK,oBAAoB,CAAC,KAAK,OAAO,OAAO,KAAK,OAAO,MAAM;AAC/D,uBAAiB;AAAA,IACnB;AAGA,UAAM,eAAe,KAAK;AAC1B,UAAM,gBAAgB,KAAK;AAG3B,iBAAa,MAAM,KAAK;AAExB,QAAI,kBAAkB,CAAC,KAAK,WAAW;AACrC,WAAK,YAAY,KAAK,gBAAgB,eAAe;AAAA,QACnD,cAAc,KAAK,aAAa,SAAQ,gBAAgB,YAAY;AAAA,QACpE,eAAe,KAAK,cAAc,SAAQ,iBAAiB,aAAa;AAAA,QACxE,UAAU,KAAK;AAAA,MACjB,CAAC;AAAA,IACH;AAEA,UAAM,YAAY,KAAK;AACvB,UAAM,iBAAiB,KAAK;AAE5B,QAAI,CAAC,gBAAgB;AACnB,YAAM,IAAI,MAAM,kCAAkC;AAAA,IACpD;AAGA,mBAAe,KAAK,SAAS,EAAE,gBAAgB,KAAK,OAAO,OAAO,KAAK,OAAO,MAAM;AAEpF,WAAO,KAAK,qBAAqB,QAAQ,MAAM,eAAe,MAAM,SAAS;AAAA,EAC/E;AAAA;AAAA;AAAA;AAAA,EAKA,aAAa,SAAwC;AACnD,SAAK,SAAS,KAAK,cAAc,EAAE,GAAG,KAAK,QAAQ,GAAG,QAAQ,CAAC;AAC/D,SAAK,eAAe;AAGpB,QAAI,QAAQ,SAAS,QAAQ,QAAQ;AACnC,WAAK,eAAe,QAAQ;AAC5B,WAAK,kBAAkB,CAAC,GAAG,QAAQ;AACnC,WAAK,kBAAkB,CAAC,GAAG,QAAQ;AACnC,WAAK,gBAAgB;AACrB,WAAK,kBAAkB;AACvB,WAAK,gBAAgB;AACrB,WAAK,kBAAkB,CAAC,OAAO,KAAK;AACpC,WAAK,oBAAoB,CAAC,GAAG,CAAC;AAC9B,WAAK,aAAa;AAClB,WAAK,YAAY;AACjB,WAAK,sBAAsB;AAC3B,WAAK,4BAA4B;AACjC,WAAK,cAAc;AAAA,IACrB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,UAAgB;AACd,SAAK,cAAc,QAAQ;AAC3B,SAAK,eAAe,QAAQ;AAC5B,SAAK,kBAAkB,CAAC,GAAG,QAAQ;AACnC,SAAK,kBAAkB,CAAC,GAAG,QAAQ;AACnC,SAAK,MAAM,QAAQ;AAEnB,SAAK,eAAe;AACpB,SAAK,gBAAgB;AACrB,SAAK,kBAAkB;AACvB,SAAK,gBAAgB;AACrB,SAAK,kBAAkB,CAAC,OAAO,KAAK;AACpC,SAAK,gBAAgB;AACrB,SAAK,OAAO;AACZ,SAAK,YAAY;AACjB,SAAK,aAAa;AAClB,SAAK,YAAY;AACjB,SAAK,iBAAiB;AACtB,SAAK,sBAAsB;AAC3B,SAAK,4BAA4B;AACjC,SAAK,cAAc;AACnB,SAAK,mBAAmB,CAAC,GAAG,CAAC;AAC7B,SAAK,oBAAoB,CAAC,GAAG,CAAC;AAAA,EAChC;AACF;;;ACxXO,SAAS,wBACd,MACA,SACY;AACZ,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAGJ,MAAI,SAAS,KAAK,UAAU,GAAG;AAC7B,UAAM,IAAI,MAAM,4CAA4C;AAAA,EAC9D;AAGA,QAAM,eAAe,qBAAqB,QAAQ,OAAO,MAAM;AAC/D,QAAM,aAAa,gBAAgB,cAAc,KAAK,aAAa,KAAK;AAExE,MAAI,aAAa,cAAc;AAC7B,UAAM,IAAI;AAAA,MACR,wBAAwB,MAAM,8BAA8B,YAAY,eAAe,UAAU;AAAA,IACnG;AAAA,EACF;AAGA,QAAM,OAAqC;AAAA,IACzC;AAAA,IACA,YAAY;AAAA,IACZ,aAAa;AAAA,IACb;AAAA,EACF;AAEA,MAAI,aAAa,QAAW;AAC1B,SAAK,WAAW;AAAA,EAClB;AAEA,MAAI,iBAAiB,QAAW;AAC9B,SAAK,eAAe;AAAA,EACtB;AAEA,MAAI,kBAAkB,QAAW;AAC/B,SAAK,gBAAgB;AAAA,EACvB;AAEA,MAAI,eAAe,QAAW;AAC5B,SAAK,aAAa;AAAA,EACpB;AAGA,MAAI,UAAU;AACZ,UAAM,SAAS,gBAAgB,cAAc,OAAO,KAAK;AACzD,SAAK,WAAW,CAAC,MAAM;AAAA,EACzB;AAEA,SAAO,IAAI,WAAW,MAAM,IAAI;AAClC;AA8BO,SAAS,iBACd,UACA,OACA,QACA,SAAoB,QACR;AACZ,MAAI,WAAW,QAAQ;AACrB,UAAM,IAAI,MAAM,uBAAuB,MAAM,qCAAqC;AAAA,EACpF;AAEA,QAAM,WAAW,QAAQ;AACzB,QAAM,aAAc,QAAQ,KAAM,SAAS;AAC3C,QAAM,UAAU,WAAW,aAAa;AACxC,QAAM,UAAU,IAAI,WAAW,OAAO;AAGtC,QAAM,MAAM;AACZ,QAAM,MAAM;AACZ,QAAM,MAAM;AACZ,QAAM,MAAM;AACZ,QAAM,MAAM;AACZ,QAAM,MAAM;AACZ,QAAM,MAAM;AACZ,QAAM,MAAM;AACZ,QAAM,MAAM;AAGZ,QAAM,SAAS,QAAQ,SAAS,GAAG,QAAQ;AAC3C,QAAM,SAAS,QAAQ,SAAS,UAAU,WAAW,UAAU;AAC/D,QAAM,SAAS,QAAQ,SAAS,WAAW,YAAY,OAAO;AAG9D,WAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC/B,aAAS,IAAI,GAAG,IAAI,OAAO,KAAK;AAC9B,YAAM,WAAW,IAAI,QAAQ,KAAK;AAClC,YAAM,IAAI,SAAS,OAAO;AAC1B,YAAM,IAAI,SAAS,UAAU,CAAC;AAC9B,YAAM,IAAI,SAAS,UAAU,CAAC;AAG9B,YAAM,OAAO,MAAM,IAAI,MAAM,IAAI,MAAM;AACvC,aAAO,IAAI,QAAQ,CAAC,IAAI,KAAK,MAAM,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,IAAI,CAAC,CAAC;AAAA,IAIrE;AAAA,EACF;AAGA,WAAS,IAAI,GAAG,IAAI,SAAS,GAAG,KAAK;AACnC,aAAS,IAAI,GAAG,IAAI,QAAQ,GAAG,KAAK;AAElC,UAAI,OAAO;AACX,UAAI,OAAO;AAEX,eAAS,KAAK,GAAG,KAAK,GAAG,MAAM;AAC7B,iBAAS,KAAK,GAAG,KAAK,GAAG,MAAM;AAC7B,gBAAM,OAAO,IAAI,IAAI;AACrB,gBAAM,OAAO,IAAI,IAAI;AACrB,gBAAM,WAAW,OAAO,QAAQ,QAAQ;AACxC,gBAAM,IAAI,SAAS,OAAO;AAC1B,gBAAM,IAAI,SAAS,UAAU,CAAC;AAC9B,gBAAM,IAAI,SAAS,UAAU,CAAC;AAG9B,gBAAM,OAAO,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI;AAC3C,gBAAM,OAAO,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI;AAE3C,kBAAQ;AACR,kBAAQ;AAAA,QACV;AAAA,MACF;AAGA,YAAM,OAAO,OAAO;AACpB,YAAM,OAAO,OAAO;AAEpB,YAAM,YAAY,KAAK,QAAQ,KAAK;AACpC,aAAO,SAAS,IAAI,KAAK,MAAM,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,IAAI,CAAC,CAAC;AAC/D,aAAO,SAAS,IAAI,KAAK,MAAM,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,IAAI,CAAC,CAAC;AAAA,IACjE;AAAA,EACF;AAEA,SAAO;AACT;AAUO,SAAS,qBAAqB,QAAmB,OAAe,QAAwB;AAC7F,QAAM,WAAW,QAAQ;AAEzB,UAAQ,QAAQ;AAAA,IACd,KAAK;AAAA,IACL,KAAK;AAGH,aAAO,WAAW,WAAW;AAAA,IAE/B,KAAK;AAGH,aAAO,WAAW,IAAI,WAAW;AAAA,IAEnC,KAAK;AAGH,aAAO,WAAW;AAAA,IAEpB,KAAK;AAGH,aAAO,WAAW;AAAA,IAEpB;AACE,YAAM,IAAI,MAAM,2BAA2B,MAAM,EAAE;AAAA,EACvD;AACF;","names":[]}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@gyeonghokim/fisheye.js",
+  "private": false,
+  "version": "0.0.0",
+  "description": "Modern fisheye dewarping library for the web using WebGPU",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "type-check": "tsc --noEmit",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest",
+    "test:unit:ui": "vitest --ui",
+    "test:e2e": "playwright test",
+    "test:e2e:update": "playwright test --update-snapshots",
+    "test:e2e:ui": "playwright test --ui",
+    "prepare": "husky",
+    "release": "semantic-release"
+  },
+  "keywords": [
+    "fisheye",
+    "dewarping",
+    "webgpu",
+    "typegpu",
+    "video",
+    "videoframe",
+    "webcodecs"
+  ],
+  "author": "GyeongHo Kim",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GyeongHoKim/fisheye.js.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "tag": "latest",
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/GyeongHoKim/fisheye.js/issues"
+  },
+  "homepage": "https://github.com/GyeongHoKim/fisheye.js#readme",
+  "dependencies": {
+    "typegpu": "^0.9.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@commitlint/cli": "^20.3.1",
+    "@commitlint/config-conventional": "^20.3.1",
+    "@playwright/test": "^1.48.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/node": "^25.0.10",
+    "@vitest/ui": "^4.0.18",
+    "@webgpu/types": "^0.1.69",
+    "happy-dom": "^20.4.0",
+    "husky": "^9.1.7",
+    "semantic-release": "^25.0.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  }
+}