@pbk20191/icodec 0.6.1 → 0.6.3

package/lib/avif.d.ts

@@ -0,0 +1,90 @@
+import { ImageDataLike, WasmSource } from "./common.js";
+export declare enum Subsampling {
+    YUV444 = 1,
+    YUV422 = 2,
+    YUV420 = 3,
+    YUV400 = 4
+}
+export declare enum AVIFTune {
+    Auto = 0,
+    PSNR = 1,
+    SSIM = 2
+}
+export interface Options {
+    /**
+     * [0 - 100], 0 = worst quality, 100 = lossless
+     *
+     * @default 50
+     */
+    quality?: number;
+    /**
+     * As above, but -1 means 'use quality'
+     *
+     * @default -1
+     */
+    qualityAlpha?: number;
+    /**
+     * Range: [-1, 10], 0 = slowest, 10 = fastest, slower should make for a better quality image in less bytes.
+     * A combination of settings are tweaked to simulate this speed range.
+     *
+     * @default 6
+     */
+    speed?: number;
+    /**
+     * Chrome subsampling type.
+     *
+     * @default YUV420
+     */
+    subsample?: Subsampling;
+    /**
+     * If true, ignores `tileRowsLog2` and `tileColsLog2` and automatically chooses suitable tiling values.
+     *
+     * @default false
+     */
+    autoTiling?: boolean;
+    /**
+     * [0 - 6], Creates 2^n tiles in that dimension
+     *
+     * @default 0
+     */
+    tileRowsLog2?: number;
+    tileColsLog2?: number;
+    /**
+     * Extra chroma compression, cannot be used in lossless mode.
+     *
+     * @default false
+     */
+    chromaDeltaQ?: boolean;
+    /**
+     * Bias towards block sharpness in rate-distortion optimization of transform coefficients [0, 7]
+     *
+     * @default 0
+     */
+    sharpness?: number;
+    /**
+     * Amount of noise (from 0 = don't denoise, to 50)
+     *
+     * @default 0
+     */
+    denoiseLevel?: number;
+    /**
+     * Distortion metric tuned with.
+     *
+     * @default AVIFTune.Auto
+     */
+    tune?: AVIFTune;
+    /**
+     * Use libsharpyuv for RGB->YUV conversion if needed.
+     *
+     * @default false
+     */
+    sharpYUV?: boolean;
+}
+export declare const defaultOptions: Required<Options>;
+export declare const mimeType = "image/avif";
+export declare const extension = "avif";
+export declare const bitDepth: number[];
+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 decode(input: BufferSource): ImageData;

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

@@ -0,0 +1,27 @@
+/**
+ * Parameter type of `loadEncoder()` and `loadDecoder()`.
+ *
+ * - If is a string, it's the URL of WASM file to fetch.
+ * - If is BufferSource, it will be treated as the WASM bytes.
+ */
+export type WasmSource = string | BufferSource;
+export declare function loadES(factory: any, source?: WasmSource): any;
+export interface ImageDataLike {
+    width: number;
+    height: number;
+    depth: number;
+    data: Uint8Array | Uint8ClampedArray;
+}
+export declare function toBitDepth(image: ImageDataLike, value: number): ImageDataLike;
+/**
+ * Node does not have `ImageData` class, so we define a pure version.
+ */
+export declare class PureImageData implements ImageDataLike {
+    readonly data: Uint8ClampedArray;
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    constructor(data: Uint8ClampedArray, width: number, height: number, depth?: number);
+}
+export declare function encodeES<T>(name: string, wasm: any, defaults: T, image: ImageDataLike, options?: T): Uint8Array<ArrayBufferLike>;
+export declare function check<T>(value: string | null | T, hint: string): T;

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.d.ts

