ag-psd 23.1.1 → 25.0.0

package/src/psd.ts

@@ -264,7 +264,7 @@ export type Justification = 'left' | 'right' | 'center' | 'justify-left' | 'just
 export type LineCapType = 'butt' | 'round' | 'square';
 export type LineJoinType = 'miter' | 'round' | 'bevel';
 export type LineAlignment = 'inside' | 'center' | 'outside';
-export type InterpolationMethod = 'classic' | 'perceptual' | 'linear';
+export type InterpolationMethod = 'classic' | 'perceptual' | 'linear' | 'smooth';
 
 export interface Warp {
 	style?: WarpStyle;
@@ -457,6 +457,7 @@ export interface ExtraGradientInfo {
 	scale?: number;
 	angle?: number;
 	dither?: boolean;
+	interpolationMethod?: InterpolationMethod;
 	reverse?: boolean;
 	align?: boolean;
 	offset?: { x: number; y: number; };
@@ -1125,7 +1126,19 @@ type FilterVariant = {
 		quads: number[][]; // quad indices
 		vertices: { x: UnitsValue; y: UnitsValue; }[];
 		warpedVertices: { x: UnitsValue; y: UnitsValue; }[];
-	}
+	};
+} | {
+	type: 'curves';
+	filter: {
+		presetKind: 'custom' | 'default';
+		adjustments: ({
+			channels: ('composite' | 'red' | 'green' | 'blue')[];
+			curve: { x: number; y: number; curved?: boolean; }[];
+		} | {
+			channels: ('composite' | 'red' | 'green' | 'blue')[];
+			values: number[];
+		})[];
+	};
 };
 
 /*
@@ -1367,11 +1380,14 @@ export interface LayerAdditionalInfo {
 		keyDescriptorList: KeyDescriptorItem[];
 	};
 	compositorUsed?: {
+		version?: { major: number; minor: number; fix: number; };
+		photoshopVersion?: { major: number; minor: number; fix: number; };
 		description: string;
 		reason: string;
 		engine: string;
 		enableCompCore?: string;
 		enableCompCoreGPU?: string;
+		enableCompCoreThreads?: string;
 		compCoreSupport?: string;
 		compCoreGPUSupport?: string;
 	};
@@ -1405,6 +1421,10 @@ export interface LayerAdditionalInfo {
 			data: Uint8Array;
 		} | undefined)[];
 		extra?: {
+			top: number;
+			left: number;
+			bottom: number;
+			right: number;
 			compressionMode: number;
 			data: Uint8Array;
 		};
@@ -1422,6 +1442,12 @@ export interface LayerAdditionalInfo {
 		colorSpace: Color;
 		opacity: number;
 	};
+	blendingRanges?: {
+		compositeGrayBlendSource: number[];
+		compositeGraphBlendDestinationRange: number[];
+		ranges: { sourceRange: number[]; destRange: number[]; }[];
+	};
+	vowv?: number; // ???
 
 	// Base64 encoded raw EngineData, currently just kept in original state to support
 	// loading and modifying PSD file without breaking text layers.
@@ -1665,6 +1691,7 @@ export interface Psd extends LayerAdditionalInfo {
 	channels?: number;
 	bitsPerChannel?: number;
 	colorMode?: ColorMode;
+	palette?: RGB[]; // colors for indexed color mode
 	children?: Layer[];
 	canvas?: HTMLCanvasElement;
 	imageData?: PixelData;

package/src/psdReader.ts

@@ -9,7 +9,7 @@ interface ChannelInfo {
 	length: number;
 }
 
-export const supportedColorModes = [ColorMode.Bitmap, ColorMode.Grayscale, ColorMode.RGB];
+export const supportedColorModes = [ColorMode.Bitmap, ColorMode.Grayscale, ColorMode.RGB, ColorMode.Indexed];
 const colorModes = ['bitmap', 'grayscale', 'indexed', 'RGB', 'CMYK', 'multichannel', 'duotone', 'lab'];
 
 function setupGrayscale(data: PixelData) {
@@ -131,7 +131,7 @@ export function readPascalString(reader: PsdReader, padTo: number) {
 	let length = readUint8(reader);
 	const text = length ? readShortString(reader, length) : '';
 
-	while (++length % padTo) {
+	while (++length % padTo) { // starts with length + 1 so we count the size byte too
 		reader.offset++;
 	}
 
@@ -240,14 +240,19 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 	readSection(reader, 1, left => {
 		if (!left()) return;
 
-		// const numbers: number[] = [];
-		// console.log('color mode', left());
-		// while (left() > 0) {
-		// 	numbers.push(readUint32(reader));
-		// }
-		// console.log('color mode', numbers);
+		if (colorMode === ColorMode.Indexed) {
+			// should have 256 colors here saved as 8bit channels RGB
+			if (left() != 768) throw new Error('Invalid color palette size');
+
+			psd.palette = [];
+			for (let i = 0; i < 256; i++) psd.palette.push({ r: readUint8(reader), g: 0, b: 0 });
+			for (let i = 0; i < 256; i++) psd.palette[i].g = readUint8(reader);
+			for (let i = 0; i < 256; i++) psd.palette[i].b = readUint8(reader);
+		} else {
+			// TODO: unknown format for duotone, also seems to have some data here for 32bit colors
+			// if (options.throwForMissingFeatures) throw new Error('Color mode data not supported');
+		}
 
-		// if (options.throwForMissingFeatures) throw new Error('Color mode data not supported');
 		skipBytes(reader, left());
 	});
 
@@ -441,7 +446,8 @@ function readLayerRecord(reader: PsdReader, psd: Psd) {
 		const mask = readLayerMaskData(reader);
 		if (mask) layer.mask = mask;
 
-		/*const blendingRanges =*/ readLayerBlendingRanges(reader);
+		const blendingRanges = readLayerBlendingRanges(reader);
+		if (blendingRanges) layer.blendingRanges = blendingRanges;
 		layer.name = readPascalString(reader, 1); // should be padded to 4, but is not sometimes
 
 		// HACK: fix for sometimes layer.name string not being padded correctly, just skip until we get valid signature
