pdf-codec 1.5.0 → 1.7.0

package/dist/image/jpeg2000.cjs

@@ -0,0 +1,322 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_image_jpeg2000_errors = require("./jpeg2000-errors.cjs");
+const require_image_jp2_boxes = require("./jp2-boxes.cjs");
+const require_image_jpeg2000_codestream = require("./jpeg2000-codestream.cjs");
+const require_image_jpeg2000_dwt = require("./jpeg2000-dwt.cjs");
+const require_image_jpeg2000_t1 = require("./jpeg2000-t1.cjs");
+const require_image_jpeg2000_t2 = require("./jpeg2000-t2.cjs");
+//#region src/image/jpeg2000.ts
+function resolveCoding(main, tile, component) {
+	const tileCoc = tile?.coc.get(component);
+	if (tileCoc !== void 0) return tileCoc;
+	if (tile?.cod !== void 0) return tile.cod;
+	const mainCoc = main.coc.get(component);
+	if (mainCoc !== void 0) return mainCoc;
+	if (main.cod === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("no COD marker defines a coding style for this codestream");
+	return main.cod;
+}
+function resolveQuantization(main, tile, component) {
+	const tileQcc = tile?.qcc.get(component);
+	if (tileQcc !== void 0) return tileQcc;
+	if (tile?.qcd !== void 0) return tile.qcd;
+	const mainQcc = main.qcc.get(component);
+	if (mainQcc !== void 0) return mainQcc;
+	if (main.qcd === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("no QCD marker defines a quantization for this codestream");
+	return main.qcd;
+}
+function tileDefaults(main, tile) {
+	if (tile?.cod !== void 0) return tile.cod;
+	if (main.cod === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("no COD marker defines a coding style for this codestream");
+	return main.cod;
+}
+function undecodableReason(codestream) {
+	const main = codestream.main;
+	const cod = main.cod;
+	if (cod === void 0) return "the codestream carries no COD marker";
+	const headers = [main, ...codestream.tileParts.map((part) => part.header)];
+	for (const header of headers) {
+		if (header.hasProgressionChanges) return "the codestream carries a POC marker (progression order change), which this decoder does not follow";
+		if (header.hasRegionOfInterest) return "the codestream carries an RGN marker (region of interest), whose coefficient upshift this decoder does not undo";
+		if (header.hasPackedPacketHeaders) return "the codestream carries a PPT marker (packed packet headers in the tile-part header), an organisation this decoder does not reassemble";
+	}
+	for (let c = 0; c < codestream.siz.components.length; c++) {
+		const size = codestream.siz.components[c];
+		if (size === void 0) continue;
+		if (size.dx !== 1 || size.dy !== 1) return `component ${String(c)} is sub-sampled (${String(size.dx)}x${String(size.dy)}), which this decoder does not resample`;
+		for (const header of headers) {
+			const style = resolveCoding(main, header === main ? void 0 : header, c);
+			if ((style.codeBlockStyle & 1) !== 0) return "the code-block style enables selective arithmetic coding bypass, which this decoder does not read";
+			if ((style.codeBlockStyle & 4) !== 0) return "the code-block style terminates the arithmetic coder on every coding pass, which this decoder does not read";
+		}
+	}
+	for (const part of codestream.tileParts) {
+		if (part.partIndex !== 0) continue;
+		const defaults = part.header.cod ?? cod;
+		if (defaults.progressionOrder === "LRCP" || defaults.progressionOrder === "RLCP") continue;
+		const numTilesWide = Math.max(Math.ceil((codestream.siz.xsiz - codestream.siz.xtosiz) / codestream.siz.xtsiz), 1);
+		const codingPerComponent = codestream.siz.components.map((_, c) => resolveCoding(main, part.header, c));
+		if (require_image_jpeg2000_t2.tileHasSubdividedPrecincts(codestream.siz, part.tileIndex % numTilesWide, Math.floor(part.tileIndex / numTilesWide), codingPerComponent)) return `progression order ${defaults.progressionOrder} is only decoded here when every resolution level holds a single precinct, and this codestream subdivides at least one of them`;
+	}
+	const first = codestream.siz.components[0];
+	if (first !== void 0) {
+		for (const size of codestream.siz.components) if (size.bitDepth !== first.bitDepth || size.signed !== first.signed) return "the codestream mixes component bit depths or signedness, which this decoder does not combine into one image";
+		if (first.bitDepth > 31) return `a component bit depth of ${String(first.bitDepth)} exceeds what this decoder's own 32-bit sample arithmetic can hold`;
+	}
+}
+function readJpeg2000Metadata(data) {
+	const container = require_image_jp2_boxes.parseJp2Container(data);
+	const codestream = require_image_jpeg2000_codestream.parseJpeg2000Codestream(container.codestream);
+	const cod = codestream.main.cod;
+	const qcd = codestream.main.qcd;
+	if (cod === void 0 || qcd === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("the codestream main header is missing its COD or QCD marker");
+	const reason = undecodableReason(codestream);
+	const siz = codestream.siz;
+	return {
+		width: siz.xsiz - siz.xosiz,
+		height: siz.ysiz - siz.yosiz,
+		components: siz.components.map((component) => ({
+			bitDepth: component.bitDepth,
+			signed: component.signed,
+			dx: component.dx,
+			dy: component.dy
+		})),
+		tileWidth: siz.xtsiz,
+		tileHeight: siz.ytsiz,
+		tilesWide: codestream.numTilesWide,
+		tilesHigh: codestream.numTilesHigh,
+		tilePartCount: codestream.tileParts.length,
+		decompositionLevels: cod.decompositionLevels,
+		transform: cod.transform,
+		progressionOrder: cod.progressionOrder,
+		layers: cod.layers,
+		codeBlockWidth: 2 ** cod.codeBlockWidthExp,
+		codeBlockHeight: 2 ** cod.codeBlockHeightExp,
+		codeBlockStyle: cod.codeBlockStyle,
+		quantizationStyle: qcd.style,
+		guardBits: qcd.guardBits,
+		multipleComponentTransform: cod.multipleComponentTransform,
+		usesSopMarkers: cod.useSop,
+		usesEphMarkers: cod.useEph,
+		hasIccProfile: container.iccProfile !== void 0,
+		channelDefinitions: container.channelDefinitions,
+		comments: codestream.comments,
+		truncated: codestream.truncated,
+		decodable: reason === void 0,
+		...container.colourSpace !== void 0 ? { colourSpace: container.colourSpace } : {},
+		...reason !== void 0 ? { undecodableReason: reason } : {}
+	};
+}
+function concatTilePartData(codestream, tileIndex) {
+	const parts = codestream.tileParts.filter((part) => part.tileIndex === tileIndex).sort((a, b) => a.partIndex - b.partIndex);
+	let total = 0;
+	for (const part of parts) total += part.dataEnd - part.dataStart;
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const part of parts) {
+		out.set(codestream.bytes.subarray(part.dataStart, part.dataEnd), offset);
+		offset += part.dataEnd - part.dataStart;
+	}
+	return out;
+}
+function halveTowardZero(value) {
+	return value < 0 ? -(-value >> 1) : value >> 1;
+}
+function quantizationStep(band, componentBitDepth) {
+	return 2 ** (componentBitDepth + require_image_jpeg2000_t2.subbandGainLog2(band.type) - band.stepSize.exponent) * (1 + band.stepSize.mantissa / 2048);
+}
+function decodeSubbandBlocks(band, codeBlockStyle, data, place) {
+	for (const precinct of band.precincts) for (const block of precinct.codeBlocks) {
+		const blockWidth = block.x1 - block.x0;
+		const blockHeight = block.y1 - block.y0;
+		if (blockWidth <= 0 || blockHeight <= 0 || block.passes === 0) continue;
+		let coded = /* @__PURE__ */ new Uint8Array(0);
+		if (block.chunks.length === 1) {
+			const chunk = block.chunks[0];
+			coded = chunk === void 0 ? coded : data.subarray(chunk.start, chunk.end);
+		} else if (block.chunks.length > 1) {
+			let total = 0;
+			for (const chunk of block.chunks) total += chunk.end - chunk.start;
+			const joined = new Uint8Array(total);
+			let offset = 0;
+			for (const chunk of block.chunks) {
+				joined.set(data.subarray(chunk.start, chunk.end), offset);
+				offset += chunk.end - chunk.start;
+			}
+			coded = joined;
+		}
+		const { values } = require_image_jpeg2000_t1.decodeJpeg2000CodeBlock({
+			width: blockWidth,
+			height: blockHeight,
+			subband: band.type,
+			zeroBitPlanes: block.zeroBitPlanes,
+			maxBitPlanes: band.maxBitPlanes,
+			totalPasses: block.passes,
+			codeBlockStyle,
+			data: coded
+		});
+		for (let y = 0; y < blockHeight; y++) for (let x = 0; x < blockWidth; x++) place(block.x0 - band.x0 + x, block.y0 - band.y0 + y, values[y * blockWidth + x] ?? 0);
+	}
+}
+function decodeReversibleTileComponent(tile, componentIndex, data) {
+	const component = tile.components[componentIndex];
+	if (component === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`the tile has no component ${String(componentIndex)}`);
+	const bands = /* @__PURE__ */ new Map();
+	for (const resolution of component.resolutions) for (const band of resolution.subbands) {
+		const width = band.x1 - band.x0;
+		const samples = new Int32Array(Math.max(width * (band.y1 - band.y0), 0));
+		decodeSubbandBlocks(band, component.coding.codeBlockStyle, data, (x, y, value) => {
+			samples[y * width + x] = halveTowardZero(value);
+		});
+		bands.set(`${String(resolution.index)}:${band.type}`, samples);
+	}
+	let current = bands.get("0:LL") ?? /* @__PURE__ */ new Int32Array(0);
+	for (let r = 1; r < component.resolutions.length; r++) {
+		const resolution = component.resolutions[r];
+		if (resolution === void 0) break;
+		current = require_image_jpeg2000_dwt.inverseDwt53Level({
+			ll: current,
+			hl: bands.get(`${String(r)}:HL`) ?? /* @__PURE__ */ new Int32Array(0),
+			lh: bands.get(`${String(r)}:LH`) ?? /* @__PURE__ */ new Int32Array(0),
+			hh: bands.get(`${String(r)}:HH`) ?? /* @__PURE__ */ new Int32Array(0)
+		}, {
+			u0: resolution.x0,
+			u1: resolution.x1,
+			v0: resolution.y0,
+			v1: resolution.y1
+		});
+	}
+	return current;
+}
+function decodeIrreversibleTileComponent(tile, componentIndex, componentBitDepth, data) {
+	const component = tile.components[componentIndex];
+	if (component === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`the tile has no component ${String(componentIndex)}`);
+	const bands = /* @__PURE__ */ new Map();
+	for (const resolution of component.resolutions) for (const band of resolution.subbands) {
+		const width = band.x1 - band.x0;
+		const samples = new Float32Array(Math.max(width * (band.y1 - band.y0), 0));
+		const scale = quantizationStep(band, componentBitDepth) / 2;
+		decodeSubbandBlocks(band, component.coding.codeBlockStyle, data, (x, y, value) => {
+			samples[y * width + x] = value * scale;
+		});
+		bands.set(`${String(resolution.index)}:${band.type}`, samples);
+	}
+	let current = bands.get("0:LL") ?? /* @__PURE__ */ new Float32Array(0);
+	for (let r = 1; r < component.resolutions.length; r++) {
+		const resolution = component.resolutions[r];
+		if (resolution === void 0) break;
+		current = require_image_jpeg2000_dwt.inverseDwt97Level({
+			ll: current,
+			hl: bands.get(`${String(r)}:HL`) ?? /* @__PURE__ */ new Float32Array(0),
+			lh: bands.get(`${String(r)}:LH`) ?? /* @__PURE__ */ new Float32Array(0),
+			hh: bands.get(`${String(r)}:HH`) ?? /* @__PURE__ */ new Float32Array(0)
+		}, {
+			u0: resolution.x0,
+			u1: resolution.x1,
+			v0: resolution.y0,
+			v1: resolution.y1
+		});
+	}
+	return current;
+}
+function inverseReversibleComponentTransform(planes) {
+	const y = planes[0];
+	const u = planes[1];
+	const v = planes[2];
+	if (y === void 0 || u === void 0 || v === void 0) return;
+	for (let i = 0; i < y.length; i++) {
+		const green = (y[i] ?? 0) - Math.floor(((u[i] ?? 0) + (v[i] ?? 0)) / 4);
+		const red = (v[i] ?? 0) + green;
+		const blue = (u[i] ?? 0) + green;
+		y[i] = red;
+		u[i] = green;
+		v[i] = blue;
+	}
+}
+const ICT_RED_FROM_CR = 1.402;
+const ICT_GREEN_FROM_CB = -.344136;
+const ICT_GREEN_FROM_CR = -.714136;
+const ICT_BLUE_FROM_CB = 1.772;
+function inverseIrreversibleComponentTransform(planes) {
+	const y = planes[0];
+	const cb = planes[1];
+	const cr = planes[2];
+	if (y === void 0 || cb === void 0 || cr === void 0) return;
+	for (let i = 0; i < y.length; i++) {
+		const luma = y[i] ?? 0;
+		const blueDiff = cb[i] ?? 0;
+		const redDiff = cr[i] ?? 0;
+		y[i] = luma + ICT_RED_FROM_CR * redDiff;
+		cb[i] = luma + ICT_GREEN_FROM_CB * blueDiff + ICT_GREEN_FROM_CR * redDiff;
+		cr[i] = luma + ICT_BLUE_FROM_CB * blueDiff;
+	}
+}
+function decodeJpeg2000(data, options = {}) {
+	const onWarning = options.onWarning ?? (() => void 0);
+	const container = require_image_jp2_boxes.parseJp2Container(data);
+	const codestream = require_image_jpeg2000_codestream.parseJpeg2000Codestream(container.codestream);
+	const reason = undecodableReason(codestream);
+	if (reason !== void 0) throw new require_image_jpeg2000_errors.Jpeg2000UnsupportedError(reason);
+	if (codestream.truncated) onWarning("the codestream ends without an EOC marker, so it is truncated; decoding whatever packets did arrive");
+	const siz = codestream.siz;
+	const width = siz.xsiz - siz.xosiz;
+	const height = siz.ysiz - siz.yosiz;
+	const componentCount = siz.components.length;
+	const first = siz.components[0];
+	if (first === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("the codestream declares no components");
+	const planes = Array.from({ length: componentCount }, () => new Int32Array(width * height));
+	const tileIndices = new Set(codestream.tileParts.map((part) => part.tileIndex));
+	if (tileIndices.size === 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("the codestream carries no tile-part data");
+	for (const tileIndex of [...tileIndices].sort((a, b) => a - b)) {
+		const tileX = tileIndex % codestream.numTilesWide;
+		const tileY = Math.floor(tileIndex / codestream.numTilesWide);
+		const tileHeader = codestream.tileParts.find((part) => part.tileIndex === tileIndex && part.partIndex === 0)?.header;
+		const codingPerComponent = Array.from({ length: componentCount }, (_, c) => resolveCoding(codestream.main, tileHeader, c));
+		const quantizationPerComponent = Array.from({ length: componentCount }, (_, c) => resolveQuantization(codestream.main, tileHeader, c));
+		const defaults = tileDefaults(codestream.main, tileHeader);
+		const geometry = require_image_jpeg2000_t2.buildTileGeometry(siz, tileX, tileY, codingPerComponent, quantizationPerComponent);
+		const tileData = concatTilePartData(codestream, tileIndex);
+		const sequence = require_image_jpeg2000_t2.buildPacketSequence(geometry, defaults.progressionOrder, defaults.layers);
+		require_image_jpeg2000_t2.readTilePackets(tileData, 0, tileData.length, geometry, sequence, {
+			useSop: defaults.useSop,
+			useEph: defaults.useEph,
+			onWarning
+		});
+		const tilePlanes = [];
+		if (defaults.transform === "reversible-5-3") {
+			const reversible = Array.from({ length: componentCount }, (_, c) => decodeReversibleTileComponent(geometry, c, tileData));
+			if (defaults.multipleComponentTransform && componentCount >= 3) inverseReversibleComponentTransform(reversible);
+			tilePlanes.push(...reversible);
+		} else {
+			const irreversible = Array.from({ length: componentCount }, (_, c) => decodeIrreversibleTileComponent(geometry, c, first.bitDepth, tileData));
+			if (defaults.multipleComponentTransform && componentCount >= 3) inverseIrreversibleComponentTransform(irreversible);
+			tilePlanes.push(...irreversible);
+		}
+		for (let c = 0; c < componentCount; c++) {
+			const tileComponent = geometry.components[c];
+			const source = tilePlanes[c];
+			const destination = planes[c];
+			if (tileComponent === void 0 || source === void 0 || destination === void 0) continue;
+			const tileWidth = tileComponent.x1 - tileComponent.x0;
+			for (let y = tileComponent.y0; y < tileComponent.y1; y++) for (let x = tileComponent.x0; x < tileComponent.x1; x++) destination[(y - siz.yosiz) * width + (x - siz.xosiz)] = Math.round(source[(y - tileComponent.y0) * tileWidth + (x - tileComponent.x0)] ?? 0);
+		}
+	}
+	const shift = first.signed ? 0 : 1 << first.bitDepth - 1;
+	const minimum = first.signed ? -(1 << first.bitDepth - 1) : 0;
+	const maximum = first.signed ? (1 << first.bitDepth - 1) - 1 : (1 << first.bitDepth) - 1;
+	for (const plane of planes) for (let i = 0; i < plane.length; i++) plane[i] = Math.min(Math.max((plane[i] ?? 0) + shift, minimum), maximum);
+	const base = {
+		width,
+		height,
+		bitDepth: first.bitDepth,
+		signed: first.signed,
+		components: planes,
+		channelDefinitions: container.channelDefinitions
+	};
+	return container.colourSpace !== void 0 ? {
+		...base,
+		colourSpace: container.colourSpace
+	} : base;
+}
+//#endregion
+exports.decodeJpeg2000 = decodeJpeg2000;
+exports.readJpeg2000Metadata = readJpeg2000Metadata;

package/dist/image/jpeg2000.d.cts

@@ -0,0 +1,54 @@
+import { Jp2ChannelDefinition, Jp2ColourSpace } from "./jp2-boxes.cjs";
+import { Jpeg2000ProgressionOrder, Jpeg2000QuantizationStyle, Jpeg2000Transform } from "./jpeg2000-codestream.cjs";
+//#region src/image/jpeg2000.d.ts
+interface Jpeg2000ComponentMetadata {
+  readonly bitDepth: number;
+  readonly signed: boolean;
+  readonly dx: number;
+  readonly dy: number;
+}
+interface Jpeg2000Metadata {
+  readonly width: number;
+  readonly height: number;
+  readonly components: readonly Jpeg2000ComponentMetadata[];
+  readonly tileWidth: number;
+  readonly tileHeight: number;
+  readonly tilesWide: number;
+  readonly tilesHigh: number;
+  readonly tilePartCount: number;
+  readonly decompositionLevels: number;
+  readonly transform: Jpeg2000Transform;
+  readonly progressionOrder: Jpeg2000ProgressionOrder;
+  readonly layers: number;
+  readonly codeBlockWidth: number;
+  readonly codeBlockHeight: number;
+  readonly codeBlockStyle: number;
+  readonly quantizationStyle: Jpeg2000QuantizationStyle;
+  readonly guardBits: number;
+  readonly multipleComponentTransform: boolean;
+  readonly usesSopMarkers: boolean;
+  readonly usesEphMarkers: boolean;
+  readonly colourSpace?: Jp2ColourSpace;
+  readonly hasIccProfile: boolean;
+  readonly channelDefinitions: readonly Jp2ChannelDefinition[];
+  readonly comments: readonly string[];
+  readonly truncated: boolean;
+  readonly decodable: boolean;
+  readonly undecodableReason?: string;
+}
+interface Jpeg2000DecodeOptions {
+  readonly onWarning?: (message: string) => void;
+}
+interface Jpeg2000Image {
+  readonly width: number;
+  readonly height: number;
+  readonly bitDepth: number;
+  readonly signed: boolean;
+  readonly components: readonly Int32Array[];
+  readonly colourSpace?: Jp2ColourSpace;
+  readonly channelDefinitions: readonly Jp2ChannelDefinition[];
+}
+declare function readJpeg2000Metadata(data: Uint8Array<ArrayBuffer>): Jpeg2000Metadata;
+declare function decodeJpeg2000(data: Uint8Array<ArrayBuffer>, options?: Jpeg2000DecodeOptions): Jpeg2000Image;
+//#endregion
+export { Jpeg2000ComponentMetadata, Jpeg2000DecodeOptions, Jpeg2000Image, Jpeg2000Metadata, decodeJpeg2000, readJpeg2000Metadata };

package/dist/image/jpeg2000.d.ts

@@ -0,0 +1,54 @@
+import { Jp2ChannelDefinition, Jp2ColourSpace } from "./jp2-boxes.js";
+import { Jpeg2000ProgressionOrder, Jpeg2000QuantizationStyle, Jpeg2000Transform } from "./jpeg2000-codestream.js";
+//#region src/image/jpeg2000.d.ts
+interface Jpeg2000ComponentMetadata {
+  readonly bitDepth: number;
+  readonly signed: boolean;
+  readonly dx: number;
+  readonly dy: number;
+}
+interface Jpeg2000Metadata {
+  readonly width: number;
+  readonly height: number;
+  readonly components: readonly Jpeg2000ComponentMetadata[];
+  readonly tileWidth: number;
+  readonly tileHeight: number;
+  readonly tilesWide: number;
+  readonly tilesHigh: number;
+  readonly tilePartCount: number;
+  readonly decompositionLevels: number;
+  readonly transform: Jpeg2000Transform;
+  readonly progressionOrder: Jpeg2000ProgressionOrder;
+  readonly layers: number;
+  readonly codeBlockWidth: number;
+  readonly codeBlockHeight: number;
+  readonly codeBlockStyle: number;
+  readonly quantizationStyle: Jpeg2000QuantizationStyle;
+  readonly guardBits: number;
+  readonly multipleComponentTransform: boolean;
+  readonly usesSopMarkers: boolean;
+  readonly usesEphMarkers: boolean;
+  readonly colourSpace?: Jp2ColourSpace;
+  readonly hasIccProfile: boolean;
+  readonly channelDefinitions: readonly Jp2ChannelDefinition[];
+  readonly comments: readonly string[];
+  readonly truncated: boolean;
+  readonly decodable: boolean;
+  readonly undecodableReason?: string;
+}
+interface Jpeg2000DecodeOptions {
+  readonly onWarning?: (message: string) => void;
+}
+interface Jpeg2000Image {
+  readonly width: number;
+  readonly height: number;
+  readonly bitDepth: number;
+  readonly signed: boolean;
+  readonly components: readonly Int32Array[];
+  readonly colourSpace?: Jp2ColourSpace;
+  readonly channelDefinitions: readonly Jp2ChannelDefinition[];
+}
+declare function readJpeg2000Metadata(data: Uint8Array<ArrayBuffer>): Jpeg2000Metadata;
+declare function decodeJpeg2000(data: Uint8Array<ArrayBuffer>, options?: Jpeg2000DecodeOptions): Jpeg2000Image;
+//#endregion
+export { Jpeg2000ComponentMetadata, Jpeg2000DecodeOptions, Jpeg2000Image, Jpeg2000Metadata, decodeJpeg2000, readJpeg2000Metadata };