Skip to content

Free open-source image editor for the browser

10.6 KB
Raw Blame
import { expect, mock, test } from "bun:test";
import type { Target } from "vgpu";
import {
  frame,
  getMockGPUDeviceInstrumentation,
  init,
  target,
} from "vgpu/mock";
import { createImageLayer, createLayer, createMask } from "@/app/editor/layers";
import { createEditorRenderer as createRenderer } from "@/app/editor/renderer";
import { createDocument, createResources } from "@/core/document";
import { createImageSource } from "@/core/image";
import { imageFrame } from "@/core/image/frame";
import {
  createDisplay,
  createRenderGraph,
  input,
  pipeline,
} from "@/core/renderer";
import { setAdjustments } from "@/features/adjustments/edits";
import { defaultAdjustments } from "@/features/adjustments/model";
import { unsharpMask } from "@/features/details/unsharp-mask";
import { addLayer } from "@/features/layers/edits";
import { defaultGradient } from "@/features/layers/gradient";
import { setToneCurve } from "@/features/tone-curves/edits";
import { setWhiteBalance } from "@/features/white-balance/edits";

test("RAW edits coalesce, recover from failure, and retain an exporting source after document replacement", async () => {
  const gpu = await init();
  const image = target(gpu, { size: [8, 8], format: "rgba16float" });
  const asShot = { temperature: 5000, tint: 10 };
  const requests: ReturnType<typeof Promise.withResolvers<void>>[] = [];
  const outputs: Target[] = [];
  const started = Promise.withResolvers<void>();
  const close = mock(() => {});
  const develop = mock(() => {
    requests.push(Promise.withResolvers<void>());
    started.resolve();
    return requests[requests.length - 1].promise;
  });
  const source = createImageSource(image, {
    raw: {
      asShot,
      createPass() {
        const output = target(gpu, { size: image.size, format: image.format });
        outputs.push(output);
        return {
          prepare: ({ temperature }) =>
            temperature === asShot.temperature ? Promise.resolve() : develop(),
          render: () => output,
          dispose: () => output.color.dispose(),
        };
      },
      dispose: close,
    },
  });
  const resources = createResources();
  const id = resources.add(new File([], "photo.nef"), source);
  const layers = [createImageLayer(id, "Photo", asShot)] as const;
  const document = createDocument(
    { frame: imageFrame(image.size), layers },
    resources,
  );
  const preview = createRenderer(gpu, source);
  const exported = createRenderer(gpu, source);
  const notify = mock(() => {});
  preview.subscribe(notify);
  const render = () => preview.update(document.scene.getState());
  // An edit in the same tick as the initial render must not be lost.
  const initial = render();
  setWhiteBalance(document, { temperature: 2000 });
  render();
  await started.promise;
  setWhiteBalance(document, { temperature: 3000 });
  render();
  setWhiteBalance(document);
  render();
  requests[0].resolve();
  await initial;
  // Only the first edit developed; the ones queued behind it collapsed into the last.
  expect(develop).toHaveBeenCalledTimes(1);
  expect(notify).toHaveBeenCalledTimes(2);
  document.history.undo();
  const failed = render();
  requests[1].reject(Error("Decode failure"));
  await expect(failed).rejects.toThrow("Decode failure");
  const superseded = render();
  setWhiteBalance(document);
  render();
  requests[2].reject(Error("Superseded failure"));
  await superseded;
  setWhiteBalance(document, { temperature: 6500 });
  const recovered = render();
  requests[3].resolve();
  await recovered;
  expect(() => setWhiteBalance(document, { temperature: NaN })).toThrow(
    "Invalid",
  );
  const exporting = exported.update(document.scene.getState());
  preview.dispose();
  document.dispose();
  expect(close).not.toHaveBeenCalled();
  requests[4].resolve();
  await exporting;
  expect(exported.outputImage().size).toEqual([8, 8]);
  exported.dispose();
  expect(close).toHaveBeenCalledTimes(1);
  for (const destroyed of [image, ...outputs]) {
    expect(() => destroyed.color.view).toThrow("destroyed");
  }
  gpu.dispose();
});

test.each([1, 16])(
  "unsharp mask at reduction %s bypasses zero and shares graph storage",
  async (reduction) => {
    const gpu = await init();
    const source = target(gpu, { size: [127, 65], format: "rgba16float" });
    const graph = createRenderGraph(gpu);
    const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
    const radius = reduction === 1 ? 1 : 64;
    const render = (amount: number) =>
      graph.render(
        [
          pipeline(input(source), [
            unsharpMask("detail", amount / 200, radius, reduction),
          ]),
        ],
        { set: 1, kept: [] },
      )[0];
    expect(render(0)).toBe(source);
    expect(calls.createRenderPipeline ?? 0).toBe(0);
    const filtered = render(100);
    expect(filtered).not.toBe(source);
    expect(filtered.size).toEqual(source.size);
    expect(graph.inspect().textures).toHaveLength(reduction === 1 ? 2 : 3);
    const pipelines = calls.createRenderPipeline;
    expect(render(-100)).toBe(filtered);
    expect(render(25)).toBe(filtered);
    expect(calls.createRenderPipeline).toBe(pipelines);
    expect(render(0)).toBe(source);
    expect(graph.inspect().textures).toHaveLength(0);
    graph.dispose();
    source.color.dispose();
    gpu.dispose();
  },
);

