Skip to content

Free open-source image editor for the browser

3.5 KB
Raw Blame
import type { Gpu, Target } from "vgpu";
import { createImageSource, type ImageSource } from "@/core/image";
import { checkHeader } from "./size";
import type { Decoder } from "./types";
import { uploadDecoded } from "./upload";

export type { Target };

type Format = {
  types: string[];
  extensions: string[];
  decode: (gpu: Gpu, file: File) => Promise<ImageSource>;
};

/** A format whose decoder yields 8-bit sRGB-encoded pixels, kept as such on the GPU. */
function pixelFormat(load: () => Promise<Decoder>) {
  return async (gpu: Gpu, file: File) => {
    const decoder = await load();
    const decoded = await decoder(file, gpu.gpu.limits.maxTextureDimension2D);
    const { image, primaries } = uploadDecoded(gpu, decoded);
    return createImageSource(image, { primaries });
  };
}

/** Decodes through the browser once the size its header declares fits. */
async function decodeBrowser(file: Blob, limit: number) {
  await checkHeader(limit, file);
  return createImageBitmap(file);
}

const native = pixelFormat(async () => decodeBrowser);
// An AVIF header lists several images without marking the primary one, so upload checks its size.
const avif = pixelFormat(async () => (file: Blob) => createImageBitmap(file));
const svg = pixelFormat(async () => (await import("./svg")).decodeSvg);
const heic = pixelFormat(async () => (await import("./heic")).decodeHeic);
const tiff = async (gpu: Gpu, file: File) =>
  (await import("./tiff")).decodeTiff(gpu, file);
const raw = async (gpu: Gpu, file: File) =>
  (await import("./raw")).decodeRaw(gpu, file);

const formats: Format[] = [
  {
    types: ["image/x-adobe-dng", "image/dng"],
    extensions: [
      "dng",
      "cr2",
      "cr3",
      "crw",
      "nef",
      "nrw",
      "arw",
      "sr2",
      "srf",
      "raf",
      "orf",
      "ori",
      "rw2",
      "raw",
      "rwl",
      "pef",
      "ptx",
      "srw",
      "3fr",
      "fff",
      "iiq",
      "kdc",
      "dcr",
      "mos",
      "mef",
      "erf",
      "mrw",
      "sti",
      "x3f",
    ],
    decode: raw,
  },
  {
    types: ["image/tiff", "image/x-tiff"],
    extensions: ["tif", "tiff"],
    decode: tiff,
  },
  { types: ["image/png"], extensions: ["png"], decode: native },
  { types: ["image/jpeg"], extensions: ["jpg", "jpeg"], decode: native },
  { types: ["image/gif"], extensions: ["gif"], decode: native },
  { types: ["image/webp"], extensions: ["webp"], decode: native },
  { types: ["image/avif"], extensions: ["avif"], decode: avif },
  { types: ["image/bmp"], extensions: ["bmp"], decode: native },
  { types: ["image/svg+xml"], extensions: ["svg"], decode: svg },
  {
    types: ["image/heic", "image/heif"],
    extensions: ["heic", "heif"],
    decode: heic,
  },
];

/** Matches by MIME type, then by extension for files the OS doesn't type. */
function formatOf(file: File) {
  const extension = file.name.split(".").pop()?.toLowerCase() ?? "";
  return formats.find(
    (f) => f.types.includes(file.type) || f.extensions.includes(extension),
  );
}

/** Types and extensions `decode` accepts, for `<input accept>`. */
export const accept = formats
  .flatMap((f) => [...f.types, ...f.extensions.map((e) => `.${e}`)])
  .join(",");

export const canDecode = (file: File) => formatOf(file) !== undefined;

/** Decodes the file into a GPU target: 8-bit sRGB-encoded in its own primaries, or the working format for RAW and TIFF. */
export async function decode(gpu: Gpu, file: File): Promise<ImageSource> {
  const format = formatOf(file);
  if (!format) {
    throw new Error(`Unsupported image: ${file.name}`);
  }
  return format.decode(gpu, file);
}