@pbk20191/icodec 0.6.1 → 0.6.2

package/lib/jxl.d.ts

@@ -0,0 +1,179 @@
+import { ImageDataLike, WasmSource } from "./common.js";
+export declare enum Override {
+    Default = -1,
+    False = 0,
+    True = 1
+}
+export declare enum Predictor {
+    Default = -1,
+    Zero = 0,
+    Left = 1,
+    Top = 2,
+    Average0 = 3,
+    Select = 4,
+    Gradient = 5,
+    Weighted = 6,
+    TopRight = 7,
+    TopLeft = 8,
+    LeftLeft = 9,
+    Average1 = 10,
+    Average2 = 11,
+    Average3 = 12,
+    Average4 = 13,
+    Best = 14,
+    Variable = 15
+}
+export interface Options {
+    /**
+     * If true, encode the image without any loss.
+     * Some options are ignored in lossless mode.
+     *
+     * @default false
+     */
+    lossless?: boolean;
+    /**
+     * Quality setting, higher value = higher quality.
+     * 100 = mathematically lossless, 90 = visually lossless.
+     *
+     * Quality values roughly match libjpeg quality.
+     * Recommended range: [68, 96]. Allowed range: [0, 100].
+     *
+     * @default 75
+     */
+    quality?: number;
+    /**
+     * Quality setting of alpha channel.
+     *
+     * @default 100
+     */
+    alphaQuality?: number;
+    /**
+     * Sets encoder effort/speed level without affecting decoding speed.
+     * Valid values are, from faster to slower speed: [1, 9].
+     *
+     * @default 7
+     */
+    effort?: number;
+    /**
+     * Sets brotli encode effort for use in JPEG recompression and compressed metadata boxes (brob).
+     * Can be -1 (default) or 0 (fastest) to 11 (slowest).
+     *
+     * Default is based on the general encode effort in case of JPEG recompression, and 4 for brob boxes.
+     *
+     * @default -1
+     */
+    brotliEffort?: number;
+    /**
+     * Enables or disables progressive encoding for modular mode.
+     *
+     * @default Override.Default
+     */
+    responsive?: Override;
+    /**
+     * Progressive-DC setting. Valid values are: -1, 0, 1, 2.
+     *
+     * @default -1
+     */
+    progressiveDC?: -1;
+    /**
+     * Set the progressive mode for the AC coefficients of VarDCT,
+     * using spectral progression from the DCT coefficients.
+     *
+     * @default Override.Default
+     */
+    progressiveAC?: Override;
+    /**
+     * Set the progressive mode for the AC coefficients of VarDCT,
+     * using quantization of the least significant bits.
+     *
+     * @default Override.Default
+     */
+    qProgressiveAC?: Override;
+    /**
+     * Edge preserving filter level, -1 to 3.
+     * Use -1 for the default (encoder chooses), 0 to 3 to set a strength.
+     *
+     * @default -1
+     */
+    epf?: number;
+    /**
+     * Enables or disables the gaborish filter.
+     *
+     * @default Override.Default
+     */
+    gaborish?: Override;
+    /**
+     * Sets the decoding speed tier for the provided options.
+     *
+     * Minimum is 0 (slowest to decode, best quality/density), and
+     * maximum is 4 (fastest to decode, at the cost of some quality/density).
+     *
+     * @default 0
+     */
+    decodingSpeed?: number;
+    /**
+     * Adds noise to the image emulating photographic film noise, the higher the
+     * given number, the grainier the image will be. As an example, a value of 100
+     * gives low noise whereas a value of 3200 gives a lot of noise.
+     *
+     * @default 0
+     */
+    photonNoiseIso?: number;
+    /**
+     * Enables modular encoding.
+     *
+     * false to enforce VarDCT mode (e.g. for photographic images),
+     * true to enforce modular mode (e.g. for lossless images).
+     *
+     * @default false
+     */
+    modular?: boolean;
+    /**
+     * Enables or disables delta palette, used in modular mode.
+     *
+     * @default false
+     */
+    lossyPalette?: boolean;
+    /**
+     * Use color palette if amount of colors is smaller than or equal to this amount,
+     * or -1 to use the encoder default. Used for modular encoding.
+     *
+     * @default -1
+     */
+    paletteColors?: number;
+    /**
+     * Fraction of pixels used to learn MA trees as a percentage.
+     * Higher values use more memory.
+     *
+     * -1 = default, 0 = no MA and fast decode, 50 = default value, 100 = all.
+     *
+     * @default -1
+     */
+    iterations?: number;
+    /**
+     * Reversible color transform for modular encoding: -1=default, 0-41=RCT
+     * index, e.g. index 0 = none, index 6 = YCoCg.
+     *
+     * If this option is set to a non-default value, the RCT will be globally applied to the whole frame.
+     *
+     * The default behavior is to try several RCTs locally per modular group,
+     * depending on the speed and distance setting.
+     *
+     * @default -1
+     */
+    modularColorspace?: number;
+    /**
+     * Predictor for modular encoding.
+     *
+     * @default Predictor.Default,
+     */
+    modularPredictor?: Predictor;
+}
+export declare const defaultOptions: Required<Options>;
+export declare const mimeType = "image/jxl";
+export declare const extension = "jxl";
+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/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.d.ts