test("rendering follows grouped edits and undo, reuses pipelines, and releases owned targets", async () => {
  const gpu = await init();
  const source = target(gpu, { size: [32, 16], format: "rgba16float" });
  const canvas = Object.assign(target(gpu, { size: [64, 32] }), { dpr: 2 });
  const adjustments = { ...defaultAdjustments, exposure: 0.25 };
  const image = { ...createImageLayer("photo", "Photo"), id: "base" };
  const layers = [{ ...image, adjustments }] as const;
  const document = createDocument({ frame: imageFrame([32, 16]), layers });
  const resource = createImageSource(source);
  const renderer = createRenderer(gpu, resource);
  const notify = mock(() => {});
  const detach = renderer.subscribe(notify);
  const unsubscribe = document.scene.subscribe((scene) =>
    renderer.update(scene),
  );
  const display = createDisplay(gpu);
  const draw = () =>
    frame(gpu, (frame) =>
      display(frame, canvas, renderer.outputImage(), {
        view: { pan: [4, 8], zoom: 2 },
      }),
    );
  const passes = () => renderer.inspect().passes;
  renderer.update(document.scene.getState());
  const adjusted = renderer.outputImage();
  document.history.begin();
  setAdjustments(document, { exposure: 0.5 });
  setAdjustments(document, { exposure: 1 });
  setToneCurve(document, [
    { x: 0, y: 0 },
    { x: 0.5, y: 0.7 },
    { x: 1, y: 1 },
  ]);
  document.history.commit();
  const curved = renderer.outputImage();
  expect(curved).not.toBe(adjusted);
  draw();
  const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
  const pipelines = calls.createRenderPipeline;
  expect(pipelines).toBeGreaterThan(0);
  const late = mock(() => {});
  renderer.subscribe(late)();
  expect(late).toHaveBeenCalledTimes(1);
  document.history.undo();
  expect(renderer.outputImage()).toBe(adjusted);
  expect(document.scene.getState().layers[0].adjustments.exposure).toBe(0.25);
  document.history.redo();
  const curves = ["layer/base/exposure", "layer/base/curves"];
  expect(passes()).toEqual(curves);
  document.history.begin();
  setToneCurve(document);
  expect(renderer.outputImage()).toBe(adjusted);
  document.history.cancel();
  expect(passes()).toEqual(curves);
  draw();
  expect(calls.createRenderPipeline).toBe(pipelines);
  detach();
  const beforeInput = document.scene.getState();
  const base = beforeInput.layers[0];
  const exposure = { ...createLayer("exposure"), id: "exposure" };
  document.edit({
    ...beforeInput,
    layers: [{ ...base, children: [exposure, ...base.children] }],
  });
  await renderer.update(document.scene.getState(), "base");
  expect(renderer.inputImage("base")).toBeDefined();
  expect(renderer.inputImage("base")).not.toBe(renderer.outputImage());
  // The curve's input is planned first, so the image it reads is let go once the curve has read it.
  expect(passes()).toEqual([
    "layer/base/exposure",
    "layer/base/input",
    "layer/base/curves",
    "layer/exposure/exposure",
  ]);
  document.edit(beforeInput);
  expect(renderer.inputImage("base")).toBeUndefined();
  const scene = document.scene.getState();
  const details = { clarity: 50, sharpening: 100, sharpenRadius: 2 };
  document.edit({
    ...scene,
    layers: [...scene.layers, { ...createLayer("details"), details }],
  });
  // Eight renders reached the listener before it detached.
  expect(notify).toHaveBeenCalledTimes(8);
  document.edit({
    ...document.scene.getState(),
    frame: { ...scene.frame, size: [16, 8], angle: 10 },
  });
  const croppedOutput = renderer.outputImage();
  expect(croppedOutput.size).toEqual([16, 8]);
  renderer.dispose();
  for (const owned of [croppedOutput, adjusted, curved]) {
    expect(() => owned.color.view).toThrow("destroyed");
  }
  expect(() => source.color.view).not.toThrow();
  unsubscribe();
  document.dispose();
  resource.dispose();
  canvas.color.dispose();
  display.dispose();
  gpu.dispose();
});

test("a mask without effects of its own adjusts, curves, and mixes in one pass unless inspected", async () => {
  const gpu = await init();
  const source = createImageSource(
    target(gpu, { size: [32, 16], format: "rgba16float" }),
  );
  const layers = [createImageLayer("photo", "Photo")] as const;
  const document = createDocument({ frame: imageFrame([32, 16]), layers });
  const renderer = createRenderer(gpu, source);
  const passes = async (inputId?: string) => {
    await renderer.update(document.scene.getState(), inputId);
    return renderer.inspect().passes;
  };
  const mask = addLayer(document, createMask(defaultGradient([32, 16])));
  expect(await passes()).toEqual([]);
  setAdjustments(document, { exposure: 1 }, mask);
  expect(await passes()).toEqual([`layer/${mask}/mask`]);
  const curve = [
    { x: 0, y: 0 },
    { x: 0.5, y: 0.7 },
    { x: 1, y: 1 },
  ];
  setToneCurve(document, curve, mask);
  expect(await passes()).toEqual([`layer/${mask}/mask`]);
  // Its curve's input reads the adjusted image, which only the separate passes render.
  expect(await passes(mask)).toEqual([
    `layer/${mask}/exposure`,
    `layer/${mask}/input`,
    `layer/${mask}/curves`,
    `layer/${mask}/mix`,
  ]);
  const vignette = addLayer(document, createLayer("vignette"), {
    inside: mask,
  });
  expect(await passes()).toEqual([
    `layer/${mask}/exposure`,
    `layer/${mask}/curves`,
    `layer/${vignette}/vignette`,
    `layer/${mask}/mix`,
  ]);
  renderer.dispose();
  document.dispose();
  source.dispose();
  gpu.dispose();
});