pdf-codec 1.5.0 → 1.7.0

package/dist/image/jpeg2000-t2.js

@@ -0,0 +1,311 @@
+import { Jpeg2000ParseError, Jpeg2000UnsupportedError } from "./jpeg2000-errors.js";
+import { PacketBitReader, TagTree } from "./jpeg2000-tagtree.js";
+//#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 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 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 TagTree(gridWidth, gridHeight),
+		zeroBitPlaneTree: new 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 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 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 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 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 Jpeg2000ParseError("the progression sequence names a resolution level the tile does not have");
+		const reader = new 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
+export { buildPacketSequence, buildTileGeometry, readTilePackets, subbandGainLog2, tileHasSubdividedPrecincts };

package/dist/image/jpeg2000-tagtree.cjs

@@ -0,0 +1,105 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_image_jpeg2000_errors = require("./jpeg2000-errors.cjs");
+//#region src/image/jpeg2000-tagtree.ts
+var PacketBitReader = class {
+	data;
+	end;
+	position;
+	buffer = 0;
+	available = 0;
+	previousByte = 0;
+	constructor(data, start, end) {
+		this.data = data;
+		this.end = end;
+		this.position = start;
+	}
+	get offset() {
+		return this.position;
+	}
+	nextByte() {
+		if (this.position >= this.end) {
+			this.previousByte = 0;
+			return 0;
+		}
+		const byte = this.data[this.position] ?? 0;
+		this.position++;
+		return byte;
+	}
+	readBit() {
+		if (this.available === 0) {
+			const stuffed = this.previousByte === 255;
+			const byte = this.nextByte();
+			if (stuffed && (byte & 128) !== 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("a packet header byte following 0xFF has its stuffed bit set, which ISO/IEC 15444-1 B.10.1 forbids");
+			this.buffer = byte;
+			this.previousByte = byte;
+			this.available = stuffed ? 7 : 8;
+		}
+		this.available--;
+		return this.buffer >> this.available & 1;
+	}
+	readBits(count) {
+		let value = 0;
+		for (let i = 0; i < count; i++) value = value * 2 + this.readBit();
+		return value;
+	}
+	alignToByte() {
+		if (this.previousByte === 255) this.nextByte();
+		this.available = 0;
+		this.previousByte = 0;
+	}
+};
+var TagTree = class {
+	width;
+	height;
+	levelOffsets = [];
+	levelWidths = [];
+	levelHeights = [];
+	value;
+	low;
+	constructor(width, height) {
+		this.width = width;
+		this.height = height;
+		let w = Math.max(width, 1);
+		let h = Math.max(height, 1);
+		let total = 0;
+		for (;;) {
+			this.levelOffsets.push(total);
+			this.levelWidths.push(w);
+			this.levelHeights.push(h);
+			total += w * h;
+			if (w === 1 && h === 1) break;
+			w = Math.ceil(w / 2);
+			h = Math.ceil(h / 2);
+		}
+		this.value = new Int32Array(total).fill(SENTINEL_VALUE);
+		this.low = new Int32Array(total);
+	}
+	decode(reader, x, y, threshold) {
+		const path = [];
+		let levelX = x;
+		let levelY = y;
+		for (let level = 0; level < this.levelOffsets.length; level++) {
+			path.push((this.levelOffsets[level] ?? 0) + levelY * (this.levelWidths[level] ?? 1) + levelX);
+			levelX = levelX >> 1;
+			levelY = levelY >> 1;
+		}
+		let low = 0;
+		for (let i = path.length - 1; i >= 0; i--) {
+			const node = path[i] ?? 0;
+			if (low > (this.low[node] ?? 0)) this.low[node] = low;
+			else low = this.low[node] ?? 0;
+			while (low < threshold && low < (this.value[node] ?? SENTINEL_VALUE)) if (reader.readBit() === 1) this.value[node] = low;
+			else low++;
+			this.low[node] = low;
+		}
+		const leaf = path[0] ?? 0;
+		return (this.value[leaf] ?? SENTINEL_VALUE) < threshold;
+	}
+	valueAt(x, y) {
+		return this.value[y * (this.levelWidths[0] ?? 1) + x] ?? SENTINEL_VALUE;
+	}
+};
+const SENTINEL_VALUE = 2147483647;
+//#endregion
+exports.PacketBitReader = PacketBitReader;
+exports.TagTree = TagTree;

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

@@ -0,0 +1,29 @@
+//#region src/image/jpeg2000-tagtree.d.ts
+declare class PacketBitReader {
+  private readonly data;
+  private readonly end;
+  private position;
+  private buffer;
+  private available;
+  private previousByte;
+  constructor(data: Uint8Array<ArrayBuffer>, start: number, end: number);
+  get offset(): number;
+  private nextByte;
+  readBit(): number;
+  readBits(count: number): number;
+  alignToByte(): void;
+}
+declare class TagTree {
+  readonly width: number;
+  readonly height: number;
+  private readonly levelOffsets;
+  private readonly levelWidths;
+  private readonly levelHeights;
+  private readonly value;
+  private readonly low;
+  constructor(width: number, height: number);
+  decode(reader: PacketBitReader, x: number, y: number, threshold: number): boolean;
+  valueAt(x: number, y: number): number;
+}
+//#endregion
+export { PacketBitReader, TagTree };

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

@@ -0,0 +1,29 @@
+//#region src/image/jpeg2000-tagtree.d.ts
+declare class PacketBitReader {
+  private readonly data;
+  private readonly end;
+  private position;
+  private buffer;
+  private available;
+  private previousByte;
+  constructor(data: Uint8Array<ArrayBuffer>, start: number, end: number);
+  get offset(): number;
+  private nextByte;
+  readBit(): number;
+  readBits(count: number): number;
+  alignToByte(): void;
+}
+declare class TagTree {
+  readonly width: number;
+  readonly height: number;
+  private readonly levelOffsets;
+  private readonly levelWidths;
+  private readonly levelHeights;
+  private readonly value;
+  private readonly low;
+  constructor(width: number, height: number);
+  decode(reader: PacketBitReader, x: number, y: number, threshold: number): boolean;
+  valueAt(x: number, y: number): number;
+}
+//#endregion
+export { PacketBitReader, TagTree };

package/dist/image/jpeg2000-tagtree.js

@@ -0,0 +1,103 @@
+import { Jpeg2000ParseError } from "./jpeg2000-errors.js";
+//#region src/image/jpeg2000-tagtree.ts
+var PacketBitReader = class {
+	data;
+	end;
+	position;
+	buffer = 0;
+	available = 0;
+	previousByte = 0;
+	constructor(data, start, end) {
+		this.data = data;
+		this.end = end;
+		this.position = start;
+	}
+	get offset() {
+		return this.position;
+	}
+	nextByte() {
+		if (this.position >= this.end) {
+			this.previousByte = 0;
+			return 0;
+		}
+		const byte = this.data[this.position] ?? 0;
+		this.position++;
+		return byte;
+	}
+	readBit() {
+		if (this.available === 0) {
+			const stuffed = this.previousByte === 255;
+			const byte = this.nextByte();
+			if (stuffed && (byte & 128) !== 0) throw new Jpeg2000ParseError("a packet header byte following 0xFF has its stuffed bit set, which ISO/IEC 15444-1 B.10.1 forbids");
+			this.buffer = byte;
+			this.previousByte = byte;
+			this.available = stuffed ? 7 : 8;
+		}
+		this.available--;
+		return this.buffer >> this.available & 1;
+	}
+	readBits(count) {
+		let value = 0;
+		for (let i = 0; i < count; i++) value = value * 2 + this.readBit();
+		return value;
+	}
+	alignToByte() {
+		if (this.previousByte === 255) this.nextByte();
+		this.available = 0;
+		this.previousByte = 0;
+	}
+};
+var TagTree = class {
+	width;
+	height;
+	levelOffsets = [];
+	levelWidths = [];
+	levelHeights = [];
+	value;
+	low;
+	constructor(width, height) {
+		this.width = width;
+		this.height = height;
+		let w = Math.max(width, 1);
+		let h = Math.max(height, 1);
+		let total = 0;
+		for (;;) {
+			this.levelOffsets.push(total);
+			this.levelWidths.push(w);
+			this.levelHeights.push(h);
+			total += w * h;
+			if (w === 1 && h === 1) break;
+			w = Math.ceil(w / 2);
+			h = Math.ceil(h / 2);
+		}
+		this.value = new Int32Array(total).fill(SENTINEL_VALUE);
+		this.low = new Int32Array(total);
+	}
+	decode(reader, x, y, threshold) {
+		const path = [];
+		let levelX = x;
+		let levelY = y;
+		for (let level = 0; level < this.levelOffsets.length; level++) {
+			path.push((this.levelOffsets[level] ?? 0) + levelY * (this.levelWidths[level] ?? 1) + levelX);
+			levelX = levelX >> 1;
+			levelY = levelY >> 1;
+		}
+		let low = 0;
+		for (let i = path.length - 1; i >= 0; i--) {
+			const node = path[i] ?? 0;
+			if (low > (this.low[node] ?? 0)) this.low[node] = low;
+			else low = this.low[node] ?? 0;
+			while (low < threshold && low < (this.value[node] ?? SENTINEL_VALUE)) if (reader.readBit() === 1) this.value[node] = low;
+			else low++;
+			this.low[node] = low;
+		}
+		const leaf = path[0] ?? 0;
+		return (this.value[leaf] ?? SENTINEL_VALUE) < threshold;
+	}
+	valueAt(x, y) {
+		return this.value[y * (this.levelWidths[0] ?? 1) + x] ?? SENTINEL_VALUE;
+	}
+};
+const SENTINEL_VALUE = 2147483647;
+//#endregion
+export { PacketBitReader, TagTree };