raw-webgpu 0.1.0-alpha.1

package/dist/decode/instantiate.d.ts

@@ -0,0 +1,3 @@
+import { type LibRaw } from "./libraw.js";
+/** Runs inside a worker: binds the Emscripten runtime to a module compiled on the main thread. */
+export declare function instantiateDecoder(module: WebAssembly.Module): Promise<LibRaw>;

package/dist/decode/module.d.ts

@@ -0,0 +1,2 @@
+/** Compiles the native decoder once per page; each worker instantiates the shared module. */
+export declare function compileDecoder(): Promise<WebAssembly.Module>;

package/dist/decode/session.d.ts

@@ -0,0 +1,7 @@
+import type { RawReply, WhiteBalance } from "../types";
+/** Each source retains one native calibration session in its own worker. */
+export declare function createSession(compiled: Promise<WebAssembly.Module>): {
+    /** A Blob opens a file; a white balance recalibrates the file already open. */
+    request(value: Blob | WhiteBalance): Promise<RawReply>;
+    dispose: (error?: Error) => void;
+};

package/dist/decode/tiff-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/decode/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/develop/gpu.d.ts

@@ -0,0 +1,27 @@
+import type { DevelopOptions, RawPixels } from "../types";
+export declare function createPipeline(device: GPUDevice): Promise<{
+    sensor: GPURenderPipeline;
+    camera: GPURenderPipeline;
+}>;
+/** Owns the sensor texture and immutable uniforms; each pass owns its calibration buffer. */
+export declare function createGpuSource(device: GPUDevice, pixels: RawPixels, pipeline: Awaited<ReturnType<typeof createPipeline>>): {
+    texture: GPUTexture;
+    metadata: {
+        size: [number, number];
+        flip: number;
+        cfa: number[] | null;
+        cfaSize?: number;
+        black: number[];
+        white: number;
+        vignette: number[];
+        demosaic: "gpu" | "cpu" | "none";
+        sampleFormat?: "uint16" | "float32";
+        whiteBalanceOrigin?: "as-shot" | "daylight";
+    };
+    size: [number, number];
+    createDevelopPass(): {
+        render(options: DevelopOptions): void;
+        dispose: () => void;
+    };
+    dispose: () => void;
+};

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import type { LoadOptions } from "./types";
+export type { Calibration, DevelopOptions, LoadOptions, RawMetadata, WhiteBalance, } from "./types";
+/** Reuses a pipeline on the consumer's device. Each load owns an independent worker and source. */
+export declare function createRawDecoder(device: GPUDevice): {
+    load(file: Blob, { signal }?: LoadOptions): Promise<{
+        texture: GPUTexture;
+        metadata: {
+            size: [number, number];
+            flip: number;
+            cfa: number[] | null;
+            cfaSize?: number;
+            black: number[];
+            white: number;
+            vignette: number[];
+            demosaic: "gpu" | "cpu" | "none";
+            sampleFormat?: "uint16" | "float32";
+            whiteBalanceOrigin?: "as-shot" | "daylight";
+        };
+        size: [number, number];
+        createDevelopPass(): {
+            render(options: import("./types").DevelopOptions): void;
+            dispose: () => void;
+        };
+        asShot: import("./types").WhiteBalance;
+        calibration: import("./types").Calibration;
+        /** Gains and matrix for another white point; omit the argument to restore as-shot. */
+        calibrate(balance?: import("./types").WhiteBalance): Promise<import("./types").Calibration>;
+        dispose: () => void;
+    }>;
+    dispose: () => void;
+};
+export type RawDecoder = ReturnType<typeof createRawDecoder>;
+export type RawSource = Awaited<ReturnType<RawDecoder["load"]>>;
+export { decodeTiff } from "./tiff";