@@ -0,0 +1,72 @@
+import { ImageDataLike, WasmSource } from "./common.js";
+export interface QuantizeOptions {
+    /**
+     * Range: [1, 10], bigger is faster and generate images of lower quality,
+     * but may be useful for real-time generation of images.
+     *
+     * @default 4
+     */
+    speed?: number;
+    /**
+     * Range [0, 100], roughly like JPEG. the max 100 means best effort
+     * If less than 100, the library will try to use fewer colors.
+     *
+     * Images with fewer colors are not always smaller, due to increased dithering it causes.
+     *
+     * @default 75
+     */
+    quality?: number;
+    /**
+     * Limit the number of colors in palette, range: [2, 256].
+     *
+     * @default 256
+     */
+    colors?: number;
+    /**
+     * Range [0, 1] float, set to 1 to get nice smooth image.
+     *
+     * @default 1
+     */
+    dithering?: number;
+}
+export interface Options extends QuantizeOptions {
+    /**
+     * Range [0, 6], bigger means smallest file and slower compression.
+     *
+     * @default 3
+     */
+    level?: number;
+    /**
+     * Is the image made to support progressive loading?
+     * Enabling this feature will increase the size of the results.
+     *
+     * @default false
+     */
+    interlace?: boolean;
+    /**
+     * Lossy compress the image to PNG for significant file size reduction.
+     * Implements the same functionality as [pngquant](https://pngquant.org)
+     *
+     * if set to false, properties from `QuantizeOptions` are ignored.
+     *
+     * @default true
+     */
+    quantize?: boolean;
+    /** @internal */
+    bit_depth?: number;
+}
+export declare const defaultOptions: Required<Options>;
+export declare const bitDepth: number[];
+export declare const mimeType = "image/png";
+export declare const extension = "png";
+export declare const loadEncoder: (module_or_path?: WasmSource) => Promise<any>;
+export declare const loadDecoder: (module_or_path?: WasmSource) => Promise<any>;
+/**
+ * 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 declare function reduceColors(image: ImageDataLike, options?: QuantizeOptions): Uint8Array<ArrayBufferLike>;
+export declare function encode(image: ImageDataLike, options?: Options): Uint8Array<ArrayBufferLike>;
+export declare function decode(input: Uint8Array): ImageDataLike;

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

@@ -0,0 +1,13 @@
+import { ImageDataLike, WasmSource } from "./common.js";
+/**
+ * QOI encoder does not have options, it's always lossless.
+ */
+export type Options = never;
+export declare const defaultOptions: never;
+export declare const bitDepth: number[];
+export declare const mimeType = "image/qoi";
+export declare const extension = "qoi";
+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;

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

