pdf-codec 1.5.0 → 1.7.0

package/dist/image/jpeg2000-codestream.cjs

@@ -0,0 +1,309 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_image_jpeg2000_errors = require("./jpeg2000-errors.cjs");
+//#region src/image/jpeg2000-codestream.ts
+const MARKER_SOC = 65359;
+const MARKER_SIZ = 65361;
+const MARKER_COD = 65362;
+const MARKER_COC = 65363;
+const MARKER_QCD = 65372;
+const MARKER_QCC = 65373;
+const MARKER_RGN = 65374;
+const MARKER_POC = 65375;
+const MARKER_PPM = 65376;
+const MARKER_PPT = 65377;
+const MARKER_COM = 65380;
+const MARKER_SOT = 65424;
+const MARKER_SOD = 65427;
+const MARKER_EOC = 65497;
+const PROGRESSION_ORDERS = [
+	"LRCP",
+	"RLCP",
+	"RPCL",
+	"PCRL",
+	"CPRL"
+];
+var MarkerCursor = class {
+	data;
+	position;
+	constructor(data, start = 0) {
+		this.data = data;
+		this.position = start;
+	}
+	get remaining() {
+		return this.data.length - this.position;
+	}
+	uint8() {
+		const value = this.data[this.position];
+		if (value === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("JPEG 2000 codestream ended in the middle of a marker segment");
+		this.position++;
+		return value;
+	}
+	uint16() {
+		return this.uint8() << 8 | this.uint8();
+	}
+	uint32() {
+		return this.uint16() * 65536 + this.uint16();
+	}
+	bytes(length) {
+		if (length < 0 || this.position + length > this.data.length) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("a JPEG 2000 marker segment declares more data than the codestream carries");
+		const slice = this.data.subarray(this.position, this.position + length);
+		this.position += length;
+		return slice;
+	}
+};
+function readImageSize(cursor, segmentEnd) {
+	cursor.uint16();
+	const xsiz = cursor.uint32();
+	const ysiz = cursor.uint32();
+	const xosiz = cursor.uint32();
+	const yosiz = cursor.uint32();
+	const xtsiz = cursor.uint32();
+	const ytsiz = cursor.uint32();
+	const xtosiz = cursor.uint32();
+	const ytosiz = cursor.uint32();
+	const count = cursor.uint16();
+	if (count === 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("SIZ declares zero components");
+	if (cursor.position + count * 3 > segmentEnd) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`SIZ declares ${String(count)} components but its own length leaves room for fewer`);
+	const components = [];
+	for (let i = 0; i < count; i++) {
+		const ssiz = cursor.uint8();
+		components.push({
+			signed: (ssiz & 128) !== 0,
+			bitDepth: (ssiz & 127) + 1,
+			dx: cursor.uint8(),
+			dy: cursor.uint8()
+		});
+	}
+	if (xsiz <= xosiz || ysiz <= yosiz) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("SIZ declares an image with no area (Xsiz/Ysiz do not exceed XOsiz/YOsiz)");
+	if (xtsiz === 0 || ytsiz === 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("SIZ declares a zero-sized tile");
+	return {
+		xsiz,
+		ysiz,
+		xosiz,
+		yosiz,
+		xtsiz,
+		ytsiz,
+		xtosiz,
+		ytosiz,
+		components
+	};
+}
+const DEFAULT_PRECINCT_EXPONENT = 15;
+function readCodingStyleParameters(cursor, explicitPrecincts) {
+	const decompositionLevels = cursor.uint8();
+	const codeBlockWidthExp = (cursor.uint8() & 15) + 2;
+	const codeBlockHeightExp = (cursor.uint8() & 15) + 2;
+	const codeBlockStyle = cursor.uint8();
+	const transformCode = cursor.uint8();
+	if (transformCode !== 0 && transformCode !== 1) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`SPcod/SPcoc declares transformation ${String(transformCode)}, which is neither of the two ISO/IEC 15444-1 defines`);
+	if (codeBlockWidthExp > 10 || codeBlockHeightExp > 10 || codeBlockWidthExp + codeBlockHeightExp > 12) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`code-block size 2^${String(codeBlockWidthExp)} by 2^${String(codeBlockHeightExp)} is outside the range ISO/IEC 15444-1 Table A.18 permits`);
+	const precinctSizes = [];
+	if (explicitPrecincts) for (let r = 0; r <= decompositionLevels; r++) {
+		const packed = cursor.uint8();
+		precinctSizes.push({
+			ppx: packed & 15,
+			ppy: packed >> 4 & 15
+		});
+	}
+	else for (let r = 0; r <= decompositionLevels; r++) precinctSizes.push({
+		ppx: DEFAULT_PRECINCT_EXPONENT,
+		ppy: DEFAULT_PRECINCT_EXPONENT
+	});
+	return {
+		decompositionLevels,
+		codeBlockWidthExp,
+		codeBlockHeightExp,
+		codeBlockStyle,
+		transform: transformCode === 1 ? "reversible-5-3" : "irreversible-9-7",
+		precinctSizes
+	};
+}
+function readCodingDefaults(cursor) {
+	const scod = cursor.uint8();
+	const progressionOrder = PROGRESSION_ORDERS[cursor.uint8()];
+	if (progressionOrder === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("COD declares a progression order outside the five ISO/IEC 15444-1 Table A.16 defines");
+	const layers = cursor.uint16();
+	if (layers === 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("COD declares zero quality layers");
+	const multipleComponentTransform = cursor.uint8() !== 0;
+	return {
+		...readCodingStyleParameters(cursor, (scod & 1) !== 0),
+		progressionOrder,
+		layers,
+		multipleComponentTransform,
+		useSop: (scod & 2) !== 0,
+		useEph: (scod & 4) !== 0
+	};
+}
+function readQuantization(cursor, segmentEnd) {
+	const sq = cursor.uint8();
+	const guardBits = sq >> 5;
+	const styleCode = sq & 31;
+	const stepSizes = [];
+	if (styleCode === 0) {
+		while (cursor.position < segmentEnd) stepSizes.push({
+			exponent: cursor.uint8() >> 3,
+			mantissa: 0
+		});
+		return {
+			style: "none",
+			guardBits,
+			stepSizes
+		};
+	}
+	if (styleCode === 1 || styleCode === 2) {
+		while (cursor.position + 1 < segmentEnd) {
+			const packed = cursor.uint16();
+			stepSizes.push({
+				exponent: packed >> 11,
+				mantissa: packed & 2047
+			});
+		}
+		return {
+			style: styleCode === 1 ? "derived" : "expounded",
+			guardBits,
+			stepSizes
+		};
+	}
+	throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`QCD/QCC declares quantization style ${String(styleCode)}, which ISO/IEC 15444-1 Table A.28 does not define`);
+}
+function readComponentIndex(cursor, componentCount) {
+	return componentCount < 257 ? cursor.uint8() : cursor.uint16();
+}
+function emptyHeader() {
+	return {
+		coc: /* @__PURE__ */ new Map(),
+		qcc: /* @__PURE__ */ new Map(),
+		hasProgressionChanges: false,
+		hasRegionOfInterest: false,
+		hasPackedPacketHeaders: false
+	};
+}
+function freezeHeader(header) {
+	const base = {
+		coc: header.coc,
+		qcc: header.qcc,
+		hasProgressionChanges: header.hasProgressionChanges,
+		hasRegionOfInterest: header.hasRegionOfInterest,
+		hasPackedPacketHeaders: header.hasPackedPacketHeaders
+	};
+	if (header.cod !== void 0 && header.qcd !== void 0) return {
+		...base,
+		cod: header.cod,
+		qcd: header.qcd
+	};
+	if (header.cod !== void 0) return {
+		...base,
+		cod: header.cod
+	};
+	if (header.qcd !== void 0) return {
+		...base,
+		qcd: header.qcd
+	};
+	return base;
+}
+function readHeaderSegment(marker, cursor, header, componentCount, comments) {
+	const length = cursor.uint16();
+	if (length < 2) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`marker segment 0x${marker.toString(16)} declares a length of ${String(length)}, which is shorter than the length field itself`);
+	const segmentEnd = cursor.position + length - 2;
+	if (segmentEnd > cursor.data.length) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`marker segment 0x${marker.toString(16)} declares more data than the codestream carries`);
+	if (marker === MARKER_COD) header.cod = readCodingDefaults(cursor);
+	else if (marker === MARKER_COC) {
+		const component = readComponentIndex(cursor, componentCount);
+		header.coc.set(component, readCodingStyleParameters(cursor, (cursor.uint8() & 1) !== 0));
+	} else if (marker === MARKER_QCD) header.qcd = readQuantization(cursor, segmentEnd);
+	else if (marker === MARKER_QCC) {
+		const component = readComponentIndex(cursor, componentCount);
+		header.qcc.set(component, readQuantization(cursor, segmentEnd));
+	} else if (marker === MARKER_POC) header.hasProgressionChanges = true;
+	else if (marker === MARKER_RGN) header.hasRegionOfInterest = true;
+	else if (marker === MARKER_PPT) header.hasPackedPacketHeaders = true;
+	else if (marker === MARKER_COM) {
+		const registration = cursor.uint16();
+		const body = cursor.bytes(segmentEnd - cursor.position);
+		if (registration === 1) comments.push(Array.from(body, (byte) => String.fromCharCode(byte)).join(""));
+	}
+	cursor.position = segmentEnd;
+}
+function validateMainHeader(header) {
+	if (header.cod === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("the main header carries no COD marker, so no coding style is defined for any tile");
+	if (header.qcd === void 0) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("the main header carries no QCD marker, so no quantization is defined for any tile");
+}
+function parseJpeg2000Codestream(data) {
+	const cursor = new MarkerCursor(data);
+	if (cursor.remaining < 4 || cursor.uint16() !== MARKER_SOC) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("codestream does not begin with an SOC marker");
+	if (cursor.uint16() !== MARKER_SIZ) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("the SOC marker is not immediately followed by SIZ, which ISO/IEC 15444-1 A.3 requires");
+	const sizLength = cursor.uint16();
+	const sizEnd = cursor.position + sizLength - 2;
+	const siz = readImageSize(cursor, sizEnd);
+	cursor.position = sizEnd;
+	const comments = [];
+	const main = emptyHeader();
+	const tileParts = [];
+	let sawEoc = false;
+	for (;;) {
+		if (cursor.remaining < 2) break;
+		const marker = cursor.uint16();
+		if (marker === MARKER_EOC) {
+			sawEoc = true;
+			break;
+		}
+		if (marker === MARKER_PPM) throw new require_image_jpeg2000_errors.Jpeg2000UnsupportedError("the codestream carries a PPM marker (packed packet headers in the main header), an organisation this decoder does not reassemble");
+		if (marker === MARKER_SOT) {
+			cursor.position -= 2;
+			readTilePart(cursor, siz.components.length, tileParts, comments);
+			continue;
+		}
+		if (marker === MARKER_SOD || marker === MARKER_SOC) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`unexpected marker 0x${marker.toString(16)} in the main header`);
+		readHeaderSegment(marker, cursor, main, siz.components.length, comments);
+	}
+	validateMainHeader(main);
+	const numTilesWide = Math.ceil((siz.xsiz - siz.xtosiz) / siz.xtsiz);
+	const numTilesHigh = Math.ceil((siz.ysiz - siz.ytosiz) / siz.ytsiz);
+	return {
+		bytes: data,
+		siz,
+		main: freezeHeader(main),
+		tileParts,
+		comments,
+		numTilesWide,
+		numTilesHigh,
+		truncated: !sawEoc
+	};
+}
+function readTilePart(cursor, componentCount, tileParts, comments) {
+	const sotStart = cursor.position;
+	cursor.uint16();
+	const lsot = cursor.uint16();
+	if (lsot !== 10) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`SOT declares a length of ${String(lsot)}, but ISO/IEC 15444-1 A.4.2 fixes it at 10`);
+	const tileIndex = cursor.uint16();
+	const psot = cursor.uint32();
+	const partIndex = cursor.uint8();
+	cursor.uint8();
+	const header = emptyHeader();
+	for (;;) {
+		if (cursor.remaining < 2) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("a tile-part header ended without an SOD marker");
+		const marker = cursor.uint16();
+		if (marker === MARKER_SOD) break;
+		if (marker === MARKER_SOT || marker === MARKER_EOC) throw new require_image_jpeg2000_errors.Jpeg2000ParseError(`a tile-part header ended at marker 0x${marker.toString(16)} rather than at SOD`);
+		readHeaderSegment(marker, cursor, header, componentCount, comments);
+	}
+	const dataStart = cursor.position;
+	const declaredEnd = psot === 0 ? cursor.data.length : sotStart + psot;
+	const dataEnd = Math.min(declaredEnd, cursor.data.length);
+	if (dataEnd < dataStart) throw new require_image_jpeg2000_errors.Jpeg2000ParseError("a tile-part declares a Psot shorter than its own header");
+	const trimmedEnd = trimTrailingEoc(cursor.data, dataStart, dataEnd);
+	tileParts.push({
+		tileIndex,
+		partIndex,
+		header: freezeHeader(header),
+		dataStart,
+		dataEnd: trimmedEnd
+	});
+	cursor.position = dataEnd;
+}
+function trimTrailingEoc(data, start, end) {
+	if (end - start >= 2 && data[end - 2] === 255 && data[end - 1] === 217) return end - 2;
+	return end;
+}
+//#endregion
+exports.parseJpeg2000Codestream = parseJpeg2000Codestream;

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

