raw-webgpu 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,710 @@
+// src/decode/module.ts
+var compiled;
+async function compile() {
+  const response = await fetch(new URL("./libraw.wasm", import.meta.url));
+  if (!response.ok) {
+    throw Error("Could not load the native decoder.");
+  }
+  const type = response.headers.get("content-type")?.split(";")[0].trim();
+  if (type === "application/wasm" && "compileStreaming" in WebAssembly) {
+    return WebAssembly.compileStreaming(response);
+  }
+  return WebAssembly.compile(await response.arrayBuffer());
+}
+function compileDecoder() {
+  compiled ??= compile().catch((error) => {
+    compiled = undefined;
+    throw error;
+  });
+  return compiled;
+}
+
+// src/decode/session.ts
+function createSession(compiled2) {
+  const worker = new Worker(new URL("./worker.js", import.meta.url), {
+    type: "module"
+  });
+  const pending = new Map;
+  let sequence = 0;
+  let failure;
+  function dispose(error = Error("RAW source is closed.")) {
+    failure = error;
+    worker.terminate();
+    for (const request of pending.values()) {
+      request.reject(error);
+    }
+    pending.clear();
+  }
+  compiled2.then((module) => worker.postMessage({ module }), (error) => dispose(error instanceof Error ? error : Error(String(error))));
+  worker.onmessage = ({
+    data
+  }) => {
+    const request = pending.get(data.id);
+    pending.delete(data.id);
+    if ("error" in data) {
+      request?.reject(Error(data.error));
+    } else {
+      request?.resolve(data);
+    }
+  };
+  worker.onerror = (event) => {
+    event.preventDefault();
+    dispose(Error(event.message || "RAW decoding worker failed."));
+  };
+  worker.onmessageerror = () => dispose(Error("Could not read the RAW worker response."));
+  return {
+    request(value) {
+      if (failure) {
+        return Promise.reject(failure);
+      }
+      const id = ++sequence;
+      const result = Promise.withResolvers();
+      pending.set(id, result);
+      try {
+        worker.postMessage({ id, value });
+      } catch (error) {
+        pending.delete(id);
+        result.reject(error);
+      }
+      return result.promise;
+    },
+    dispose
+  };
+}
+
+// src/develop/develop.wgsl
+var develop_default = `// Sensor samples in, unclipped linear Rec.2020 out: normalize, white balance,
+// demosaic when needed, correct vignetting, convert color and apply exposure.
+
+struct Sensor {
+  black: vec4f,
+  patternSize: vec4u,
+  white: f32,
+  flip: u32,
+  mosaic: u32,
+  floating: u32,
+}
+
+struct Calibration {
+  gains: vec3f,
+  exposure: f32,
+  matrix: mat3x3f,
+}
+
+struct Vignette {
+  coefficients: vec4f,
+  origin: vec2f,
+  step: vec2f,
+  last: f32,
+}
+
+@group(0) @binding(0) var source: texture_2d<u32>;
+@group(0) @binding(1) var<uniform> sensor: Sensor;
+@group(0) @binding(2) var<uniform> calibration: Calibration;
+@group(0) @binding(3) var<uniform> vignette: Vignette;
+
+@group(0) @binding(4) var<uniform> pattern: array<vec4u, 9>;
+
+// CFA color index at a sensor position: R=0, G=1 or 3, B=2.
+fn channel(p: vec2i) -> u32 {
+  if (sensor.patternSize.x == 2u) {
+    return pattern[0][(p.y & 1) * 2 + (p.x & 1)];
+  }
+  let side = i32(sensor.patternSize.x);
+  let q = (p % side + side) % side;
+  let i = u32(q.y * side + q.x);
+  return pattern[i / 4u][i % 4u];
+}
+
+// One normalized, white-balanced sample; both greens share the green gain.
+fn sample(p: vec2i, size: vec2i) -> f32 {
+  // Reflect at the border without changing CFA parity.
+  let q = min(abs(p), 2 * (size - 1) - p);
+  let c = channel(q);
+  let value = f32(textureLoad(source, q, 0).r);
+  let gain = calibration.gains[select(c, 1u, c == 3u)];
+  return max(value - sensor.black[c], 0.0) / (sensor.white - sensor.black[c]) * gain;
+}
+
+// Malvar, He and Cutler, ICASSP 2004, Fig. 2: gradient-corrected 5x5 Bayer filters.
+fn demosaic(p: vec2i, size: vec2i) -> vec3f {
+  let center = sample(p, size);
+  let horizontal = sample(p + vec2i(-1, 0), size) + sample(p + vec2i(1, 0), size);
+  let vertical = sample(p + vec2i(0, -1), size) + sample(p + vec2i(0, 1), size);
+  let horizontal2 = sample(p + vec2i(-2, 0), size) + sample(p + vec2i(2, 0), size);
+  let vertical2 = sample(p + vec2i(0, -2), size) + sample(p + vec2i(0, 2), size);
+  let diagonal = sample(p + vec2i(-1, -1), size) + sample(p + vec2i(1, -1), size)
+    + sample(p + vec2i(-1, 1), size) + sample(p + vec2i(1, 1), size);
+  let c = channel(p);
+
+  // At a red or blue site: green from the cross, the opposite color from the diagonals.
+  if (c == 0u || c == 2u) {
+    let green = (4.0 * center + 2.0 * (horizontal + vertical) - horizontal2 - vertical2) / 8.0;
+    let opposite = (6.0 * center + 2.0 * diagonal - 1.5 * (horizontal2 + vertical2)) / 8.0;
+    return select(vec3f(opposite, green, center), vec3f(center, green, opposite), c == 0u);
+  }
+
+  // At a green site: the color of the row neighbors uses the row filter, the other the column filter.
+  let across = (5.0 * center + 4.0 * horizontal - horizontal2 - diagonal + 0.5 * vertical2) / 8.0;
+  let along = (5.0 * center + 4.0 * vertical - vertical2 - diagonal + 0.5 * horizontal2) / 8.0;
+  return select(vec3f(along, center, across), vec3f(across, center, along), channel(p + vec2i(1, 0)) == 0u);
+}
+
+// Normalized convolution for larger RGB mosaics. Preserve the measured channel and
+// reconstruct missing colors from nearby sites, weighted by inverse fourth-power distance.
+fn demosaicPattern(p: vec2i, size: vec2i) -> vec3f {
+  var sum = vec3f(0.0);
+  var weight = vec3f(0.0);
+  for (var y = -3; y <= 3; y++) {
+    for (var x = -3; x <= 3; x++) {
+      let q = p + vec2i(x, y);
+      if (any(q < vec2i(0)) || any(q >= size)) { continue; }
+      let c = channel(q);
+      let rgb = select(c, 1u, c == 3u);
+      let distance2 = f32(max(x * x + y * y, 1));
+      let w = 1.0 / (distance2 * distance2);
+      sum[rgb] += sample(q, size) * w;
+      weight[rgb] += w;
+    }
+  }
+  var color = sum / max(weight, vec3f(0.00001));
+  let c = channel(p);
+  color[select(c, 1u, c == 3u)] = sample(p, size);
+  return color;
+}
+
+@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {
+  // Map the oriented output pixel back to its sensor position.
+  let size = vec2i(textureDimensions(source));
+  var p = vec2i(position.xy);
+  if ((sensor.flip & 4u) != 0u) { p = p.yx; }
+  if ((sensor.flip & 2u) != 0u) { p.y = size.y - 1 - p.y; }
+  if ((sensor.flip & 1u) != 0u) { p.x = size.x - 1 - p.x; }
+
+  var camera: vec3f;
+  if (sensor.mosaic != 0u) {
+    if (sensor.patternSize.x == 2u) {
+      camera = demosaic(p, size);
+    } else {
+      camera = demosaicPattern(p, size);
+    }
+  } else {
+    let bits = textureLoad(source, p, 0).rgb;
+    let value = select(vec3f(bits), bitcast<vec3f>(bits), sensor.floating != 0u);
+    camera = max(value - sensor.black.rgb, vec3f(0.0))
+      / (vec3f(sensor.white) - sensor.black.rgb) * calibration.gains;
+  }
+
+  // DNG FixVignetteRadial: a polynomial in r² over normalized coordinates.
+  let q = (vec2f(p) + 0.5) * vignette.step + vignette.origin;
+  let r2 = dot(q, q);
+  let k = vignette.coefficients;
+  let gain = 1.0 + r2 * (k.x + r2 * (k.y + r2 * (k.z + r2 * (k.w + r2 * vignette.last))));
+
+  return vec4f(calibration.matrix * camera * gain * calibration.exposure, 1.0);
+}
+
+@group(0) @binding(5) var cameraSource: texture_2d<f32>;
+
+// Cached X-Trans camera RGB: subsequent edits only apply per-pixel linear transforms.
+@fragment fn fs_camera(@builtin(position) position: vec4f) -> @location(0) vec4f {
+  let camera = textureLoad(cameraSource, vec2i(position.xy), 0).rgb;
+  return vec4f(calibration.matrix * (camera * calibration.gains) * calibration.exposure, 1.0);
+}
+
+// One triangle covering the whole destination.
+@vertex fn vs_main(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {
+  let points = array<vec2f, 3>(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3));
+  return vec4f(points[index], 0, 1);
+}
+`;
+
+// src/develop/gpu.ts
+async function createPipeline(device) {
+  const module = device.createShaderModule({ code: develop_default });
+  function create(entryPoint) {
+    return device.createRenderPipelineAsync({
+      layout: "auto",
+      vertex: { module, entryPoint: "vs_main" },
+      fragment: { module, entryPoint, targets: [{ format: "rgba16float" }] },
+      primitive: { topology: "triangle-list" }
+    });
+  }
+  const [sensor, camera] = await Promise.all([
+    create("fs_main"),
+    create("fs_camera")
+  ]);
+  return { sensor, camera };
+}
+function createUniform(device, data) {
+  const buffer = device.createBuffer({
+    size: data.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(buffer, 0, data);
+  return buffer;
+}
+function createSensorUniform(device, metadata) {
+  const data = new ArrayBuffer(48);
+  const floats = new Float32Array(data);
+  const integers = new Uint32Array(data);
+  floats.set(metadata.black);
+  integers[4] = metadata.cfaSize ?? 2;
+  floats[8] = metadata.white;
+  integers[9] = metadata.flip;
+  integers[10] = Number(metadata.cfa !== null);
+  integers[11] = Number(metadata.sampleFormat === "float32");
+  return createUniform(device, data);
+}
+function createVignetteUniform(device, metadata) {
+  const data = new Float32Array(12);
+  data.set(metadata.vignette.slice(0, 4));
+  data.set(metadata.vignette.slice(5, 9), 4);
+  data[8] = metadata.vignette[4];
+  return createUniform(device, data.buffer);
+}
+function createGpuSource(device, pixels, pipeline) {
+  const { data, ...metadata } = pixels;
+  const mosaic = metadata.cfa !== null;
+  const size = metadata.flip & 4 ? [metadata.size[1], metadata.size[0]] : metadata.size;
+  const floating = metadata.sampleFormat === "float32";
+  const integerFormat = mosaic ? "r16uint" : "rgba16uint";
+  const format = floating ? "rgba32uint" : integerFormat;
+  const texture = device.createTexture({
+    size: metadata.size,
+    format,
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT
+  });
+  const uniforms = [];
+  const passes = new Set;
+  let cameraTexture;
+  let closed = false;
+  function dispose() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    for (const close of passes) {
+      close();
+    }
+    for (const buffer of uniforms) {
+      buffer.destroy();
+    }
+    texture.destroy();
+    cameraTexture?.destroy();
+  }
+  function createPass(renderPipeline, entries) {
+    if (closed) {
+      throw Error("RAW source is closed.");
+    }
+    const calibrationData = new Float32Array(16);
+    const calibrationBuffer = createUniform(device, calibrationData.buffer);
+    const group = device.createBindGroup({
+      layout: renderPipeline.getBindGroupLayout(0),
+      entries: [
+        ...entries,
+        { binding: 2, resource: { buffer: calibrationBuffer } }
+      ]
+    });
+    let disposed = false;
+    function close() {
+      disposed = true;
+      calibrationBuffer.destroy();
+      passes.delete(close);
+    }
+    passes.add(close);
+    return {
+      render(options) {
+        if (disposed || closed) {
+          throw Error("RAW development pass is closed.");
+        }
+        const { destination, calibration, exposure = 0 } = options;
+        if (destination.format !== "rgba16float" || destination.width !== size[0] || destination.height !== size[1]) {
+          throw Error("RAW destination must be an rgba16float texture matching the oriented source size.");
+        }
+        calibrationData.set(calibration.gains);
+        calibrationData[3] = 2 ** exposure;
+        for (let column = 0;column < 3; column++) {
+          calibrationData.set(calibration.matrix.slice(column * 3, column * 3 + 3), 4 + column * 4);
+        }
+        device.queue.writeBuffer(calibrationBuffer, 0, calibrationData);
+        const encoder = options.encoder ?? device.createCommandEncoder();
+        const pass = encoder.beginRenderPass({
+          colorAttachments: [
+            {
+              view: destination.createView(),
+              loadOp: "clear",
+              storeOp: "store"
+            }
+          ]
+        });
+        pass.setPipeline(renderPipeline);
+        pass.setBindGroup(0, group);
+        pass.draw(3);
+        pass.end();
+        if (!options.encoder) {
+          device.queue.submit([encoder.finish()]);
+        }
+      },
+      dispose: close
+    };
+  }
+  try {
+    if (data.byteLength > device.limits.maxBufferSize) {
+      const encoder = device.createCommandEncoder();
+      encoder.beginRenderPass({
+        colorAttachments: [
+          { view: texture.createView(), loadOp: "clear", storeOp: "store" }
+        ]
+      }).end();
+      device.queue.submit([encoder.finish()]);
+    }
+    const bytesPerPixel = data.BYTES_PER_ELEMENT * (mosaic ? 1 : 4);
+    const bytesPerRow = metadata.size[0] * bytesPerPixel;
+    const rowsPerUpload = Math.floor(device.limits.maxBufferSize / (Math.ceil(bytesPerRow / 256) * 256));
+    for (let y = 0;y < metadata.size[1]; y += rowsPerUpload) {
+      const height = Math.min(rowsPerUpload, metadata.size[1] - y);
+      device.queue.writeTexture({ texture, origin: [0, y] }, data.buffer, { offset: data.byteOffset + y * bytesPerRow, bytesPerRow }, [metadata.size[0], height]);
+    }
+    const sensor = createSensorUniform(device, metadata);
+    uniforms.push(sensor);
+    const pattern = new Uint32Array(36);
+    pattern.set(metadata.cfa ?? []);
+    const patternBuffer = createUniform(device, pattern.buffer);
+    uniforms.push(patternBuffer);
+    const vignette = createVignetteUniform(device, metadata);
+    uniforms.push(vignette);
+    const sensorEntries = [
+      { binding: 0, resource: texture.createView() },
+      { binding: 1, resource: { buffer: sensor } },
+      { binding: 3, resource: { buffer: vignette } },
+      { binding: 4, resource: { buffer: patternBuffer } }
+    ];
+    if (mosaic && (metadata.cfaSize ?? 2) > 2) {
+      cameraTexture = device.createTexture({
+        size,
+        format: "rgba16float",
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+      });
+      const prepare = createPass(pipeline.sensor, sensorEntries);
+      prepare.render({
+        destination: cameraTexture,
+        calibration: {
+          gains: [1, 1, 1],
+          matrix: [1, 0, 0, 0, 1, 0, 0, 0, 1]
+        }
+      });
+      prepare.dispose();
+    }
+    return {
+      texture,
+      metadata,
+      size,
+      createDevelopPass() {
+        if (cameraTexture) {
+          return createPass(pipeline.camera, [
+            { binding: 5, resource: cameraTexture.createView() }
+          ]);
+        }
+        return createPass(pipeline.sensor, sensorEntries);
+      },
+      dispose
+    };
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+}
+
+// src/tiff/upload.wgsl
+var upload_default = `// Interleaved TIFF samples in, linear Rec.2020 with straight alpha out, one row band per dispatch.
+
+struct Params {
+  width: u32,
+  height: u32,
+  channels: u32,
+  bytes: u32,        // per sample
+  bits: u32,         // per sample; zero for float
+  orientation: u32,  // TIFF orientation tag, 1 to 8
+  photometric: u32,  // 0 white is zero, 1 black is zero, 2 RGB
+  alpha: u32,        // 1 when the extra sample is associated (premultiplied) alpha
+  rowBytes: u32,
+  startRow: u32,     // first image row in this band
+  rows: u32,         // rows in this band
+  bigEndian: u32,
+  matrix: mat3x3f,
+}
+
+@group(0) @binding(0) var<storage, read> source: array<u32>;
+@group(0) @binding(1) var<storage, read> curves: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+@group(0) @binding(3) var output: texture_storage_2d<rgba16float, write>;
+
+// One sample at a byte offset, normalized to 0..1 for integers and left as is for floats.
+fn sample(offset: u32) -> f32 {
+  var word = source[offset / 4u];
+  if params.bigEndian == 1u {
+    if params.bytes == 2u { word = ((word & 0x00ff00ffu) << 8u) | ((word & 0xff00ff00u) >> 8u); }
+    if params.bytes == 4u { word = (word << 24u) | ((word & 0xff00u) << 8u) | ((word >> 8u) & 0xff00u) | (word >> 24u); }
+  }
+  if params.bits == 0u { return bitcast<f32>(word); }
+  var value = word;
+  if params.bytes < 4u { value = (word >> ((offset % 4u) * 8u)) & ((1u << (params.bytes * 8u)) - 1u); }
+  return f32(value) / (exp2(f32(params.bits)) - 1.0);
+}
+
+// Transfer curve over 0..1; samples outside keep their distance, so HDR and negative values pass through.
+fn transfer(value: f32, channel: u32) -> f32 {
+  let last = arrayLength(&curves) / 3u - 1u;
+  let bounded = clamp(value, 0.0, 1.0);
+  let position = bounded * f32(last);
+  let low = min(u32(position), last - 1u);
+  let base = channel * (last + 1u) + low;
+  return mix(curves[base], curves[base + 1u], position - f32(low)) + (value - bounded);
+}
+
+// Where a stored pixel lands after the orientation tag.
+fn oriented(p: vec2u) -> vec2u {
+  let w = params.width - 1u;
+  let h = params.height - 1u;
+  switch params.orientation {
+    case 2u: { return vec2u(w - p.x, p.y); }
+    case 3u: { return vec2u(w - p.x, h - p.y); }
+    case 4u: { return vec2u(p.x, h - p.y); }
+    case 5u: { return p.yx; }
+    case 6u: { return vec2u(h - p.y, p.x); }
+    case 7u: { return vec2u(h - p.y, w - p.x); }
+    case 8u: { return vec2u(p.y, w - p.x); }
+    default: { return p; }
+  }
+}
+
+@compute @workgroup_size(16, 16) fn main(@builtin(global_invocation_id) id: vec3u) {
+  if id.x >= params.width || id.y >= params.rows { return; }
+  let offset = id.y * params.rowBytes + id.x * params.channels * params.bytes;
+
+  // Gray replicates its single sample; RGB reads three.
+  var rgb = vec3f(sample(offset));
+  var colors = 1u;
+  if params.photometric == 2u {
+    colors = 3u;
+    rgb = vec3f(rgb.r, sample(offset + params.bytes), sample(offset + 2u * params.bytes));
+  }
+  var alpha = 1.0;
+  if params.channels > colors { alpha = sample(offset + colors * params.bytes); }
+  if params.photometric == 0u { rgb = 1.0 - rgb; }
+  if params.alpha == 1u { rgb /= max(alpha, 0.000001); }
+
+  let linear = vec3f(transfer(rgb.r, 0u), transfer(rgb.g, 1u), transfer(rgb.b, 2u));
+  textureStore(output, oriented(vec2u(id.x, id.y + params.startRow)), vec4f(params.matrix * linear, alpha));
+}
+`;
+
+// src/tiff/upload.ts
+var pipelines = new WeakMap;
+function createFilledBuffer(device, data, usage) {
+  const result = device.createBuffer({
+    size: Math.ceil(data.byteLength / 4) * 4,
+    usage,
+    mappedAtCreation: true
+  });
+  new Uint8Array(result.getMappedRange()).set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+  result.unmap();
+  return result;
+}
+function createParams(pixels, startRow, rows) {
+  const params = new ArrayBuffer(96);
+  const integers = new Uint32Array(params);
+  integers.set(pixels.metadata);
+  integers[9] = startRow;
+  integers[10] = rows;
+  integers[11] = Number(pixels.bigEndian);
+  const floats = new Float32Array(params);
+  for (let column = 0;column < 3; column++) {
+    floats.set(pixels.color.matrix.slice(column * 3, column * 3 + 3), 12 + column * 4);
+  }
+  return new Uint8Array(params);
+}
+async function uploadTiff(device, pixels) {
+  let pending = pipelines.get(device);
+  if (!pending) {
+    pending = device.createComputePipelineAsync({
+      layout: "auto",
+      compute: {
+        module: device.createShaderModule({ code: upload_default }),
+        entryPoint: "main"
+      }
+    }).catch((error) => {
+      pipelines.delete(device);
+      throw error;
+    });
+    pipelines.set(device, pending);
+  }
+  const pipeline = await pending;
+  const { data, metadata, color } = pixels;
+  const [width, height, , , , orientation, , , rowBytes] = metadata;
+  const size = orientation >= 5 ? [height, width] : [width, height];
+  if (size.some((value) => value > device.limits.maxTextureDimension2D)) {
+    throw Error("TIFF exceeds the device texture size limit.");
+  }
+  const rowsPerBand = Math.floor(Math.min(device.limits.maxStorageBufferBindingSize, device.limits.maxBufferSize) / rowBytes);
+  if (!rowsPerBand) {
+    throw Error("TIFF row exceeds the device buffer size limit.");
+  }
+  const texture = device.createTexture({
+    size,
+    format: "rgba16float",
+    usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+  });
+  const curves = createFilledBuffer(device, color.table, GPUBufferUsage.STORAGE);
+  try {
+    for (let y = 0;y < height; y += rowsPerBand) {
+      const rows = Math.min(rowsPerBand, height - y);
+      const source = createFilledBuffer(device, data.subarray(y * rowBytes, (y + rows) * rowBytes), GPUBufferUsage.STORAGE);
+      const params = createFilledBuffer(device, createParams(pixels, y, rows), GPUBufferUsage.UNIFORM);
+      try {
+        const bindings = device.createBindGroup({
+          layout: pipeline.getBindGroupLayout(0),
+          entries: [
+            { binding: 0, resource: { buffer: source } },
+            { binding: 1, resource: { buffer: curves } },
+            { binding: 2, resource: { buffer: params } },
+            { binding: 3, resource: texture.createView() }
+          ]
+        });
+        const encoder = device.createCommandEncoder();
+        const pass = encoder.beginComputePass();
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, bindings);
+        pass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(rows / 16));
+        pass.end();
+        device.queue.submit([encoder.finish()]);
+      } finally {
+        source.destroy();
+        params.destroy();
+      }
+    }
+    return { texture, size, dispose: () => texture.destroy() };
+  } catch (error) {
+    texture.destroy();
+    throw error;
+  } finally {
+    curves.destroy();
+  }
+}
+
+// src/tiff/index.ts
+async function decodeTiff(device, file, { signal } = {}) {
+  if (signal?.aborted) {
+    throw signal.reason;
+  }
+  const worker = new Worker(new URL("./tiff-worker.js", import.meta.url), {
+    type: "module"
+  });
+  const aborted = Promise.withResolvers();
+  const abort = () => aborted.reject(signal?.reason);
+  signal?.addEventListener("abort", abort);
+  try {
+    const module = await Promise.race([compileDecoder(), aborted.promise]);
+    const decoded = new Promise((resolve, reject) => {
+      worker.onmessage = ({ data }) => {
+        if (data.error) {
+          reject(Error(data.error));
+        } else {
+          resolve(data);
+        }
+      };
+      worker.onerror = (event) => {
+        event.preventDefault();
+        reject(Error(event.message || "TIFF decoding worker failed."));
+      };
+      worker.onmessageerror = () => reject(Error("Could not read TIFF worker response."));
+      worker.postMessage({ file, module });
+    });
+    const pixels = await Promise.race([decoded, aborted.promise]);
+    return await uploadTiff(device, pixels);
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    worker.terminate();
+  }
+}
+
+// src/index.ts
+function createRawDecoder(device) {
+  let pipeline;
+  const sources = new Set;
+  let closed = false;
+  function dispose() {
+    closed = true;
+    for (const close of sources) {
+      close();
+    }
+  }
+  device.lost.then(dispose);
+  return {
+    async load(file, { signal } = {}) {
+      if (closed) {
+        throw Error("RAW decoder is closed.");
+      }
+      if (signal?.aborted) {
+        throw signal.reason;
+      }
+      const session = createSession(compileDecoder());
+      let gpuSource;
+      let disposed = false;
+      function close() {
+        disposed = true;
+        signal?.removeEventListener("abort", close);
+        gpuSource?.dispose();
+        session.dispose();
+        sources.delete(close);
+      }
+      sources.add(close);
+      signal?.addEventListener("abort", close);
+      try {
+        pipeline ??= createPipeline(device).catch((error) => {
+          pipeline = undefined;
+          throw error;
+        });
+        const [reply, gpuPipeline] = await Promise.all([
+          session.request(file),
+          pipeline
+        ]);
+        if (disposed) {
+          throw Error("RAW source is closed.");
+        }
+        if (!reply.image) {
+          throw Error("RAW decoder returned no sensor samples.");
+        }
+        if (reply.image.size.some((value) => value > device.limits.maxTextureDimension2D)) {
+          throw Error("RAW image exceeds this device's texture size limit.");
+        }
+        gpuSource = createGpuSource(device, reply.image, gpuPipeline);
+        signal?.removeEventListener("abort", close);
+        return {
+          ...gpuSource,
+          asShot: reply.asShot,
+          calibration: reply.calibration,
+          async calibrate(balance = reply.asShot) {
+            if (disposed) {
+              throw Error("RAW source is closed.");
+            }
+            if (!Number.isFinite(balance.temperature) || balance.temperature <= 0 || !Number.isFinite(balance.tint)) {
+              throw Error("White balance needs a positive temperature and a finite tint.");
+            }
+            return (await session.request(balance)).calibration;
+          },
+          dispose: close
+        };
+      } catch (error) {
+        close();
+        throw signal?.aborted ? signal.reason : error;
+      }
+    },
+    dispose
+  };
+}
+export {
+  decodeTiff,
+  createRawDecoder
+};