Free open-source image editor for the browser
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);
}