@pbk20191/icodec 0.6.5 → 0.6.6

package/lib/avif.d.ts

@@ -1,4 +1,4 @@
-import { ImageDataLike, WasmSource } from "./common.js";
+import { EnumValue, ImageDataLike, WasmSource } from "./common.js";
 export declare enum Subsampling {
     YUV444 = 1,
     YUV422 = 2,
@@ -35,7 +35,7 @@ export interface Options {
      *
      * @default YUV420
      */
-    subsample?: Subsampling;
+    subsample?: EnumValue<typeof Subsampling>;
     /**
      * If true, ignores `tileRowsLog2` and `tileColsLog2` and automatically chooses suitable tiling values.
      *
@@ -72,7 +72,7 @@ export interface Options {
      *
      * @default AVIFTune.Auto
      */
-    tune?: AVIFTune;
+    tune?: EnumValue<typeof AVIFTune>;
     /**
      * Use libsharpyuv for RGB->YUV conversion if needed.
      *

package/lib/avif.js

@@ -0,0 +1,47 @@
+import wasmFactoryEnc from "../dist/avif-enc.js";
+import wasmFactoryDec from "../dist/avif-dec.js";
+import { check, encodeES, loadES } from "./common.js";
+export var Subsampling;
+(function (Subsampling) {
+    Subsampling[Subsampling["YUV444"] = 1] = "YUV444";
+    Subsampling[Subsampling["YUV422"] = 2] = "YUV422";
+    Subsampling[Subsampling["YUV420"] = 3] = "YUV420";
+    Subsampling[Subsampling["YUV400"] = 4] = "YUV400";
+})(Subsampling || (Subsampling = {}));
+export var AVIFTune;
+(function (AVIFTune) {
+    AVIFTune[AVIFTune["Auto"] = 0] = "Auto";
+    AVIFTune[AVIFTune["PSNR"] = 1] = "PSNR";
+    AVIFTune[AVIFTune["SSIM"] = 2] = "SSIM";
+})(AVIFTune || (AVIFTune = {}));
+export const defaultOptions = {
+    quality: 50,
+    qualityAlpha: -1,
+    speed: 6,
+    subsample: Subsampling.YUV420,
+    autoTiling: false,
+    tileColsLog2: 0,
+    tileRowsLog2: 0,
+    chromaDeltaQ: false,
+    sharpness: 0,
+    denoiseLevel: 0,
+    tune: AVIFTune.Auto,
+    sharpYUV: false,
+};
+export const mimeType = "image/avif";
+export const extension = "avif";
+export const bitDepth = [8, 10, 12, 16];
+let encoderWASM;
+let decoderWASM;
+export async function loadEncoder(input) {
+    return encoderWASM ??= await loadES(wasmFactoryEnc, input);
+}
+export async function loadDecoder(input) {
+    return decoderWASM ??= await loadES(wasmFactoryDec, input);
+}
+export function encode(image, options) {
+    return encodeES("AVIF Encode", encoderWASM, defaultOptions, image, options);
+}
+export function decode(input) {
+    return check(decoderWASM.decode(input), "AVIF Decode");
+}

package/lib/common.d.ts

@@ -5,6 +5,7 @@
  * - If is BufferSource, it will be treated as the WASM bytes.
  */
 export type WasmSource = string | BufferSource;
+export type EnumValue<E> = E[Extract<keyof E, string>];
 export declare function loadES(factory: any, source?: WasmSource): any;
 export interface ImageDataLike {
     width: number;

package/lib/common.js

@@ -0,0 +1,64 @@
+export function loadES(factory, source) {
+    return typeof source === "string"
+        ? factory({ locateFile: () => source })
+        : factory({ wasmBinary: source });
+}
+export function toBitDepth(image, value) {
+    const { data, width, height, depth = 8 } = image;
+    if (value === depth) {
+        return image;
+    }
+    const pixels = width * height * 4;
+    const dist = value === 8
+        ? new Uint8ClampedArray(pixels)
+        : new Uint16Array(pixels);
+    const view = depth === 8
+        ? data
+        : new Uint16Array(data.buffer, data.byteOffset);
+    const from = (1 << depth) - 1;
+    const to = (1 << value) - 1;
+    for (let i = 0; i < pixels; i++) {
+        dist[i] = view[i] / from * to + 0.5;
+    }
+    const nd = new Uint8ClampedArray(dist.buffer, dist.byteOffset, dist.byteLength);
+    return _icodec_ImageData(nd, width, height, value);
+}
+/**
+ * Node does not have `ImageData` class, so we define a pure version.
+ */
+export class PureImageData {
+    data;
+    width;
+    height;
+    depth;
+    constructor(data, width, height, depth = 8) {
+        this.data = data;
+        this.width = width;
+        this.height = height;
+        this.depth = depth;
+    }
+}
+// @ts-expect-error
+PureImageData.prototype.colorSpace = "srgb";
+export function encodeES(name, wasm, defaults, image, options) {
+    options = { ...defaults, ...options };
+    const { data, width, height } = image;
+    options.bitDepth = image.depth ?? 8;
+    const result = wasm.encode(data, width, height, options);
+    if (result instanceof Error) {
+        throw result;
+    }
+    return check(result, name);
+}
+export function check(value, hint) {
+    if (typeof value === "string") {
+        throw new Error(`${hint}: ${value}`);
+    }
+    if (value instanceof Error) {
+        throw value;
+    }
+    if (value)
+        return value;
+    else
+        throw new Error(hint + " failed");
+}

package/lib/heic.js

@@ -0,0 +1,43 @@
+import wasmFactoryEnc from "../dist/heic-enc.js";
+import wasmFactoryDec from "../dist/heic-dec.js";
+import { check, encodeES, loadES } from "./common.js";
+export const Presets = ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo"];
+export const Subsampling = ["420", "422", "444"];
+export const Tune = ["psnr", "ssim", "grain", "fastdecode"];
+export const defaultOptions = {
+    quality: 50,
+    lossless: false,
+    preset: "slow",
+    tune: "ssim",
+    tuIntraDepth: 2,
+    complexity: 50,
+    chroma: "420",
+    sharpYUV: false,
+};
+export const mimeType = "image/heic";
+export const extension = "heic";
+export const bitDepth = [8, 10, 12];
+let encoderWASM;
+let decoderWASM;
+export async function loadEncoder(input) {
+    return encoderWASM ??= await loadES(wasmFactoryEnc, input);
+}
+export async function loadDecoder(input) {
+    return decoderWASM ??= await loadES(wasmFactoryDec, input);
+}
+export function encode(image, options) {
+    const new_encode = (...args) => {
+        const holder = {};
+        encoderWASM.encode(...args, holder);
+        if (holder.error) {
+            return holder.error;
+        }
+        if (holder.success) {
+            return holder.success;
+        }
+    };
+    return encodeES("HEIC Encode", { encode: new_encode }, defaultOptions, image, options);
+}
+export function decode(input) {
+    return check(decoderWASM.decode(input), "HEIC Decode");
+}

package/lib/index.js

@@ -0,0 +1,19 @@
+import { PureImageData, toBitDepth } from "./common.js";
+export { toBitDepth };
+export * as avif from "./avif.js";
+export * as png from "./png.js";
+export * as jpeg from "./jpeg.js";
+export * as jxl from "./jxl.js";
+export * as webp from "./webp.js";
+export * as heic from "./heic.js";
+export * as qoi from "./qoi.js";
+export * as wp2 from "./wp2.js";
+globalThis._icodec_ImageData = (data, w, h, depth) => {
+    if (depth === 8) {
+        return new ImageDataEx(data, w, h);
+    }
+    return new PureImageData(data, w, h, depth);
+};
+class ImageDataEx extends ImageData {
+    depth = 8;
+}

package/lib/jpeg.d.ts

@@ -1,4 +1,4 @@
-import { ImageDataLike, WasmSource } from "./common.js";
+import { EnumValue, ImageDataLike, WasmSource } from "./common.js";
 export declare const enum ColorSpace {
     GRAYSCALE = 1,
     RGB = 2,
@@ -55,13 +55,13 @@ export interface Options {
     /**
      * @default ColorSpace.YCbCr
      */
-    colorSpace?: ColorSpace;
+    colorSpace?: EnumValue<typeof ColorSpace>;
     /**
      * Select the predefined quantization table to use.
      *
      * @default Quantization.ImageMagick
      */
-    quantTable?: Quantization;
+    quantTable?: EnumValue<typeof Quantization>;
     /**
      * use scans in trellis optimization.
      *

package/lib/jpeg.js

@@ -0,0 +1,34 @@
+import wasmFactoryEnc from "../dist/mozjpeg.js";
+import { check, encodeES, loadES } from "./common.js";
+export const defaultOptions = {
+    quality: 75,
+    baseline: false,
+    arithmetic: false,
+    progressive: true,
+    optimizeCoding: true,
+    smoothing: 0,
+    colorSpace: 3 /* ColorSpace.YCbCr */,
+    quantTable: 3 /* Quantization.ImageMagick */,
+    trellisMultipass: false,
+    trellisOptZero: false,
+    trellisOptTable: false,
+    trellisLoops: 1,
+    autoSubsample: true,
+    chromaSubsample: 2,
+    separateChromaQuality: false,
+    chromaQuality: 75,
+};
+export const bitDepth = [8];
+export const mimeType = "image/jpeg";
+export const extension = "jpg";
+let codecWASM;
+export async function loadEncoder(input) {
+    return codecWASM = await loadES(wasmFactoryEnc, input);
+}
+export const loadDecoder = loadEncoder;
+export function encode(image, options) {
+    return encodeES("JPEG Encode", codecWASM, defaultOptions, image, options);
+}
+export function decode(input) {
+    return check(codecWASM.decode(input), "JPEG Decode");
+}

package/lib/jxl.d.ts

@@ -1,10 +1,10 @@
-import { ImageDataLike, WasmSource } from "./common.js";
-export declare const enum Override {
+import { EnumValue, ImageDataLike, WasmSource } from "./common.js";
+export declare enum Override {
     Default = -1,
     False = 0,
     True = 1
 }
-export declare const enum Predictor {
+export declare enum Predictor {
     Default = -1,
     Zero = 0,
     Left = 1,
@@ -167,7 +167,7 @@ export interface Options {
      *
      * @default Predictor.Default,
      */
-    modularPredictor?: Predictor;
+    modularPredictor?: EnumValue<typeof Predictor>;
 }
 export declare const defaultOptions: Required<Options>;
 export declare const mimeType = "image/jxl";

package/lib/jxl.js

@@ -0,0 +1,69 @@
+import wasmFactoryEnc from "../dist/jxl-enc.js";
+import wasmFactoryDec from "../dist/jxl-dec.js";
+import { check, encodeES, loadES } from "./common.js";
+// Tristate bool value, `Default` means encoder chooses.
+export var Override;
+(function (Override) {
+    Override[Override["Default"] = -1] = "Default";
+    Override[Override["False"] = 0] = "False";
+    Override[Override["True"] = 1] = "True";
+})(Override || (Override = {}));
+export var Predictor;
+(function (Predictor) {
+    Predictor[Predictor["Default"] = -1] = "Default";
+    Predictor[Predictor["Zero"] = 0] = "Zero";
+    Predictor[Predictor["Left"] = 1] = "Left";
+    Predictor[Predictor["Top"] = 2] = "Top";
+    Predictor[Predictor["Average0"] = 3] = "Average0";
+    Predictor[Predictor["Select"] = 4] = "Select";
+    Predictor[Predictor["Gradient"] = 5] = "Gradient";
+    Predictor[Predictor["Weighted"] = 6] = "Weighted";
+    Predictor[Predictor["TopRight"] = 7] = "TopRight";
+    Predictor[Predictor["TopLeft"] = 8] = "TopLeft";
+    Predictor[Predictor["LeftLeft"] = 9] = "LeftLeft";
+    Predictor[Predictor["Average1"] = 10] = "Average1";
+    Predictor[Predictor["Average2"] = 11] = "Average2";
+    Predictor[Predictor["Average3"] = 12] = "Average3";
+    Predictor[Predictor["Average4"] = 13] = "Average4";
+    // The following predictors are encoder-only.
+    Predictor[Predictor["Best"] = 14] = "Best";
+    Predictor[Predictor["Variable"] = 15] = "Variable";
+})(Predictor || (Predictor = {}));
+export const defaultOptions = {
+    lossless: false,
+    quality: 75,
+    alphaQuality: 100,
+    effort: 7,
+    brotliEffort: -1,
+    epf: -1,
+    gaborish: -1,
+    responsive: -1,
+    progressiveDC: -1,
+    progressiveAC: -1,
+    qProgressiveAC: -1,
+    decodingSpeed: 0,
+    photonNoiseIso: 0,
+    modular: false,
+    lossyPalette: false,
+    paletteColors: -1,
+    iterations: -1,
+    modularColorspace: -1,
+    modularPredictor: Predictor.Default,
+};
+export const mimeType = "image/jxl";
+export const extension = "jxl";
+export const bitDepth = [8, 9, 10, 11, 12, 13, 14, 15, 16];
+let encoderWASM;
+let decoderWASM;
+export async function loadEncoder(input) {
+    return encoderWASM ??= await loadES(wasmFactoryEnc, input);
+}
+export async function loadDecoder(input) {
+    return decoderWASM ??= await loadES(wasmFactoryDec, input);
+}
+export function encode(image, options) {
+    return encodeES("JXL Encode", encoderWASM, defaultOptions, image, options);
+}
+export function decode(input) {
+    return check(decoderWASM.decode(input), "JXL Decode");
+}

package/lib/png.js

@@ -0,0 +1,45 @@
+import wasmFactory, { optimize, png_to_rgba, quantize } from "../dist/pngquant.js";
+import { toBitDepth } from "./common.js";
+export const defaultOptions = {
+    speed: 4,
+    quality: 75,
+    colors: 256,
+    dithering: 1,
+    level: 3,
+    interlace: false,
+    quantize: true,
+    bit_depth: 8,
+};
+export const bitDepth = [8, 16];
+export const mimeType = "image/png";
+export const extension = "png";
+export const loadEncoder = (module_or_path) => wasmFactory({ module_or_path });
+export const loadDecoder = loadEncoder;
+/**
+ * Reduces the colors used in the image at a slight loss, using a combination
+ * of vector quantization algorithms.
+ *
+ * Can be used before other compression algorithm to boost compression ratio.
+ */
+export function reduceColors(image, options) {
+    options = { ...defaultOptions, ...options };
+    const { data, width, height } = toBitDepth(image, 8);
+    return quantize(data, width, height, { ...defaultOptions, ...options });
+}
+export function encode(image, options) {
+    options = { ...defaultOptions, ...options };
+    if (options.quantize) {
+        image = toBitDepth(image, 8);
+    }
+    const { data, width, height, depth } = image;
+    options.bit_depth = depth;
+    return optimize(data, width, height, { ...defaultOptions, ...options });
+}
+export function decode(input) {
+    const [data, width, depth] = png_to_rgba(input);
+    let height = data.byteLength / width / 4;
+    if (depth === 16) {
+        height /= 2;
+    }
+    return _icodec_ImageData(data, width, height, depth);
+}

package/lib/qoi.js

@@ -0,0 +1,19 @@
+import wasmFactory from "../dist/qoi.js";
+import { check, loadES } from "./common.js";
+export const defaultOptions = undefined;
+export const bitDepth = [8];
+export const mimeType = "image/qoi";
+export const extension = "qoi";
+let codecWASM;
+export async function loadEncoder(input) {
+    return codecWASM = await loadES(wasmFactory, input);
+}
+export const loadDecoder = loadEncoder;
+export function encode(image) {
+    const { data, width, height } = image;
+    const result = codecWASM.encode(data, width, height, undefined);
+    return check(result, "QOI Encode");
+}
+export function decode(input) {
+    return check(codecWASM.decode(input), "QOI Decode");
+}

package/lib/webp.d.ts

@@ -1,15 +1,15 @@
-import { ImageDataLike, WasmSource } from "./common.js";
-export declare const enum Preprocess {
+import { EnumValue, ImageDataLike, WasmSource } from "./common.js";
+export declare enum Preprocess {
     None = 0,
     SegmentSmooth = 1,
     Dithering = 2
 }
-export declare const enum AlphaFiltering {
+export declare enum AlphaFiltering {
     None = 0,
     Fast = 1,
     Best = 2
 }
-export declare const enum WebPPreset {
+export declare enum WebPPreset {
     Default = 0,
     Picture = 1,
     Photo = 2,
@@ -110,7 +110,7 @@ export interface Options {
      *
      * @default Preprocess.None
      */
-    preprocessing?: Preprocess;
+    preprocessing?: EnumValue<typeof Preprocess>;
     /**
      * Turns auto-filter on. This algorithm will spend additional time optimizing the
      * filtering strength to reach a well-balanced quality.
@@ -161,7 +161,7 @@ export interface Options {
      *
      * @default AlphaFiltering.Fast
      */
-    alphaFiltering?: AlphaFiltering;
+    alphaFiltering?: EnumValue<typeof AlphaFiltering>;
     /**
      * Use more accurate and sharper RGB->YUV conversion if needed.
      * Note that this process is slower than the default conversion.
@@ -224,5 +224,5 @@ export declare const extension = "webp";
 export declare function loadEncoder(input?: WasmSource): Promise<any>;
 export declare function loadDecoder(input?: WasmSource): Promise<any>;
 export declare function encode(image: ImageDataLike, options?: Options): Uint8Array<ArrayBufferLike>;
-export declare function preset(config: Options, preset: WebPPreset): Options | null;
+export declare function preset(config: Options, preset: EnumValue<typeof WebPPreset>): Options | null;
 export declare function decode(input: BufferSource): ImageData;

package/lib/webp.js

@@ -0,0 +1,74 @@
+import wasmFactoryEnc from "../dist/webp-enc.js";
+import wasmFactoryDec from "../dist/webp-dec.js";
+import { check, encodeES, loadES } from "./common.js";
+export var Preprocess;
+(function (Preprocess) {
+    Preprocess[Preprocess["None"] = 0] = "None";
+    Preprocess[Preprocess["SegmentSmooth"] = 1] = "SegmentSmooth";
+    Preprocess[Preprocess["Dithering"] = 2] = "Dithering";
+})(Preprocess || (Preprocess = {}));
+export var AlphaFiltering;
+(function (AlphaFiltering) {
+    AlphaFiltering[AlphaFiltering["None"] = 0] = "None";
+    AlphaFiltering[AlphaFiltering["Fast"] = 1] = "Fast";
+    AlphaFiltering[AlphaFiltering["Best"] = 2] = "Best";
+})(AlphaFiltering || (AlphaFiltering = {}));
+export var WebPPreset;
+(function (WebPPreset) {
+    WebPPreset[WebPPreset["Default"] = 0] = "Default";
+    WebPPreset[WebPPreset["Picture"] = 1] = "Picture";
+    WebPPreset[WebPPreset["Photo"] = 2] = "Photo";
+    WebPPreset[WebPPreset["Drawing"] = 3] = "Drawing";
+    WebPPreset[WebPPreset["Icon"] = 4] = "Icon";
+    WebPPreset[WebPPreset["Text"] = 5] = "Text";
+})(WebPPreset || (WebPPreset = {}));
+export const defaultOptions = {
+    lossless: false,
+    nearLossless: 100,
+    quality: 75,
+    targetSize: 0,
+    targetPSNR: 0,
+    method: 4,
+    snsStrength: 50,
+    filterStrength: 60,
+    filterSharpness: 0,
+    filterType: true,
+    segments: 4,
+    pass: 1,
+    sharpYUV: false,
+    preprocessing: Preprocess.None,
+    autofilter: false,
+    partitionLimit: 0,
+    alphaCompression: 1,
+    alphaFiltering: AlphaFiltering.Fast,
+    alphaQuality: 100,
+    exact: false,
+    emulateJpegSize: false,
+    lowMemory: false,
+    // Undocumented options, only for compatibility.
+    partitions: 0,
+    showCompressed: 0,
+    imageHint: 0,
+    threadLevel: 0,
+    useDeltaPalette: 0,
+};
+export const bitDepth = [8];
+export const mimeType = "image/webp";
+export const extension = "webp";
+let encoderWASM;
+let decoderWASM;
+export async function loadEncoder(input) {
+    return encoderWASM ??= await loadES(wasmFactoryEnc, input);
+}
+export async function loadDecoder(input) {
+    return decoderWASM ??= await loadES(wasmFactoryDec, input);
+}
+export function encode(image, options) {
+    return encodeES("Webp Encode", encoderWASM, defaultOptions, image, options);
+}
+export function preset(config, preset) {
+    return encoderWASM.WebPConfigPreset(config, preset);
+}
+export function decode(input) {
+    return check(decoderWASM.decode(input), "Webp Decode");
+}

package/lib/wp2.d.ts

@@ -1,11 +1,11 @@
-import { ImageDataLike, WasmSource } from "./common.js";
-export declare const enum UVMode {
+import { EnumValue, ImageDataLike, WasmSource } from "./common.js";
+export declare enum UVMode {
     UVAdapt = 0,
     UV420 = 1,
     UV444 = 2,
     UVAuto = 3
 }
-export declare const enum Csp {
+export declare enum Csp {
     YCoCg = 0,
     YCbCr = 1,
     Custom = 2,
@@ -51,8 +51,8 @@ export interface Options {
      * @default 50.0
      */
     sns?: number;
-    uvMode?: UVMode;
-    cspType?: Csp;
+    uvMode?: EnumValue<typeof UVMode>;
+    cspType?: EnumValue<typeof Csp>;
     /**
      * error diffusion strength [0=off, 100=max]
      *

package/lib/wp2.js

@@ -0,0 +1,46 @@
+import { check, encodeES, loadES } from "./common.js";
+import wasmFactoryEnc from "../dist/wp2-enc.js";
+import wasmFactoryDec from "../dist/wp2-dec.js";
+export var UVMode;
+(function (UVMode) {
+    UVMode[UVMode["UVAdapt"] = 0] = "UVAdapt";
+    UVMode[UVMode["UV420"] = 1] = "UV420";
+    UVMode[UVMode["UV444"] = 2] = "UV444";
+    UVMode[UVMode["UVAuto"] = 3] = "UVAuto";
+})(UVMode || (UVMode = {}));
+export var Csp;
+(function (Csp) {
+    Csp[Csp["YCoCg"] = 0] = "YCoCg";
+    Csp[Csp["YCbCr"] = 1] = "YCbCr";
+    Csp[Csp["Custom"] = 2] = "Custom";
+    Csp[Csp["YIQ"] = 3] = "YIQ";
+})(Csp || (Csp = {}));
+export const defaultOptions = {
+    quality: 75,
+    alphaQuality: 100,
+    effort: 5,
+    pass: 1,
+    sns: 50,
+    uvMode: UVMode.UVAuto,
+    cspType: Csp.YCoCg,
+    errorDiffusion: 0,
+    useRandomMatrix: false,
+};
+export const bitDepth = [8];
+// WebP 2 will not be released as an image format, but wee need define these properties.
+export const mimeType = "image/webp2";
+export const extension = "wp2";
+let encoderWASM;
+let decoderWASM;
+export async function loadEncoder(input) {
+    return encoderWASM ??= await loadES(wasmFactoryEnc, input);
+}
+export async function loadDecoder(input) {
+    return decoderWASM ??= await loadES(wasmFactoryDec, input);
+}
+export function encode(image, options) {
+    return encodeES("Webp2 Encode", encoderWASM, defaultOptions, image, options);
+}
+export function decode(input) {
+    return check(decoderWASM.decode(input), "Webp2 Decode");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pbk20191/icodec",
-	"version": "0.6.5",
+	"version": "0.6.6",
 	"private": false,
 	"description": "Image encoders & decoders built with WebAssembly",
 	"license": "MIT",
@@ -12,7 +12,7 @@
 	"type": "module",
 	"scripts": {
 		"wasm": "node scripts/build.js",
-		"types": "tsc --emitDeclarationOnly -p tsconfig.json",
+		"types": "tsc -p tsconfig.json --emitDeclarationOnly && tsc -p tsconfig.json",
 		"build": "npm run wasm && npm run types",
 		"test-convert": "tsx test/test-convert.js",
 		"demo": "node scripts/start-demo.js"