@@ -0,0 +1,219 @@
+import { ImageDataLike, WasmSource } from "./common.js";
+export declare enum Preprocess {
+    None = 0,
+    SegmentSmooth = 1,
+    Dithering = 2
+}
+export declare enum AlphaFiltering {
+    None = 0,
+    Fast = 1,
+    Best = 2
+}
+export interface Options {
+    /**
+     * Encode the image without any loss (pixel values of fully transparent area may different).
+     *
+     * @default false
+     */
+    lossless?: boolean;
+    /**
+     * Specify the level of near-lossless image preprocessing. This option adjusts pixel values
+     * to help compressibility, but has minimal impact on the visual quality.
+     * It triggers lossless compression mode automatically.
+     *
+     * The range is 0 (maximum preprocessing) to 100 (no preprocessing).
+     * The typical value is around 60. Note that lossy with -q 100 can at times yield better results.
+     *
+     * @default 100
+     */
+    nearLossless?: number;
+    /**
+     * Specify the compression factor for RGB channels between 0 and 100.
+     *
+     * In case of lossy compression (default), a small factor produces a smaller file
+     * with lower quality.  Best quality is achieved by using a value of 100.
+     *
+     * In case of lossless compression, a small factor enables faster compression speed,
+     * but produces a larger file. Maximum compression is achieved by using a value of 100.
+     *
+     * @default 75
+     */
+    quality?: number;
+    /**
+     * Specify the compression factor for alpha compression between 0 and 100.
+     * Lossless compression of alpha is achieved using a value of 100, while the lower
+     * values result in a lossy compression. The default is 100.
+     *
+     * @default 100
+     */
+    alphaQuality?: number;
+    /**
+     * Specify the compression method to use. This parameter controls the trade off between
+     * encoding speed and the compressed file size and quality.
+     *
+     * Possible values range from 0 to 6. When higher values are used, the encoder will spend more
+     * time inspecting additional encoding possibilities and decide on the quality gain.
+     *
+     * Lower value can result in faster processing at the expense of larger file size and lower quality.
+     *
+     * @default 4
+     */
+    method?: number;
+    /**
+     * Specify the amplitude of the spatial noise shaping. Spatial noise shaping (or sns for short)
+     * refers to a general collection of built-in algorithms used to decide which area of the
+     * picture should use relatively less bits, and where else to better transfer these bits.
+     *
+     * The possible range goes from 0 (algorithm is off) to 100 (the maximal effect).
+     *
+     * @default 50
+     */
+    snsStrength?: number;
+    /**
+     * Specify the strength of the deblocking filter, between 0 (no filtering) and 100 (maximum filtering).
+     * A value of 0 will turn off any filtering. Higher value will increase the strength of the filtering
+     * process applied after decoding the picture. The higher the value the smoother the picture will appear.
+     *
+     * @default 60
+     */
+    filterStrength?: number;
+    /**
+     * Specify the sharpness of the filtering (if used). Range is 0 (sharpest) to 7 (least sharp).
+     *
+     * @default 0
+     */
+    filterSharpness?: number;
+    /**
+     * Use strong filtering (if filtering is being used thanks to the `filter_strength`).
+     *
+     * @default true
+     */
+    filterType?: boolean;
+    /**
+     * Change the number of partitions to use during the segmentation of the sns algorithm.
+     * Range [1, 4], this option has no effect for methods 3 and up, unless `low_memory` is used.
+     *
+     * @default 4
+     */
+    segments?: number;
+    /**
+     * Specify some pre-processing steps. Using a value of 2 will trigger quality-dependent pseudo-random
+     * dithering during RGBA->YUVA conversion (lossy compression only).
+     *
+     * @default Preprocess.None
+     */
+    preprocessing?: Preprocess;
+    /**
+     * Turns auto-filter on. This algorithm will spend additional time optimizing the
+     * filtering strength to reach a well-balanced quality.
+     *
+     * @default 0
+     */
+    autofilter?: boolean;
+    /**
+     * Degrade quality by limiting the number of bits used by some macroblocks.
+     * Range is 0 (no degradation, the default) to 100 (full degradation).
+     * Useful values are usually around 30-70 for moderately large images.
+     *
+     * In the VP8 format, the so-called control partition has a limit of 512k and is used to store
+     * the following information: whether the macroblock is skipped, which segment it belongs to,
+     * whether it is coded as intra 4x4 or intra 16x16 mode, and finally the prediction modes to use
+     * for each of the sub-blocks.
+     *
+     * For a very large image, 512k only leaves room for a few bits per 16x16 macroblock.
+     * The absolute minimum is 4 bits per macroblock. Skip, segment, and mode information can use up almost
+     * all these 4 bits (although the case is unlikely), which is problematic for very large images.
+     *
+     * `partitionLimit` controls how frequently the most bit-costly mode (intra 4x4) will be used.
+     * This is useful in case the 512k limit is reached.
+     *
+     * If using -partition_limit is not enough to meet the 512k constraint, one should use less segments
+     * in order to save more header bits per macroblock. See the `segments` option.
+     *
+     * Note the -m and -q options also influence the encoder's decisions and ability to hit this limit.
+     *
+     * @default 0
+     */
+    partitionLimit?: number;
+    /**
+     * Specify the algorithm used for alpha compression: 0 or 1.
+     * Algorithm 0 denotes no compression, 1 uses WebP lossless format for compression.
+     *
+     * @default 1
+     */
+    alphaCompression?: number;
+    /**
+     * Specify the predictive filtering method for the alpha plane. One of none,
+     * fast or best, in increasing complexity and slowness order.
+     *
+     * Internally, alpha filtering is performed using four possible predictions (none, horizontal, vertical, gradient).
+     * The best mode will try each mode in turn and pick the one which gives the smaller size.
+     *
+     * The fast mode will just try to form an a priori guess without testing all modes.
+     *
+     * @default AlphaFiltering.Fast
+     */
+    alphaFiltering?: AlphaFiltering;
+    /**
+     * Use more accurate and sharper RGB->YUV conversion if needed.
+     * Note that this process is slower than the default conversion.
+     *
+     * @default false
+     */
+    sharpYUV?: boolean;
+    /**
+     * Preserve RGB values in transparent area. The default is off, to help compressibility.
+     */
+    exact?: boolean;
+    /**
+     * Specify a target size (in bytes) to try and reach for the compressed output.
+     * The compressor will make several passes of partial encoding in order to get as close as possible to this target.
+     * If both `target_size` and `target_PSNR` are used, `target_size` value will prevail.
+     */
+    targetSize?: number;
+    /**
+     * Specify a target PSNR (in dB) to try and reach for the compressed output.
+     * The compressor will make several passes of partial encoding in order to get as close as possible to this target.
+     * If both `target_size` and `target_PSNR` are used, `target_size` value will prevail.
+     */
+    targetPSNR?: number;
+    /**
+     * Set a maximum number of passes to use during the dichotomy used by `target_size` or `target_PSNR`.
+     *
+     * Maximum value is 10. If options `target_size` or `target_PSNR` were used, but `pass` wasn't specified,
+     * a default value of '6' passes will be used. If `pass` is specified,
+     * but neither `target_size` nor `target_PSNR` are, a target PSNR of 40dB will be used.
+     *
+     * @default 1
+     */
+    pass?: number;
+    /**
+     * Reduce memory usage of lossy encoding by saving four times the compressed size (typically).
+     * This will make the encoding slower and the output slightly different in size and distortion.
+     *
+     * This flag is only effective for methods 3 and up, and is off by default.
+     *
+     * Note that leaving this flag off will have some side effects on the bitstream:
+     * it forces certain bitstream features like number of partitions (forced to 1).
+     *
+     * @default false
+     */
+    lowMemory?: boolean;
+    /**
+     * Change the internal parameter mapping to better match the expected size of JPEG compression.
+     *
+     * This flag will generally produce an output file of similar size to its JPEG equivalent
+     * (for the same `quality` setting), but with less visual distortion.
+     *
+     * @default false
+     */
+    emulateJpegSize?: boolean;
+}
+export declare const defaultOptions: Required<Options> & Record<string, any>;
+export declare const bitDepth: number[];
+export declare const mimeType = "image/webp";
+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 decode(input: BufferSource): ImageData;

package/lib/webp.js

@@ -0,0 +1,62 @@
+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 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 decode(input) {
+    return check(decoderWASM.decode(input), "Webp Decode");
+}