s2-tools/dist/readers/image/jpeg.d.ts

A collection of geospatial tools primarily designed for WGS84, Web Mercator, and S2.

/** JPEG Options */
export interface JPEGOptions {
    skipMutation?: boolean;
    colorTransform?: boolean;
    formatAsRGBA?: boolean;
    tolerantDecoding?: boolean;
    maxResolutionInMP?: number;
    maxMemoryUsageInMB?: number;
}
/** A Component of a JPEG image */
export interface JPEGComponent {
    h: number;
    v: number;
    quantizationIdx: number;
    blocksPerLine: number;
    blocksPerColumn: number;
    blocks: Int32Array[][];
    huffmanTableDC: HuffmanNode[];
    huffmanTableAC: HuffmanNode[];
    quantizationTable: Int32Array;
    pred: number;
    dctZigZag: Int32Array;
}
/** A Component of a JPEG image organized into lines */
export interface OutComponent {
    lines: Uint8Array[];
    scaleX: number;
    scaleY: number;
}
/** A JPEG frame */
export interface Frame {
    extended: boolean;
    progressive: boolean;
    precision?: number;
    scanLines: number;
    samplesPerLine: number;
    components: {
        [id: number | string]: JPEGComponent;
    };
    componentsOrder: number[];
    maxH: number;
    maxV: number;
    mcusPerLine: number;
    mcusPerColumn: number;
}
/** Adobe APP14 marker */
export interface Adobe {
    version: number;
    flags0: number;
    flags1: number;
    transformCode: number;
}
/** JFIF marker */
export interface JFIF {
    version: {
        major: number;
        minor: number;
    };
    densityUnits: number;
    xDensity: number;
    yDensity: number;
    thumbWidth: number;
    thumbHeight: number;
    thumbData: Uint8Array;
}
/** The result of an individual parse */
export interface ParseResult {
    data: Uint8Array;
    outComponents: OutComponent[];
    ready: boolean;
}
/** An Image organized for the JPEG decoder */
export interface Image {
    width: number;
    height: number;
    exifBuffer: Uint8Array | null;
    data: Uint8Array;
    comments?: string[];
}
/**
 * Decodes a JPEG image
 * @param jpegData - The JPEG data
 * @param userOpts - The user provided options
 * @param jpegTables - The JPEG tables (if provided)
 * @returns - The decoded image
 */
export declare function decodeJpegData(jpegData: ArrayBufferLike, userOpts?: JPEGOptions, jpegTables?: number[]): Image;
/**
 * Decodes a JPEG image
 * @param buffer - The JPEG data
 * @param jpegTables - The JPEG tables (if provided)
 * @returns - The decoded image as a buffer
 */
export declare function jpegDecoder(buffer: ArrayBufferLike, jpegTables?: number[]): ArrayBufferLike;
/**
 * A JPEG stream reader
 */
export declare class JpegStreamReader {
    colorTransform?: boolean;
    skipMutation: boolean;
    formatAsRGBA: boolean;
    tolerantDecoding: boolean;
    maxResolutionInMP: number;
    maxMemoryUsageInMB: number;
    quantizationTables: Int32Array[];
    huffmanTablesAC: HuffmanNode[];
    huffmanTablesDC: HuffmanNode[];
    totalBytesAllocated: number;
    maxMemoryUsageBytes: number;
    width: number;
    height: number;
    resetInterval: number;
    comments: string[];
    adobe: Adobe | null;
    jfif: JFIF | null;
    exifBuffer: Uint8Array | null;
    frames: Frame[];
    dctZigZag: Int32Array<ArrayBuffer>;
    /**
     * @param opts - The user provided options
     */
    constructor(opts?: JPEGOptions);
    /**
     * Increase the max memory usage
     * @param increaseAmount - The amount to increase the max memory usage
     */
    requestMemoryAllocation(increaseAmount?: number): void;
    /**
     * Reset the max memory usage
     * @param maxMemoryUsageBytes - The new max memory usage
     */
    resetMaxMemoryUsage(maxMemoryUsageBytes: number): void;
    /**
     * Reset the frames
     */
    resetFrames(): void;
    /**
     * Parse the data into the frames
     * @param data - The individual block of JPEG data to parse
     */
    parse(data: Uint8Array): void;
    /**
     * Get a result of the frame decoding
     * @returns - The result of the frame decoding
     */
    getResult(): ParseResult;
    /**
     * Get the complete image data
     * @returns - The image data
     */
    getImageData(): Image;
}
/**
 * Represents a Huffman tree node where each node can contain either
 * a number (leaf) or nested arrays of numbers (internal nodes).
 */
type HuffmanNode = number | HuffmanNode[];
export {};
//# sourceMappingURL=jpeg.d.ts.map