@@ -0,0 +1,69 @@
+import { ImageDataLike, WasmSource } from "./common.js";
+export declare const Presets: readonly ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo"];
+export declare const Subsampling: readonly ["420", "422", "444"];
+export declare const Tune: readonly ["psnr", "ssim", "grain", "fastdecode"];
+export interface Options {
+    /**
+     * Quality-based VBR [0, 100], it will map to `--crf` parameter of x265.
+     * quality=0   -> crf=50
+     * quality=50  -> crf=25
+     * quality=100 -> crf=0
+     *
+     * @default 50
+     */
+    quality?: number;
+    /**
+     * If true, Bypass transform, quant and loop filters.
+     *
+     * Note: it does not bypass chroma subsampling, you need
+     *       also to set `chroma` to "444" for exact lossless.
+     *
+     * @default false
+     */
+    lossless?: boolean;
+    /**
+     * Trade off performance for compression efficiency.
+     *
+     * @default "slow"
+     */
+    preset?: typeof Presets[number];
+    /**
+     * Tune the settings for a particular type of source or situation.
+     *
+     * @default "ssim"
+     */
+    tune?: typeof Tune[number];
+    /**
+     * Max TU recursive depth for intra CUs。
+     *
+     * [1, 4], default 2.
+     */
+    tuIntraDepth?: number;
+    /**
+     * CPU effort, larger value increases encode time.
+     * Range is [0, 100], but only changes at a few values.
+     *
+     * @default 50
+     */
+    complexity?: number;
+    /**
+     * Specify chroma subsampling method.
+     *
+     * @default "420"
+     */
+    chroma?: typeof Subsampling[number];
+    /**
+     * Use more accurate and sharper RGB->YUV conversion if needed.
+     *
+     * @default false
+     */
+    sharpYUV?: boolean;
+}
+export declare const defaultOptions: Required<Options>;
+export declare const mimeType = "image/heic";
+export declare const extension = "heic";
+export declare const bitDepth: number[];
+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 decode(input: BufferSource): ImageData;

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.d.ts

