@pbk20191/icodec 0.6.5 → 0.6.7

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";
@@ -177,3 +177,5 @@ 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;
+export declare function unloadDecoder(): void;
+export declare function unloadEncoder(): void;

package/lib/jxl.js

@@ -0,0 +1,75 @@
+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");
+}
+export function unloadDecoder() {
+    decoderWASM = undefined;
+}
+export function unloadEncoder() {
+    encoderWASM = undefined;
+}

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

@@ -11,3 +11,4 @@ export declare function loadEncoder(input?: WasmSource): Promise<any>;
 export declare const loadDecoder: typeof loadEncoder;
 export declare function encode(image: ImageDataLike): Uint8Array<ArrayBufferLike>;
 export declare function decode(input: BufferSource): ImageData;
+export declare function unloadCoder(): void;

package/lib/qoi.js

@@ -0,0 +1,22 @@
+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");
+}
+export function unloadCoder() {
+    codecWASM = undefined;
+}

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,7 @@ 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;
+export declare function unloadDecoder(): void;
+export declare function unloadEncoder(): void;

package/lib/webp.js

@@ -0,0 +1,80 @@
+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");
+}
+export function unloadDecoder() {
+    decoderWASM = undefined;
+}
+export function unloadEncoder() {
+    encoderWASM = undefined;
+}

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]
      *
@@ -69,3 +69,5 @@ 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;
+export declare function unloadDecoder(): void;
+export declare function unloadEncoder(): void;

package/lib/wp2.js

@@ -0,0 +1,52 @@
+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");
+}
+export function unloadDecoder() {
+    decoderWASM = undefined;
+}
+export function unloadEncoder() {
+    encoderWASM = undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pbk20191/icodec",
-	"version": "0.6.5",
+	"version": "0.6.7",
 	"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"