@@ -501,15 +507,19 @@ function readLayerMaskData(reader: PsdReader) {
 	});
 }
 
+function readBlendingRange(reader: PsdReader) {
+	return [readUint8(reader), readUint8(reader), readUint8(reader), readUint8(reader)];
+}
+
 function readLayerBlendingRanges(reader: PsdReader) {
 	return readSection(reader, 1, left => {
-		const compositeGrayBlendSource = readUint32(reader);
-		const compositeGraphBlendDestinationRange = readUint32(reader);
-		const ranges = [];
+		const compositeGrayBlendSource = readBlendingRange(reader);
+		const compositeGraphBlendDestinationRange = readBlendingRange(reader);
+		const ranges: { sourceRange: number[]; destRange: number[]; }[] = [];
 
 		while (left() > 0) {
-			const sourceRange = readUint32(reader);
-			const destRange = readUint32(reader);
+			const sourceRange = readBlendingRange(reader);
+			const destRange = readBlendingRange(reader);
 			ranges.push({ sourceRange, destRange });
 		}
 
@@ -535,7 +545,10 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 		}
 	}
 
-	if (RAW_IMAGE_DATA) (layer as any).imageDataRaw = [];
+	if (RAW_IMAGE_DATA) {
+		(layer as any).imageDataRaw = [];
+		(layer as any).imageDataRawCompression = [];
+	}
 
 	for (const channel of channels) {
 		if (channel.length === 0) continue;
@@ -575,6 +588,7 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 				readData(reader, channel.length, maskData, compression, maskWidth, maskHeight, psd.bitsPerChannel ?? 8, 0, reader.large, 4);
 
 				if (RAW_IMAGE_DATA) {
+					(layer as any).maskDataRawCompression = compression;
 					(layer as any).maskDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
 				}
 
@@ -607,6 +621,7 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 			readData(reader, channel.length, targetData, compression, layerWidth, layerHeight, psd.bitsPerChannel ?? 8, offset, reader.large, cmyk ? 5 : 4);
 
 			if (RAW_IMAGE_DATA) {
+				(layer as any).imageDataRawCompression[channel.id] = compression;
 				(layer as any).imageDataRaw[channel.id] = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start + 2, channel.length - 2);
 			}
 
@@ -633,7 +648,7 @@ function readLayerChannelImageData(reader: PsdReader, psd: Psd, layer: Layer, ch
 	}
 }
 