@@ -0,0 +1,78 @@
+//#region src/image/jpeg2000-codestream.d.ts
+type Jpeg2000ProgressionOrder = 'LRCP' | 'RLCP' | 'RPCL' | 'PCRL' | 'CPRL';
+type Jpeg2000Transform = 'reversible-5-3' | 'irreversible-9-7';
+type Jpeg2000QuantizationStyle = 'none' | 'derived' | 'expounded';
+interface Jpeg2000ComponentSize {
+  readonly signed: boolean;
+  readonly bitDepth: number;
+  readonly dx: number;
+  readonly dy: number;
+}
+interface Jpeg2000ImageSize {
+  readonly xsiz: number;
+  readonly ysiz: number;
+  readonly xosiz: number;
+  readonly yosiz: number;
+  readonly xtsiz: number;
+  readonly ytsiz: number;
+  readonly xtosiz: number;
+  readonly ytosiz: number;
+  readonly components: readonly Jpeg2000ComponentSize[];
+}
+interface Jpeg2000PrecinctSize {
+  readonly ppx: number;
+  readonly ppy: number;
+}
+interface Jpeg2000CodingStyle {
+  readonly decompositionLevels: number;
+  readonly codeBlockWidthExp: number;
+  readonly codeBlockHeightExp: number;
+  readonly codeBlockStyle: number;
+  readonly transform: Jpeg2000Transform;
+  readonly precinctSizes: readonly Jpeg2000PrecinctSize[];
+}
+interface Jpeg2000CodingDefaults extends Jpeg2000CodingStyle {
+  readonly progressionOrder: Jpeg2000ProgressionOrder;
+  readonly layers: number;
+  readonly multipleComponentTransform: boolean;
+  readonly useSop: boolean;
+  readonly useEph: boolean;
+}
+interface Jpeg2000StepSize {
+  readonly exponent: number;
+  readonly mantissa: number;
+}
+interface Jpeg2000Quantization {
+  readonly style: Jpeg2000QuantizationStyle;
+  readonly guardBits: number;
+  readonly stepSizes: readonly Jpeg2000StepSize[];
+}
+interface Jpeg2000HeaderOverrides {
+  readonly cod?: Jpeg2000CodingDefaults;
+  readonly coc: ReadonlyMap<number, Jpeg2000CodingStyle>;
+  readonly qcd?: Jpeg2000Quantization;
+  readonly qcc: ReadonlyMap<number, Jpeg2000Quantization>;
+  readonly hasProgressionChanges: boolean;
+  readonly hasRegionOfInterest: boolean;
+  readonly hasPackedPacketHeaders: boolean;
+}
+interface Jpeg2000TilePart {
+  readonly tileIndex: number;
+  readonly partIndex: number;
+  readonly header: Jpeg2000HeaderOverrides;
+  readonly dataStart: number;
+  readonly dataEnd: number;
+}
+interface Jpeg2000Codestream {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly siz: Jpeg2000ImageSize;
+  readonly main: Jpeg2000HeaderOverrides;
+  readonly tileParts: readonly Jpeg2000TilePart[];
+  readonly comments: readonly string[];
+  readonly numTilesWide: number;
+  readonly numTilesHigh: number;
+  readonly truncated: boolean;
+}
+declare function parseJpeg2000Codestream(data: Uint8Array<ArrayBuffer>): Jpeg2000Codestream;
+//#endregion
+export { Jpeg2000Codestream, Jpeg2000CodingDefaults, Jpeg2000CodingStyle, Jpeg2000ComponentSize, Jpeg2000HeaderOverrides, Jpeg2000ImageSize, Jpeg2000PrecinctSize, Jpeg2000ProgressionOrder, Jpeg2000Quantization, Jpeg2000QuantizationStyle, Jpeg2000StepSize, Jpeg2000TilePart, Jpeg2000Transform, parseJpeg2000Codestream };

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