@@ -0,0 +1,67 @@
+import { ImageDataLike, toBitDepth, WasmSource } from "./common.js";
+export { ImageDataLike, 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";
+declare global {
+    var _icodec_ImageData: (data: Uint8ClampedArray, w: number, h: number, depth: number) => ImageDataLike;
+}
+/**
+ * Provides a uniform type for codec modules that support encoding.
+ *
+ * @example
+ * import { wp2, ICodecModule } from "icodec";
+ *
+ * const encoder: ICodecModule<wp2.Options> = wp2;
+ */
+export interface ICodecModule<T = any> {
+    /**
+     * The default options of `encode` function.
+     */
+    defaultOptions: Required<T>;
+    /**
+     * The MIME type string of the format.
+     */
+    mimeType: string;
+    /**
+     * File extension (without the dot) of this format.
+     */
+    extension: string;
+    /**
+     * List of supported bit depth, from lower to higher.
+     */
+    bitDepth: number[];
+    /**
+     * Load the decoder WASM file, must be called once before decode.
+     * Multiple calls are ignored, and return the first result.
+     *
+     * @param source If pass a string, it's the URL of WASM file to fetch,
+     *               else it will be treated as the WASM bytes.
+     * @return the underlying WASM module, which is not part of
+     *               the public API and can be changed at any time.
+     */
+    loadDecoder(source?: WasmSource): Promise<any>;
+    /**
+     * Convert the image to raw RGBA data.
+     */
+    decode(input: Uint8Array): ImageData;
+    /**
+     * Load the encoder WASM file, must be called once before encode.
+     * Multiple calls are ignored, and return the first result.
+     *
+     * @param source If pass a string, it's the URL of WASM file to fetch,
+     *               else it will be treated as the WASM bytes.
+     * @return the underlying WASM module, which is not part of
+     *               the public API and can be changed at any time.
+     */
+    loadEncoder(source?: WasmSource): Promise<any>;
+    /**
+     * Encode an image with RGBA pixels data.
+     */
+    encode(image: ImageDataLike, options?: T): Uint8Array;
+}

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

@@ -0,0 +1,99 @@
+import { ImageDataLike, WasmSource } from "./common.js";
+export declare enum ColorSpace {
+    GRAYSCALE = 1,
+    RGB = 2,
+    YCbCr = 3
+}
+export declare enum Quantization {
+    JPEG_Annex_K = 0,
+    Flat = 1,
+    MSSIM_Tuned_Kodak = 2,
+    ImageMagick = 3,
+    PSNR_HVS_M_Tuned_Kodak = 4,
+    Klein_Silverstein_Carney = 5,
+    Watson_Taylor_Borthwick = 6,
+    Ahumada_Watson_Peterson = 7,
+    Peterson_Ahumada_Watson = 8
+}
+export interface Options {
+    /**
+     * Compression quality [0..100], 5-95 is most useful range.
+     *
+     * @default 75
+     */
+    quality?: number;
+    /**
+     * Create baseline JPEG file (disable progressive coding).
+     *
+     * @default false
+     */
+    baseline?: boolean;
+    /**
+     * Use arithmetic coding.
+     *
+     * @default false
+     */
+    arithmetic?: boolean;
+    /**
+     * Create progressive JPEG file.
+     *
+     * @default true
+     */
+    progressive?: boolean;
+    /**
+     * Optimize Huffman table (smaller file, but slow compression)
+     *
+     * @default true
+     */
+    optimizeCoding?: boolean;
+    /**
+     * Smooth dithered input (N=1..100 is strength)
+     *
+     * @default 0
+     */
+    smoothing?: number;
+    /**
+     * @default ColorSpace.YCbCr
+     */
+    colorSpace?: ColorSpace;
+    /**
+     * Select the predefined quantization table to use.
+     *
+     * @default Quantization.ImageMagick
+     */
+    quantTable?: Quantization;
+    /**
+     * use scans in trellis optimization.
+     *
+     * @default false
+     */
+    trellisMultipass?: boolean;
+    /**
+     * optimize for sequences of EOB
+     */
+    trellisOptZero?: boolean;
+    /**
+     * optimize quant table in trellis loop.
+     *
+     * @default false
+     */
+    trellisOptTable?: boolean;
+    /**
+     * number of trellis loops.
+     *
+     * @default 1
+     */
+    trellisLoops?: number;
+    autoSubsample?: boolean;
+    chromaSubsample?: number;
+    separateChromaQuality?: boolean;
+    chromaQuality?: number;
+}
+export declare const defaultOptions: Required<Options>;
+export declare const bitDepth: number[];
+export declare const mimeType = "image/jpeg";
+export declare const extension = "jpg";
+export declare function loadEncoder(input?: WasmSource): Promise<any>;
+export declare const loadDecoder: typeof loadEncoder;
+export declare function encode(image: ImageDataLike, options?: Options): Uint8Array<ArrayBufferLike>;
+export declare function decode(input: BufferSource): ImageData;

package/lib/jpeg.js

@@ -0,0 +1,53 @@
+import wasmFactoryEnc from "../dist/mozjpeg.js";
+import { check, encodeES, loadES } from "./common.js";
+export var ColorSpace;
+(function (ColorSpace) {
+    ColorSpace[ColorSpace["GRAYSCALE"] = 1] = "GRAYSCALE";
+    ColorSpace[ColorSpace["RGB"] = 2] = "RGB";
+    ColorSpace[ColorSpace["YCbCr"] = 3] = "YCbCr";
+})(ColorSpace || (ColorSpace = {}));
+// https://github.com/mozilla/mozjpeg/blob/6c9f0897afa1c2738d7222a0a9ab49e8b536a267/jcparam.c#L74
+export var Quantization;
+(function (Quantization) {
+    Quantization[Quantization["JPEG_Annex_K"] = 0] = "JPEG_Annex_K";
+    Quantization[Quantization["Flat"] = 1] = "Flat";
+    Quantization[Quantization["MSSIM_Tuned_Kodak"] = 2] = "MSSIM_Tuned_Kodak";
+    Quantization[Quantization["ImageMagick"] = 3] = "ImageMagick";
+    Quantization[Quantization["PSNR_HVS_M_Tuned_Kodak"] = 4] = "PSNR_HVS_M_Tuned_Kodak";
+    Quantization[Quantization["Klein_Silverstein_Carney"] = 5] = "Klein_Silverstein_Carney";
+    Quantization[Quantization["Watson_Taylor_Borthwick"] = 6] = "Watson_Taylor_Borthwick";
+    Quantization[Quantization["Ahumada_Watson_Peterson"] = 7] = "Ahumada_Watson_Peterson";
+    Quantization[Quantization["Peterson_Ahumada_Watson"] = 8] = "Peterson_Ahumada_Watson";
+})(Quantization || (Quantization = {}));
+export const defaultOptions = {
+    quality: 75,
+    baseline: false,
+    arithmetic: false,
+    progressive: true,
+    optimizeCoding: true,
+    smoothing: 0,
+    colorSpace: ColorSpace.YCbCr,
+    quantTable: 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");
+}