-function readData(reader: PsdReader, length: number, data: PixelData | undefined, compression: Compression, width: number, height: number, bitDepth: number, offset: number, large: boolean, step: number) {
+export function readData(reader: PsdReader, length: number, data: PixelData | undefined, compression: Compression, width: number, height: number, bitDepth: number, offset: number, large: boolean, step: number) {
 	if (compression === Compression.RawData) {
 		readDataRaw(reader, data, width, height, bitDepth, step, offset);
 	} else if (compression === Compression.RleCompressed) {
@@ -692,13 +707,17 @@ export function readAdditionalLayerInfo(reader: PsdReader, target: LayerAddition
 	}, false, u64);
 }
 
-function createImageDataBitDepth(width: number, height: number, bitDepth: number): PixelData {
+export function createImageDataBitDepth(width: number, height: number, bitDepth: number, channels = 4): PixelData {
 	if (bitDepth === 1 || bitDepth === 8) {
-		return createImageData(width, height);
+		if (channels === 4) {
+			return createImageData(width, height);
+		} else {
+			return { width, height, data: new Uint8ClampedArray(width * height * channels) };
+		}
 	} else if (bitDepth === 16) {
-		return { width, height, data: new Uint16Array(width * height * 4) };
+		return { width, height, data: new Uint16Array(width * height * channels) };
 	} else if (bitDepth === 32) {
-		return { width, height, data: new Float32Array(width * height * 4) };
+		return { width, height, data: new Float32Array(width * height * channels) };
 	} else {
 		throw new Error(`Invalid bitDepth (${bitDepth})`);
 	}
@@ -763,8 +782,29 @@ function readImageData(reader: PsdReader, psd: Psd) {
 			}
 			break;
 		}
+		case ColorMode.Indexed: {
+			if (bitsPerChannel !== 8) throw new Error('bitsPerChannel Not supproted');
+			if (psd.channels !== 1) throw new Error('Invalid channel count');
+			if (!psd.palette) throw new Error('Missing color palette');
+
+			if (compression === Compression.RawData) {
+				throw new Error(`Not implemented`);
+			} else if (compression === Compression.RleCompressed) {
+				const indexedImageData: PixelData = {
+					width: imageData.width,
+					height: imageData.height,
+					data: new Uint8Array(imageData.width * imageData.height),
+				};
+				readDataRLE(reader, indexedImageData, psd.width, psd.height, bitsPerChannel, 1, [0], reader.large);
+				indexedToRgb(indexedImageData, imageData, psd.palette);
+			} else {
+				throw new Error(`Not implemented`);
+			}
+
+			break;
+		}
 		case ColorMode.CMYK: {
-			if (psd.bitsPerChannel !== 8) throw new Error('bitsPerChannel Not supproted');
+			if (bitsPerChannel !== 8) throw new Error('bitsPerChannel Not supproted');
 			if (psd.channels !== 4) throw new Error(`Invalid channel count`);
 
 			const channels = [0, 1, 2, 3];
@@ -784,10 +824,12 @@ function readImageData(reader: PsdReader, psd: Psd) {
 				};
 
 				const start = reader.offset;
-				readDataRLE(reader, cmykImageData, psd.width, psd.height, psd.bitsPerChannel ?? 8, 5, channels, reader.large);
+				readDataRLE(reader, cmykImageData, psd.width, psd.height, bitsPerChannel, 5, channels, reader.large);
 				cmykToRgb(cmykImageData, imageData, true);
 
 				if (RAW_IMAGE_DATA) (psd as any).imageDataRaw = new Uint8Array(reader.view.buffer, reader.view.byteOffset + start, reader.offset - start);
+			} else {
+				throw new Error(`Not implemented`);
 			}
 
 			break;
@@ -848,6 +890,20 @@ function cmykToRgb(cmyk: PixelData, rgb: PixelData, reverseAlpha: boolean) {
 	// }
 }
 
+function indexedToRgb(indexed: PixelData, rgb: PixelData, palette: RGB[]) {
+	const size = indexed.width * indexed.height;
+	const srcData = indexed.data;
+	const dstData = rgb.data;
+
+	for (let src = 0, dst = 0; src < size; src++, dst += 4) {
+		const c = palette[srcData[src]];
+		dstData[dst + 0] = c.r;
+		dstData[dst + 1] = c.g;
+		dstData[dst + 2] = c.b;
+		dstData[dst + 3] = 255;
+	}
+}
+
 function verifyCompatible(a: PixelArray, b: PixelArray) {
 	if ((a.byteLength / a.length) !== (b.byteLength / b.length)) {
 		throw new Error('Invalid array types');

package/src/psdWriter.ts

@@ -7,13 +7,14 @@ export interface PsdWriter {
 	offset: number;
 	buffer: ArrayBuffer;
 	view: DataView;
+	tempBuffer: Uint8Array | undefined;
 }
 
 export function createWriter(size = 4096): PsdWriter {
 	const buffer = new ArrayBuffer(size);
 	const view = new DataView(buffer);
 	const offset = 0;
-	return { buffer, view, offset };
+	return { buffer, view, offset, tempBuffer: undefined };
 }
 
 export function getWriterBuffer(writer: PsdWriter) {
@@ -173,11 +174,16 @@ export function writeSection(writer: PsdWriter, round: number, func: () => void,
 	let length = writer.offset - offset - 4;
 	let len = length;
 
-	while ((writer.offset % round) !== 0) {
+	while ((len % round) !== 0) {
 		writeUint8(writer, 0);
 		len++;
 	}
 
+	// while ((writer.offset % round) !== 0) {
+	// 	writeUint8(writer, 0);
+	// 	len++;
+	// }
+
 	if (writeTotalLength) {
 		length = len;
 	}
@@ -234,7 +240,7 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 
 	const globalAlpha = !!imageData && hasAlpha(imageData);
 	const maxBufferSize = Math.max(getLargestLayerSize(psd.children), 4 * 2 * psd.width * psd.height + 2 * psd.height);
-	const tempBuffer = new Uint8Array(maxBufferSize);
+	writer.tempBuffer = new Uint8Array(maxBufferSize);
 
 	// header
 	writeSignature(writer, '8BPS');
@@ -248,7 +254,13 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 
 	// color mode data
 	writeSection(writer, 1, () => {
-		// TODO: implement
+		if (psd.palette) {
+			for (let i = 0; i < 256; i++) writeUint8(writer, psd.palette[i]?.r || 0);
+			for (let i = 0; i < 256; i++) writeUint8(writer, psd.palette[i]?.g || 0);
+			for (let i = 0; i < 256; i++) writeUint8(writer, psd.palette[i]?.b || 0);
+		}
+
+		// TODO: other data?
 	});
 
 	// image resources
@@ -267,7 +279,7 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 
 	// layer and mask info
 	writeSection(writer, 2, () => {
-		writeLayerInfo(tempBuffer, writer, psd, globalAlpha, opt);
+		writeLayerInfo(writer, psd, globalAlpha, opt);
 		writeGlobalLayerMaskInfo(writer, psd.globalLayerMaskInfo);
 		writeAdditionalLayerInfo(writer, psd, psd, opt);
 	}, undefined, !!opt.psb);
@@ -302,11 +314,11 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 			}
 		}
 
-		writeBytes(writer, writeDataRLE(tempBuffer, data, channels, !!options.psb));
+		writeBytes(writer, writeDataRLE(writer.tempBuffer, data, channels, !!options.psb));
 	}
 }
 
-function writeLayerInfo(tempBuffer: Uint8Array, writer: PsdWriter, psd: Psd, globalAlpha: boolean, options: ExtendedWriteOptions) {
+function writeLayerInfo(writer: PsdWriter, psd: Psd, globalAlpha: boolean, options: ExtendedWriteOptions) {
 	writeSection(writer, 4, () => {
 		const layers: Layer[] = [];
 
@@ -316,7 +328,7 @@ function writeLayerInfo(tempBuffer: Uint8Array, writer: PsdWriter, psd: Psd, glo
 
 		writeInt16(writer, globalAlpha ? -layers.length : layers.length);
 
-		const layersData = layers.map((l, i) => getChannels(tempBuffer, l, i === 0, options));
+		const layersData = layers.map((l, i) => getChannels(writer.tempBuffer!, l, i === 0, options));
 
 		// layer records
 		for (const layerData of layersData) {
@@ -351,7 +363,7 @@ function writeLayerInfo(tempBuffer: Uint8Array, writer: PsdWriter, psd: Psd, glo
 			writeUint8(writer, 0); // filler
 			writeSection(writer, 1, () => {
 				writeLayerMaskData(writer, layer, layerData);
-				writeLayerBlendingRanges(writer, psd);
+				writeLayerBlendingRanges(writer, layer);
 				writePascalString(writer, (layer.name || '').substring(0, 255), 4);
 				writeAdditionalLayerInfo(writer, layer, psd, options);
 			});
@@ -410,17 +422,25 @@ function writeLayerMaskData(writer: PsdWriter, { mask }: Layer, layerData: Layer
 	});
 }
 
-function writeLayerBlendingRanges(writer: PsdWriter, psd: Psd) {
+function writerBlendingRange(writer: PsdWriter, range: number[]) {
+	writeUint8(writer, range[0]);
+	writeUint8(writer, range[1]);
+	writeUint8(writer, range[2]);
+	writeUint8(writer, range[3]);
+}
+
+function writeLayerBlendingRanges(writer: PsdWriter, layer: Layer) {
 	writeSection(writer, 1, () => {
-		writeUint32(writer, 65535);
-		writeUint32(writer, 65535);
+		const ranges = layer.blendingRanges;
 
-		let channels = psd.channels || 0; // TODO: use always 4 instead ?
-		// channels = 4; // TESTING
+		if (ranges) {
+			writerBlendingRange(writer, ranges.compositeGrayBlendSource);
+			writerBlendingRange(writer, ranges.compositeGraphBlendDestinationRange);
 
-		for (let i = 0; i < channels; i++) {
-			writeUint32(writer, 65535);
-			writeUint32(writer, 65535);
+			for (const r of ranges.ranges) {
+				writerBlendingRange(writer, r.sourceRange);
+				writerBlendingRange(writer, r.destRange);
+			}
 		}
 	});
 }
@@ -449,10 +469,10 @@ function writeAdditionalLayerInfo(writer: PsdWriter, target: LayerAdditionalInfo
 
 		if (handler.has(target)) {
 			const large = options.psb && largeAdditionalInfoKeys.indexOf(key) !== -1;
-			const writeTotalLength = key !== 'Txt2' && key !== 'cinf' && key !== 'extn';
+			const writeTotalLength = key !== 'Txt2' && key !== 'cinf' && key !== 'extn' && key !== 'CAI ' && key !== 'OCIO';
 			const fourBytes = key === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
 				key === 'vogk' || key === 'SoLd' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
-				key === 'lmfx' || key === 'lrFX' || key === 'cinf' || key === 'PlLd' || key === 'Anno';
+				key === 'lmfx' || key === 'lrFX' || key === 'cinf' || key === 'PlLd' || key === 'Anno' || key === 'CAI ' || key === 'OCIO' || key === 'GenI' || key === 'FEid';
 
 			writeSignature(writer, large ? '8B64' : '8BIM');
 			writeSignature(writer, key);
@@ -462,10 +482,12 @@ function writeAdditionalLayerInfo(writer: PsdWriter, target: LayerAdditionalInfo
 		}
 	}
 }
-
 function addChildren(layers: Layer[], children: Layer[] | undefined) {
 	if (!children) return;
 
+	// const layerIds = [];
+	// const timestamps = []
+
 	for (const c of children) {
 		if (c.children && c.canvas) throw new Error(`Invalid layer, cannot have both 'canvas' and 'children' properties`);
 		if (c.children && c.imageData) throw new Error(`Invalid layer, cannot have both 'imageData' and 'children' properties`);
@@ -476,6 +498,19 @@ function addChildren(layers: Layer[], children: Layer[] | undefined) {
 				sectionDivider: {
 					type: SectionDividerType.BoundingSectionDivider,
 				},
+				// nameSource: 'lset',
+				// id: layerIds.shift(),
+				// protected: {
+				// 	transparency: false,
+				// 	composite: false,
+				// 	position: false,
+				// },
+				// layerColor: 'none',
+				// timestamp: timestamps.shift(),
+				// referencePoint: {
+				// 	x: 0,
+				// 	y: 0,
+				// },
 			});
 			addChildren(layers, c.children);
 			layers.push({
@@ -578,7 +613,7 @@ function getChannels(
 			if (RAW_IMAGE_DATA && (layer as any).maskDataRaw) {
 				// console.log('written raw layer image data');
 				buffer = (layer as any).maskDataRaw;
-				compression = Compression.RleCompressed;
+				compression = (layer as any).maskDataRawCompression;
 			} else if (options.compress) {
 				buffer = writeDataZipWithoutPrediction(imageData, [0]);
 				compression = Compression.ZipWithoutPrediction;
@@ -683,7 +718,7 @@ function getLayerChannels(tempBuffer: Uint8Array, layer: Layer, background: bool
 		if (RAW_IMAGE_DATA && (layer as any).imageDataRaw) {
 			// console.log('written raw layer image data');
 			buffer = (layer as any).imageDataRaw[channelId];
-			compression = Compression.RleCompressed;
+			compression = (layer as any).imageDataRawCompression[channelId];
 		} else if (options.compress) {
 			buffer = writeDataZipWithoutPrediction(data, [offset]);
 			compression = Compression.ZipWithoutPrediction;