pdf-codec 1.6.0 → 1.8.0

package/dist/image/jpeg2000-t2.cjs

@@ -0,0 +1,316 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_image_jpeg2000_errors = require("./jpeg2000-errors.cjs");
+const require_image_jpeg2000_tagtree = require("./jpeg2000-tagtree.cjs");
+//#region src/image/jpeg2000-t2.ts
+const HIGHER_RESOLUTION_BANDS = [
+	"HL",
+	"LH",
+	"HH"
+];
+const SUBBAND_GAIN_LOG2 = {
+	LL: 0,
+	HL: 1,
+	LH: 1,
+	HH: 2
+};
+const INITIAL_LBLOCK = 3;
+function ceilDiv(value, divisor) {
+	return Math.ceil(value / divisor);
+}
+function tileBounds(siz, tileX, tileY) {
+	return {
+		x0: Math.max(siz.xtosiz + tileX * siz.xtsiz, siz.xosiz),
+		y0: Math.max(siz.ytosiz + tileY * siz.ytsiz, siz.yosiz),
+		x1: Math.min(siz.xtosiz + (tileX + 1) * siz.xtsiz, siz.xsiz),
+		y1: Math.min(siz.ytosiz + (tileY + 1) * siz.ytsiz, siz.ysiz)
+	};
+}
+function componentBounds(tile, dx, dy) {
+	return {
+		x0: ceilDiv(tile.x0, dx),
+		y0: ceilDiv(tile.y0, dy),
+		x1: ceilDiv(tile.x1, dx),
+		y1: ceilDiv(tile.y1, dy)
+	};
+}
+function resolutionBounds(component, levels, resolution) {
+	const scale = 2 ** (levels - resolution);
+	return {
+		x0: ceilDiv(component.x0, scale),
+		y0: ceilDiv(component.y0, scale),
+		x1: ceilDiv(component.x1, scale),
+		y1: ceilDiv(component.y1, scale)
+	};
+}
+function precinctGrid(bounds, ppx, ppy) {
+	return {
+		wide: bounds.x1 > bounds.x0 ? Math.ceil(bounds.x1 / 2 ** ppx) - Math.floor(bounds.x0 / 2 ** ppx) : 0,
+		high: bounds.y1 > bounds.y0 ? Math.ceil(bounds.y1 / 2 ** ppy) - Math.floor(bounds.y0 / 2 ** ppy) : 0
+	};
+}
+function tileHasSubdividedPrecincts(siz, tileX, tileY, codingPerComponent) {
+	const tile = tileBounds(siz, tileX, tileY);
+	for (let c = 0; c < siz.components.length; c++) {
+		const size = siz.components[c];
+		const coding = codingPerComponent[c];
+		if (size === void 0 || coding === void 0) continue;
+		const component = componentBounds(tile, size.dx, size.dy);
+		for (let r = 0; r <= coding.decompositionLevels; r++) {
+			const precinctSize = coding.precinctSizes[r];
+			if (precinctSize === void 0) continue;
+			const grid = precinctGrid(resolutionBounds(component, coding.decompositionLevels, r), precinctSize.ppx, precinctSize.ppy);
+			if (grid.wide * grid.high > 1) return true;
+		}
+	}
+	return false;
+}
+function bandCoordinate(componentCoordinate, levels, orientation) {
+	if (levels === 0) return componentCoordinate;
+	const half = 2 ** (levels - 1);
+	return Math.ceil((componentCoordinate - half * orientation) / (2 * half));
+}
+function quantizationIndex(resolution, bandIndex) {
+	return resolution === 0 ? 0 : 3 * (resolution - 1) + bandIndex + 1;
+}
+function stepSizeFor(quantization, resolution, bandIndex) {
+	if (quantization.style === "derived") {
+		const base = quantization.stepSizes[0];
+		if (base === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("a QCD/QCC marker declares derived quantization but carries no step size");
+		return {
+			exponent: Math.max(base.exponent - Math.max(resolution - 1, 0), 0),
+			mantissa: base.mantissa
+		};
+	}
+	const index = quantizationIndex(resolution, bandIndex);
+	const step = quantization.stepSizes[index];
+	if (step === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`a QCD/QCC marker carries no step size for subband ${String(index)}, which its own decomposition level count requires`);
+	return step;
+}
+function buildPrecinct(band, precinctX, precinctY, bandPpx, bandPpy, codeBlockWidthExp, codeBlockHeightExp) {
+	const precinctWidth = 2 ** bandPpx;
+	const precinctHeight = 2 ** bandPpy;
+	const originX = (Math.floor(band.x0 / precinctWidth) + precinctX) * precinctWidth;
+	const originY = (Math.floor(band.y0 / precinctHeight) + precinctY) * precinctHeight;
+	const px0 = Math.max(originX, band.x0);
+	const py0 = Math.max(originY, band.y0);
+	const px1 = Math.min(originX + precinctWidth, band.x1);
+	const py1 = Math.min(originY + precinctHeight, band.y1);
+	const cbWidth = 2 ** Math.min(codeBlockWidthExp, bandPpx);
+	const cbHeight = 2 ** Math.min(codeBlockHeightExp, bandPpy);
+	const gridX0 = Math.floor(px0 / cbWidth);
+	const gridY0 = Math.floor(py0 / cbHeight);
+	const gridX1 = px1 > px0 ? Math.ceil(px1 / cbWidth) : gridX0;
+	const gridY1 = py1 > py0 ? Math.ceil(py1 / cbHeight) : gridY0;
+	const gridWidth = gridX1 - gridX0;
+	const gridHeight = gridY1 - gridY0;
+	const codeBlocks = [];
+	for (let gy = 0; gy < gridHeight; gy++) for (let gx = 0; gx < gridWidth; gx++) {
+		const cellX = (gridX0 + gx) * cbWidth;
+		const cellY = (gridY0 + gy) * cbHeight;
+		codeBlocks.push({
+			x0: Math.max(cellX, px0),
+			y0: Math.max(cellY, py0),
+			x1: Math.min(cellX + cbWidth, px1),
+			y1: Math.min(cellY + cbHeight, py1),
+			gridX: gx,
+			gridY: gy,
+			included: false,
+			lblock: INITIAL_LBLOCK,
+			zeroBitPlanes: 0,
+			passes: 0,
+			chunks: []
+		});
+	}
+	return {
+		inclusion: new require_image_jpeg2000_tagtree.TagTree(gridWidth, gridHeight),
+		zeroBitPlaneTree: new require_image_jpeg2000_tagtree.TagTree(gridWidth, gridHeight),
+		codeBlocks
+	};
+}
+function buildTileGeometry(siz, tileX, tileY, codingPerComponent, quantizationPerComponent) {
+	const tile = tileBounds(siz, tileX, tileY);
+	const components = [];
+	for (let c = 0; c < siz.components.length; c++) {
+		const componentSize = siz.components[c];
+		const coding = codingPerComponent[c];
+		const quantization = quantizationPerComponent[c];
+		if (componentSize === void 0 || coding === void 0 || quantization === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`no coding style or quantization is defined for component ${String(c)}`);
+		const bounds = componentBounds(tile, componentSize.dx, componentSize.dy);
+		const levels = coding.decompositionLevels;
+		const resolutions = [];
+		for (let r = 0; r <= levels; r++) {
+			const level = resolutionBounds(bounds, levels, r);
+			const { x0: rx0, y0: ry0, x1: rx1, y1: ry1 } = level;
+			const precinctSize = coding.precinctSizes[r];
+			if (precinctSize === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`the coding style declares ${String(levels)} decomposition levels but no precinct size for resolution ${String(r)}`);
+			const { ppx, ppy } = precinctSize;
+			if (r > 0 && (ppx === 0 || ppy === 0)) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`resolution level ${String(r)} declares a precinct exponent of zero, which ISO/IEC 15444-1 B.6 permits only at resolution level 0`);
+			const { wide: precinctsWide, high: precinctsHigh } = precinctGrid(level, ppx, ppy);
+			const bandPpx = r === 0 ? ppx : ppx - 1;
+			const bandPpy = r === 0 ? ppy : ppy - 1;
+			const bandTypes = r === 0 ? ["LL"] : HIGHER_RESOLUTION_BANDS;
+			const subbands = [];
+			for (let b = 0; b < bandTypes.length; b++) {
+				const type = bandTypes[b] ?? "LL";
+				const bandLevels = r === 0 ? levels : levels - r + 1;
+				const xob = type === "HL" || type === "HH" ? 1 : 0;
+				const yob = type === "LH" || type === "HH" ? 1 : 0;
+				const bx0 = bandCoordinate(bounds.x0, bandLevels, xob);
+				const by0 = bandCoordinate(bounds.y0, bandLevels, yob);
+				const bx1 = bandCoordinate(bounds.x1, bandLevels, xob);
+				const by1 = bandCoordinate(bounds.y1, bandLevels, yob);
+				const stepSize = stepSizeFor(quantization, r, b);
+				const precincts = [];
+				for (let py = 0; py < precinctsHigh; py++) for (let px = 0; px < precinctsWide; px++) precincts.push(buildPrecinct({
+					x0: bx0,
+					y0: by0,
+					x1: bx1,
+					y1: by1
+				}, px, py, bandPpx, bandPpy, coding.codeBlockWidthExp, coding.codeBlockHeightExp));
+				subbands.push({
+					type,
+					x0: bx0,
+					y0: by0,
+					x1: bx1,
+					y1: by1,
+					stepSize,
+					maxBitPlanes: stepSize.exponent + quantization.guardBits - 1,
+					precincts
+				});
+			}
+			resolutions.push({
+				index: r,
+				x0: rx0,
+				y0: ry0,
+				x1: rx1,
+				y1: ry1,
+				precinctsWide,
+				precinctsHigh,
+				subbands
+			});
+		}
+		components.push({
+			...bounds,
+			coding,
+			quantization,
+			resolutions
+		});
+	}
+	return {
+		...tile,
+		components
+	};
+}
+function subbandGainLog2(type) {
+	return SUBBAND_GAIN_LOG2[type];
+}
+function readCodingPasses(reader) {
+	if (reader.readBit() === 0) return 1;
+	if (reader.readBit() === 0) return 2;
+	const twoBit = reader.readBits(2);
+	if (twoBit < 3) return 3 + twoBit;
+	const fiveBit = reader.readBits(5);
+	if (fiveBit < 31) return 6 + fiveBit;
+	return 37 + reader.readBits(7);
+}
+function buildPacketSequence(tile, order, layers) {
+	const maxResolutions = Math.max(...tile.components.map((component) => component.resolutions.length));
+	const precinctCount = (component, resolution) => {
+		const level = (tile.components[component]?.resolutions)?.[resolution];
+		return level === void 0 ? 0 : level.precinctsWide * level.precinctsHigh;
+	};
+	const packets = [];
+	const push = (layer, resolution, component, precinct) => {
+		packets.push({
+			layer,
+			resolution,
+			component,
+			precinct
+		});
+	};
+	if (order === "LRCP") {
+		for (let l = 0; l < layers; l++) for (let r = 0; r < maxResolutions; r++) for (let c = 0; c < tile.components.length; c++) for (let p = 0; p < precinctCount(c, r); p++) push(l, r, c, p);
+		return packets;
+	}
+	if (order === "RLCP") {
+		for (let r = 0; r < maxResolutions; r++) for (let l = 0; l < layers; l++) for (let c = 0; c < tile.components.length; c++) for (let p = 0; p < precinctCount(c, r); p++) push(l, r, c, p);
+		return packets;
+	}
+	for (let c = 0; c < tile.components.length; c++) for (let r = 0; r < maxResolutions; r++) if (precinctCount(c, r) > 1) throw new require_image_jpeg2000_errors.Jpeg2000UnsupportedError(`progression order ${order} is only decoded here when every resolution level holds a single precinct, and this codestream subdivides at least one of them`);
+	if (order === "RPCL") {
+		for (let r = 0; r < maxResolutions; r++) for (let c = 0; c < tile.components.length; c++) for (let l = 0; l < layers; l++) if (precinctCount(c, r) > 0) push(l, r, c, 0);
+		return packets;
+	}
+	if (order === "PCRL") {
+		for (let c = 0; c < tile.components.length; c++) for (let r = 0; r < maxResolutions; r++) for (let l = 0; l < layers; l++) if (precinctCount(c, r) > 0) push(l, r, c, 0);
+		return packets;
+	}
+	for (let c = 0; c < tile.components.length; c++) for (let r = 0; r < maxResolutions; r++) for (let l = 0; l < layers; l++) if (precinctCount(c, r) > 0) push(l, r, c, 0);
+	return packets;
+}
+const MARKER_SOP_HIGH = 255;
+const MARKER_SOP_LOW = 145;
+const MARKER_EPH_LOW = 146;
+const SOP_SEGMENT_BYTES = 6;
+const EPH_MARKER_BYTES = 2;
+function readTilePackets(data, start, end, tile, sequence, options) {
+	let position = start;
+	for (let packetIndex = 0; packetIndex < sequence.length; packetIndex++) {
+		const packet = sequence[packetIndex];
+		if (packet === void 0) break;
+		if (position >= end) {
+			options.onWarning(`the tile's coded data ended after ${String(packetIndex)} of ${String(sequence.length)} packets; the rest of the image is reconstructed from what did arrive`);
+			return position;
+		}
+		if (options.useSop && position + SOP_SEGMENT_BYTES <= end && data[position] === MARKER_SOP_HIGH && data[position + 1] === MARKER_SOP_LOW) position += SOP_SEGMENT_BYTES;
+		const component = tile.components[packet.component];
+		const resolution = component?.resolutions[packet.resolution];
+		if (component === void 0 || resolution === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("the progression sequence names a resolution level the tile does not have");
+		const reader = new require_image_jpeg2000_tagtree.PacketBitReader(data, position, end);
+		const included = [];
+		const lengths = [];
+		if (reader.readBit() === 1) for (const band of resolution.subbands) {
+			const precinct = band.precincts[packet.precinct];
+			if (precinct === void 0) continue;
+			for (const block of precinct.codeBlocks) {
+				if (!(block.included ? reader.readBit() === 1 : precinct.inclusion.decode(reader, block.gridX, block.gridY, packet.layer + 1))) continue;
+				if (!block.included) {
+					block.included = true;
+					let threshold = 1;
+					while (!precinct.zeroBitPlaneTree.decode(reader, block.gridX, block.gridY, threshold)) threshold++;
+					block.zeroBitPlanes = threshold - 1;
+				}
+				const passes = readCodingPasses(reader);
+				while (reader.readBit() === 1) block.lblock++;
+				const lengthBits = block.lblock + Math.floor(Math.log2(passes));
+				const length = reader.readBits(lengthBits);
+				block.passes += passes;
+				included.push(block);
+				lengths.push(length);
+			}
+		}
+		reader.alignToByte();
+		position = reader.offset;
+		if (options.useEph && position + EPH_MARKER_BYTES <= end && data[position] === MARKER_SOP_HIGH && data[position + 1] === MARKER_EPH_LOW) position += EPH_MARKER_BYTES;
+		for (let i = 0; i < included.length; i++) {
+			const block = included[i];
+			const length = lengths[i] ?? 0;
+			if (block === void 0) continue;
+			const chunkEnd = Math.min(position + length, end);
+			if (chunkEnd < position + length) options.onWarning("a code-block declares more coded bytes than the tile carries; decoding it from the bytes that did arrive");
+			block.chunks.push({
+				start: position,
+				end: chunkEnd
+			});
+			position += length;
+			if (position > end) return end;
+		}
+	}
+	return position;
+}
+//#endregion
+exports.buildPacketSequence = buildPacketSequence;
+exports.buildTileGeometry = buildTileGeometry;
+exports.readTilePackets = readTilePackets;
+exports.subbandGainLog2 = subbandGainLog2;
+exports.tileHasSubdividedPrecincts = tileHasSubdividedPrecincts;

package/dist/image/jpeg2000-t2.d.cts

@@ -0,0 +1,79 @@
+import { Jpeg2000CodingStyle, Jpeg2000ImageSize, Jpeg2000ProgressionOrder, Jpeg2000Quantization, Jpeg2000StepSize } from "./jpeg2000-codestream.cjs";
+import { Jpeg2000SubbandType } from "./jpeg2000-t1.cjs";
+import { TagTree } from "./jpeg2000-tagtree.cjs";
+//#region src/image/jpeg2000-t2.d.ts
+interface Jpeg2000CodeBlock {
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly gridX: number;
+  readonly gridY: number;
+  included: boolean;
+  lblock: number;
+  zeroBitPlanes: number;
+  passes: number;
+  readonly chunks: {
+    start: number;
+    end: number;
+  }[];
+}
+interface Jpeg2000Precinct {
+  readonly inclusion: TagTree;
+  readonly zeroBitPlaneTree: TagTree;
+  readonly codeBlocks: Jpeg2000CodeBlock[];
+}
+interface Jpeg2000Subband {
+  readonly type: Jpeg2000SubbandType;
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly stepSize: Jpeg2000StepSize;
+  readonly maxBitPlanes: number;
+  readonly precincts: readonly Jpeg2000Precinct[];
+}
+interface Jpeg2000Resolution {
+  readonly index: number;
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly precinctsWide: number;
+  readonly precinctsHigh: number;
+  readonly subbands: readonly Jpeg2000Subband[];
+}
+interface Jpeg2000TileComponent {
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly coding: Jpeg2000CodingStyle;
+  readonly quantization: Jpeg2000Quantization;
+  readonly resolutions: readonly Jpeg2000Resolution[];
+}
+interface Jpeg2000TileGeometry {
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly components: readonly Jpeg2000TileComponent[];
+}
+declare function tileHasSubdividedPrecincts(siz: Jpeg2000ImageSize, tileX: number, tileY: number, codingPerComponent: readonly Jpeg2000CodingStyle[]): boolean;
+declare function buildTileGeometry(siz: Jpeg2000ImageSize, tileX: number, tileY: number, codingPerComponent: readonly Jpeg2000CodingStyle[], quantizationPerComponent: readonly Jpeg2000Quantization[]): Jpeg2000TileGeometry;
+declare function subbandGainLog2(type: Jpeg2000SubbandType): number;
+interface PacketPosition {
+  readonly layer: number;
+  readonly resolution: number;
+  readonly component: number;
+  readonly precinct: number;
+}
+declare function buildPacketSequence(tile: Jpeg2000TileGeometry, order: Jpeg2000ProgressionOrder, layers: number): PacketPosition[];
+interface PacketReadOptions {
+  readonly useSop: boolean;
+  readonly useEph: boolean;
+  readonly onWarning: (message: string) => void;
+}
+declare function readTilePackets(data: Uint8Array<ArrayBuffer>, start: number, end: number, tile: Jpeg2000TileGeometry, sequence: readonly PacketPosition[], options: PacketReadOptions): number;
+//#endregion
+export { Jpeg2000CodeBlock, Jpeg2000Precinct, Jpeg2000Resolution, Jpeg2000Subband, Jpeg2000TileComponent, Jpeg2000TileGeometry, PacketReadOptions, buildPacketSequence, buildTileGeometry, readTilePackets, subbandGainLog2, tileHasSubdividedPrecincts };

package/dist/image/jpeg2000-t2.d.ts

@@ -0,0 +1,79 @@
+import { Jpeg2000CodingStyle, Jpeg2000ImageSize, Jpeg2000ProgressionOrder, Jpeg2000Quantization, Jpeg2000StepSize } from "./jpeg2000-codestream.js";
+import { Jpeg2000SubbandType } from "./jpeg2000-t1.js";
+import { TagTree } from "./jpeg2000-tagtree.js";
+//#region src/image/jpeg2000-t2.d.ts
+interface Jpeg2000CodeBlock {
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly gridX: number;
+  readonly gridY: number;
+  included: boolean;
+  lblock: number;
+  zeroBitPlanes: number;
+  passes: number;
+  readonly chunks: {
+    start: number;
+    end: number;
+  }[];
+}
+interface Jpeg2000Precinct {
+  readonly inclusion: TagTree;
+  readonly zeroBitPlaneTree: TagTree;
+  readonly codeBlocks: Jpeg2000CodeBlock[];
+}
+interface Jpeg2000Subband {
+  readonly type: Jpeg2000SubbandType;
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly stepSize: Jpeg2000StepSize;
+  readonly maxBitPlanes: number;
+  readonly precincts: readonly Jpeg2000Precinct[];
+}
+interface Jpeg2000Resolution {
+  readonly index: number;
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly precinctsWide: number;
+  readonly precinctsHigh: number;
+  readonly subbands: readonly Jpeg2000Subband[];
+}
+interface Jpeg2000TileComponent {
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly coding: Jpeg2000CodingStyle;
+  readonly quantization: Jpeg2000Quantization;
+  readonly resolutions: readonly Jpeg2000Resolution[];
+}
+interface Jpeg2000TileGeometry {
+  readonly x0: number;
+  readonly y0: number;
+  readonly x1: number;
+  readonly y1: number;
+  readonly components: readonly Jpeg2000TileComponent[];
+}
+declare function tileHasSubdividedPrecincts(siz: Jpeg2000ImageSize, tileX: number, tileY: number, codingPerComponent: readonly Jpeg2000CodingStyle[]): boolean;
+declare function buildTileGeometry(siz: Jpeg2000ImageSize, tileX: number, tileY: number, codingPerComponent: readonly Jpeg2000CodingStyle[], quantizationPerComponent: readonly Jpeg2000Quantization[]): Jpeg2000TileGeometry;
+declare function subbandGainLog2(type: Jpeg2000SubbandType): number;
+interface PacketPosition {
+  readonly layer: number;
+  readonly resolution: number;
+  readonly component: number;
+  readonly precinct: number;
+}
+declare function buildPacketSequence(tile: Jpeg2000TileGeometry, order: Jpeg2000ProgressionOrder, layers: number): PacketPosition[];
+interface PacketReadOptions {
+  readonly useSop: boolean;
+  readonly useEph: boolean;
+  readonly onWarning: (message: string) => void;
+}
+declare function readTilePackets(data: Uint8Array<ArrayBuffer>, start: number, end: number, tile: Jpeg2000TileGeometry, sequence: readonly PacketPosition[], options: PacketReadOptions): number;
+//#endregion
+export { Jpeg2000CodeBlock, Jpeg2000Precinct, Jpeg2000Resolution, Jpeg2000Subband, Jpeg2000TileComponent, Jpeg2000TileGeometry, PacketReadOptions, buildPacketSequence, buildTileGeometry, readTilePackets, subbandGainLog2, tileHasSubdividedPrecincts };