@@ -0,0 +1,78 @@
+//#region src/image/jpeg2000-codestream.d.ts
+type Jpeg2000ProgressionOrder = 'LRCP' | 'RLCP' | 'RPCL' | 'PCRL' | 'CPRL';
+type Jpeg2000Transform = 'reversible-5-3' | 'irreversible-9-7';
+type Jpeg2000QuantizationStyle = 'none' | 'derived' | 'expounded';
+interface Jpeg2000ComponentSize {
+  readonly signed: boolean;
+  readonly bitDepth: number;
+  readonly dx: number;
+  readonly dy: number;
+}
+interface Jpeg2000ImageSize {
+  readonly xsiz: number;
+  readonly ysiz: number;
+  readonly xosiz: number;
+  readonly yosiz: number;
+  readonly xtsiz: number;
+  readonly ytsiz: number;
+  readonly xtosiz: number;
+  readonly ytosiz: number;
+  readonly components: readonly Jpeg2000ComponentSize[];
+}
+interface Jpeg2000PrecinctSize {
+  readonly ppx: number;
+  readonly ppy: number;
+}
+interface Jpeg2000CodingStyle {
+  readonly decompositionLevels: number;
+  readonly codeBlockWidthExp: number;
+  readonly codeBlockHeightExp: number;
+  readonly codeBlockStyle: number;
+  readonly transform: Jpeg2000Transform;
+  readonly precinctSizes: readonly Jpeg2000PrecinctSize[];
+}
+interface Jpeg2000CodingDefaults extends Jpeg2000CodingStyle {
+  readonly progressionOrder: Jpeg2000ProgressionOrder;
+  readonly layers: number;
+  readonly multipleComponentTransform: boolean;
+  readonly useSop: boolean;
+  readonly useEph: boolean;
+}
+interface Jpeg2000StepSize {
+  readonly exponent: number;
+  readonly mantissa: number;
+}
+interface Jpeg2000Quantization {
+  readonly style: Jpeg2000QuantizationStyle;
+  readonly guardBits: number;
+  readonly stepSizes: readonly Jpeg2000StepSize[];
+}
+interface Jpeg2000HeaderOverrides {
+  readonly cod?: Jpeg2000CodingDefaults;
+  readonly coc: ReadonlyMap<number, Jpeg2000CodingStyle>;
+  readonly qcd?: Jpeg2000Quantization;
+  readonly qcc: ReadonlyMap<number, Jpeg2000Quantization>;
+  readonly hasProgressionChanges: boolean;
+  readonly hasRegionOfInterest: boolean;
+  readonly hasPackedPacketHeaders: boolean;
+}
+interface Jpeg2000TilePart {
+  readonly tileIndex: number;
+  readonly partIndex: number;
+  readonly header: Jpeg2000HeaderOverrides;
+  readonly dataStart: number;
+  readonly dataEnd: number;
+}
+interface Jpeg2000Codestream {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly siz: Jpeg2000ImageSize;
+  readonly main: Jpeg2000HeaderOverrides;
+  readonly tileParts: readonly Jpeg2000TilePart[];
+  readonly comments: readonly string[];
+  readonly numTilesWide: number;
+  readonly numTilesHigh: number;
+  readonly truncated: boolean;
+}
+declare function parseJpeg2000Codestream(data: Uint8Array<ArrayBuffer>): Jpeg2000Codestream;
+//#endregion
+export { Jpeg2000Codestream, Jpeg2000CodingDefaults, Jpeg2000CodingStyle, Jpeg2000ComponentSize, Jpeg2000HeaderOverrides, Jpeg2000ImageSize, Jpeg2000PrecinctSize, Jpeg2000ProgressionOrder, Jpeg2000Quantization, Jpeg2000QuantizationStyle, Jpeg2000StepSize, Jpeg2000TilePart, Jpeg2000Transform, parseJpeg2000Codestream };