ag-psd 31.0.3 → 33.0.0

package/src/psdWriter.ts

@@ -1,20 +1,22 @@
 import { Psd, Layer, LayerAdditionalInfo, ColorMode, SectionDividerType, WriteOptions, Color, GlobalLayerMaskInfo, PixelData, LayerMaskData, Compression, ChannelID, PatternInfo } from './psd';
-import { hasAlpha, createCanvas, writeDataRLE, LayerChannelData, ChannelData, offsetForChannel, createImageData, fromBlendMode, clamp, LayerMaskFlags, MaskParams, ColorSpace, Bounds, largeAdditionalInfoKeys, RAW_IMAGE_DATA, writeDataZipWithoutPrediction, imageDataToCanvas } from './helpers';
-import { ExtendedWriteOptions, infoHandlers } from './additionalInfo';
+import { hasAlpha, createCanvas, writeDataRLE, LayerChannelData, ChannelData, offsetForChannel, createImageData, fromBlendMode, clamp, LayerMaskFlags, MaskParams, ColorSpace, Bounds, largeAdditionalInfoKeys, writeDataZipWithoutPrediction, imageDataToCanvas, denormalizeLabAB } from './helpers';
+import { ExtendedWriteOptions, infoHandlers, infoHandlersMap } from './additionalInfo';
 import { InternalImageResources, resourceHandlers } from './imageResources';
+import { getCompositeImageData, getLayerImageData, getLayerMaskImageData, getLayerRealMaskImageData } from './psdReader';
 
 export interface PsdWriter {
 	offset: number;
 	buffer: ArrayBuffer;
 	view: DataView;
 	tempBuffer: Uint8Array | undefined;
+	log(...args: any[]): void;
 }
 
 export function createWriter(size = 4096): PsdWriter {
 	const buffer = new ArrayBuffer(size);
 	const view = new DataView(buffer);
 	const offset = 0;
-	return { buffer, view, offset, tempBuffer: undefined };
+	return { buffer, view, offset, tempBuffer: undefined, log: console.log };
 }
 
 export function getWriterBuffer(writer: PsdWriter) {
@@ -153,39 +155,45 @@ export function writeUnicodeStringWithPadding(writer: PsdWriter, text: string) {
 	writeUint16(writer, 0);
 }
 
-function getLargestLayerSize(layers: Layer[] = []): number {
+// Worst-case size of writeDataRLE output for a single channel: per row the byte count (2 bytes, 4 for PSB)
+// plus PackBits data, which in the worst case is all literal runs of up to 128 bytes, each with 1 header byte.
+export function getRLEChannelBound(width: number, height: number, large: boolean) {
+	return height * ((large ? 4 : 2) + width + Math.ceil(width / 128));
+}
+
+function getLargestLayerSize(layers: Layer[] = [], large: boolean): number {
 	let max = 0;
 
 	for (const layer of layers) {
-		const { width, height } = getLayerDimentions(layer);
-		max = Math.max(max, 2 * height + 2 * width * height);
-
-		if (layer.mask) {
-			const { width, height } = getLayerDimentions(layer.mask);
-			max = Math.max(max, 2 * height + 2 * width * height);
-		}
-
-		if (layer.realMask) {
-			const { width, height } = getLayerDimentions(layer.realMask);
-			max = Math.max(max, 2 * height + 2 * width * height);
+		for (const target of [layer, layer.mask, layer.realMask]) {
+			if (target) {
+				const { width, height } = getLayerDimentions(target);
+				max = Math.max(max, getRLEChannelBound(width, height, large));
+			}
 		}
 
 		if (layer.children) {
-			max = Math.max(max, getLargestLayerSize(layer.children));
+			max = Math.max(max, getLargestLayerSize(layer.children, large));
 		}
 	}
 
 	return max;
 }
 
+export function writeUint64(writer: PsdWriter, value: number) {
+	writeUint32(writer, Math.floor(value / 0x100000000));
+	writeUint32(writer, value >>> 0);
+}
+
 export function writeSection(writer: PsdWriter, round: number, func: () => void, writeTotalLength = false, large = false) {
-	if (large) writeUint32(writer, 0);
 	const offset = writer.offset;
+	if (large) writeUint32(writer, 0);
 	writeUint32(writer, 0);
+	const start = writer.offset;
 
 	func();
 
-	let length = writer.offset - offset - 4;
+	let length = writer.offset - start;
 	let len = length;
 
 	while (len % round) {
@@ -193,32 +201,34 @@ export function writeSection(writer: PsdWriter, round: number, func: () => void,
 		len++;
 	}
 
-	// while (writer.offset % round) {
-	// 	writeUint8(writer, 0);
-	// 	len++;
-	// }
-
 	if (writeTotalLength) {
 		length = len;
 	}
 
-	writer.view.setUint32(offset, length, false);
+	if (large) {
+		writer.view.setUint32(offset, Math.floor(length / 0x100000000), false);
+		writer.view.setUint32(offset + 4, length >>> 0, false);
+	} else {
+		if (length > 0xffffffff) throw new Error('Section too large, use PSB format instead');
+		writer.view.setUint32(offset, length, false);
+	}
+}
+
+function verifyPixelData(data: PixelData | undefined, name: string) {
+	// check element size instead of instanceof, so arrays from other realms (iframes, workers, vm) are accepted
+	const bytesPerElement = data && (data.data as any).BYTES_PER_ELEMENT;
+	if (bytesPerElement !== undefined && bytesPerElement !== 1) {
+		throw new Error(`${name} has incorrect bitDepth (only 8-bit Uint8Array or Uint8ClampedArray data is supported for writing)`);
+	}
 }
 
 function verifyBitCount(target: Psd | Layer) {
 	target.children?.forEach(verifyBitCount);
 
-	const data = target.imageData;
-	if (data && (data.data instanceof Uint32Array || data.data instanceof Uint16Array)) {
-		throw new Error('imageData has incorrect bitDepth');
-	}
+	verifyPixelData(target.imageData, 'imageData');
 
-	if ('mask' in target && target.mask) {
-		const data = target.mask.imageData;
-		if (data && (data.data instanceof Uint32Array || data.data instanceof Uint16Array)) {
-			throw new Error('mask imageData has incorrect bitDepth');
-		}
-	}
+	if ('mask' in target) verifyPixelData(target.mask?.imageData, 'mask imageData');
+	if ('realMask' in target) verifyPixelData(target.realMask?.imageData, 'realMask imageData');
 }
 
 export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}) {
@@ -233,11 +243,29 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 	if (bitsPerChannel !== 8)
 		throw new Error('bitsPerChannel other than 8 are not supported for writing');
 
+	if (options.log) writer.log = options.log;
+
+	const layers: Layer[] = [];
+	addChildren(layers, psd.children);
+	if (!layers.length) layers.push({});
+
 	verifyBitCount(psd);
 
 	const imageResources: InternalImageResources = { ...psd.imageResources };
 	const opt: ExtendedWriteOptions = { ...options, layerIds: new Set(), layerToId: new Map() };
 
+	// document is always written in RGB color mode, skip resources specific to original color mode
+	if (psd.colorMode !== undefined && psd.colorMode !== ColorMode.RGB) {
+		delete imageResources.iccProfile;
+		delete imageResources.indexedColorCount;
+		delete imageResources.transparencyIndex;
+		delete imageResources.alphaChannelDisplayInfo;
+		delete imageResources.colorHalftoneScreens;
+		delete imageResources.grayscaleHalftoneScreens;
+		delete imageResources.colorTransferFunctions;
+		delete imageResources.grayscaleTransferFunctions;
+	}
+
 	if (opt.generateThumbnail) {
 		imageResources.thumbnail = createThumbnail(psd);
 	}
@@ -248,12 +276,16 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 		imageData = psd.canvas.getContext('2d')!.getImageData(0, 0, psd.canvas.width, psd.canvas.height);
 	}
 
+	if (!imageData && psd.rawCompositeData) { // read with `useRawData` option
+		imageData = getCompositeImageData(psd);
+	}
+
 	if (imageData && (psd.width !== imageData.width || psd.height !== imageData.height))
 		throw new Error('Document canvas must have the same size as document');
 
 	const globalAlpha = !!imageData && hasAlpha(imageData);
-	const maxBufferSize = Math.max(getLargestLayerSize(psd.children), 4 * 2 * psd.width * psd.height + 2 * psd.height);
-	writer.tempBuffer = new Uint8Array(maxBufferSize);
+	// only used for encoding a single layer channel at a time, composite image is encoded directly into the writer buffer
+	writer.tempBuffer = new Uint8Array(getLargestLayerSize(psd.children, !!options.psb));
 
 	// header
 	writeSignature(writer, '8BPS');
@@ -265,20 +297,8 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 	writeUint16(writer, bitsPerChannel); // bits per channel
 	writeUint16(writer, ColorMode.RGB); // we only support saving RGB right now
 
-	// color mode data
-	writeSection(writer, 1, () => {
-		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?
-	});
-
-	const layers: Layer[] = [];
-	addChildren(layers, psd.children);
-	if (!layers.length) layers.push({});
+	// color mode data (empty for RGB color mode)
+	writeUint32(writer, 0);
 
 	// image resources
 
@@ -290,10 +310,12 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 			const has = handler.has(imageResources);
 			const count = has === false ? 0 : (has === true ? 1 : has);
 			for (let i = 0; i < count; i++) {
+				const id = handler.keyCount > 1 ? handler.key + i : handler.key;
+				const name = handler.name ? handler.name(imageResources, i) : '';
 				writeSignature(writer, '8BIM');
-				writeUint16(writer, handler.key);
-				writePascalString(writer, '', 2);
-				writeSection(writer, 2, () => handler.write(writer, imageResources, i));
+				writeUint16(writer, id);
+				writePascalString(writer, name, 2);
+				writeSection(writer, 2, () => handler.write(writer, imageResources, i, psd));
 			}
 		}
 	});
@@ -305,45 +327,51 @@ export function writePsd(writer: PsdWriter, psd: Psd, options: WriteOptions = {}
 		writeAdditionalLayerInfo(writer, psd, psd, opt);
 	}, undefined, !!opt.psb);
 
-	// image data
-	const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
-	const width = imageData ? imageData.width : psd.width;
-	const height = imageData ? imageData.height : psd.height;
-	const data: PixelData = { data: new Uint8Array(width * height * 4), width, height };
+	writer.tempBuffer = undefined;
 
+	// image data
 	writeUint16(writer, Compression.RleCompressed); // Photoshop doesn't support zip compression of composite image data
 
-	if (RAW_IMAGE_DATA && (psd as any).imageDataRaw) {
-		console.log('writing raw image data');
-		writeBytes(writer, (psd as any).imageDataRaw);
-	} else {
-		if (imageData) data.data.set(new Uint8Array(imageData.data.buffer, imageData.data.byteOffset, imageData.data.byteLength));
-
-		// add weird white matte
-		if (globalAlpha) {
-			const size = data.width * data.height * 4;
-			const p = data.data;
-			for (let i = 0; i < size; i += 4) {
-				const pa = p[i + 3];
-				if (pa != 0 && pa != 255) {
-					const a = pa / 255;
-					const ra = 255 * (1 - a);
-					p[i + 0] = p[i + 0] * a + ra;
-					p[i + 1] = p[i + 1] * a + ra;
-					p[i + 2] = p[i + 2] * a + ra;
-				}
+	const channels = globalAlpha ? [0, 1, 2, 3] : [0, 1, 2];
+	const data = getCompositeData(imageData, psd.width, psd.height, globalAlpha);
+
+	// encode directly into the writer buffer
+	const maxSize = channels.length * getRLEChannelBound(data.width, data.height, !!options.psb);
+	ensureSize(writer, writer.offset + maxSize);
+	const buffer = new Uint8Array(writer.buffer, writer.offset, maxSize);
+	writer.offset += writeDataRLE(buffer, data, channels, !!options.psb).length;
+}
+
+function getCompositeData(imageData: PixelData | undefined, width: number, height: number, globalAlpha: boolean): PixelData {
+	if (!imageData) return { data: new Uint8Array(width * height * 4), width, height };
+
+	const size = width * height * 4;
+	const src = imageData.data;
+	let dst: Uint8Array | undefined = undefined;
+
+	// add weird white matte (copy the data only if there are semi-transparent pixels)
+	if (globalAlpha) {
+		for (let i = 0; i < size; i += 4) {
+			const pa = src[i + 3];
+			if (pa != 0 && pa != 255) {
+				if (!dst) dst = new Uint8Array(src.buffer, src.byteOffset, size).slice();
+				const a = pa / 255;
+				const ra = 255 * (1 - a);
+				dst[i + 0] = src[i + 0] * a + ra;
+				dst[i + 1] = src[i + 1] * a + ra;
+				dst[i + 2] = src[i + 2] * a + ra;
 			}
 		}
-
-		writeBytes(writer, writeDataRLE(writer.tempBuffer, data, channels, !!options.psb));
 	}
+
+	return dst ? { data: dst, width, height } : imageData;
 }
 
 function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlpha: boolean, options: ExtendedWriteOptions) {
 	writeSection(writer, 4, () => {
 		writeInt16(writer, globalAlpha ? -layers.length : layers.length);
 
-		const layersData = layers.map((l, i) => getChannels(writer.tempBuffer!, l, i === 0, options));
+		const layersData = layers.map((l, i) => getChannels(writer, l, i === 0, options));
 
 		// layer records
 		for (const layerData of layersData) {
@@ -357,8 +385,11 @@ function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlph
 
 			for (const c of channels) {
 				writeInt16(writer, c.id);
-				if (options.psb) writeUint32(writer, 0);
-				writeUint32(writer, c.length);
+				if (options.psb) {
+					writeUint64(writer, c.length);
+				} else {
+					writeUint32(writer, c.length);
+				}
 			}
 
 			writeSignature(writer, '8BIM');
@@ -397,8 +428,15 @@ function writeLayerInfo(writer: PsdWriter, layers: Layer[], psd: Psd, globalAlph
 	}, true, options.psb);
 }
 
-function writeLayerMaskData(writer: PsdWriter, { mask, realMask }: Layer, layerData: LayerChannelData) {
-	writeSection(writer, 1, () => {
+// real mask is only stored separately if layer has both vector and pixel masks, otherwise it's stored as the main mask
+function getMasks(layer: Layer) {
+	return layer.mask ? { mask: layer.mask, realMask: layer.realMask } : { mask: layer.realMask, realMask: undefined };
+}
+
+function writeLayerMaskData(writer: PsdWriter, layer: Layer, layerData: LayerChannelData) {
+	const { mask, realMask } = getMasks(layer);
+
+	writeSection(writer, 4, () => {
 		if (!mask && !realMask) return;
 
 		let params = 0, flags = 0, realFlags = 0;
@@ -444,9 +482,7 @@ function writeLayerMaskData(writer: PsdWriter, { mask, realMask }: Layer, layerD
 			if (mask.vectorMaskDensity !== undefined) writeUint8(writer, Math.round(mask.vectorMaskDensity * 0xff));
 			if (mask.vectorMaskFeather !== undefined) writeFloat64(writer, mask.vectorMaskFeather);
 		}
-
-		writeZeros(writer, 2);
-	});
+	}, true); // photoshop pads mask data to multiple of 4 bytes and includes padding in the length
 }
 
 function writerBlendingRange(writer: PsdWriter, range: number[]) {
@@ -480,7 +516,7 @@ function writeGlobalLayerMaskInfo(writer: PsdWriter, info: GlobalLayerMaskInfo |
 			writeUint16(writer, info.colorSpace2);
 			writeUint16(writer, info.colorSpace3);
 			writeUint16(writer, info.colorSpace4);
-			writeUint16(writer, Math.round(info.opacity * 0xff));
+			writeUint16(writer, Math.round(clamp(info.opacity, 0, 1) * 100)); // 0-100
 			writeUint8(writer, info.kind);
 			writeZeros(writer, 3);
 		}
@@ -492,13 +528,13 @@ function writeAdditionalLayerInfo(writer: PsdWriter, target: LayerAdditionalInfo
 		let key = handler.key;
 
 		if (key === 'Txt2' && options.invalidateTextLayers) continue;
-		if (key === 'vmsk' && options.psb) key = 'vsms';
+		if (key === 'vmsk' && infoHandlersMap['vscg'].has(target)) key = 'vsms'; // Photoshop uses 'vsms' for layers with vector stroke
 
 		if (handler.has(target)) {
 			const large = options.psb && largeAdditionalInfoKeys.indexOf(key) !== -1;
 			const writeTotalLength = key !== 'Txt2' && key !== 'cinf' && key !== 'extn' && key !== 'CAI ' && key !== 'OCIO';
 			const fourBytes = key === 'levl' || key === 'Txt2' || key === 'luni' || key === 'vmsk' || key === 'artb' || key === 'artd' ||
-				key === 'vogk' || key === 'SoLd' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
+				key === 'vogk' || key === 'SoLd' || key === 'SoLE' || key === 'lnk2' || key === 'vscg' || key === 'vsms' || key === 'GdFl' ||
 				key === 'lmfx' || key === 'lrFX' || key === 'cinf' || key === 'PlLd' || key === 'Anno' || key === 'CAI ' || key === 'OCIO' || key === 'GenI' || key === 'FEid' || key === 'curv' || key === 'CgEd' || key === 'vibA' || key === 'blwh' || key === 'grdm';
 
 			writeSignature(writer, large ? '8B64' : '8BIM');
@@ -555,11 +591,8 @@ function addChildren(layers: Layer[], children: Layer[] | undefined) {
 }
 
 function resizeBuffer(writer: PsdWriter, size: number) {
-	let newLength = writer.buffer.byteLength;
-
-	do {
-		newLength *= 2;
-	} while (size > newLength);
+	// grow at least 2x to keep small writes fast, but don't overshoot large reservations (like composite image data)
+	const newLength = Math.max(writer.buffer.byteLength * 2, size);
 
 	const newBuffer = new ArrayBuffer(newLength);
 	const newBytes = new Uint8Array(newBuffer);
@@ -587,11 +620,11 @@ function createThumbnail(psd: Psd) {
 
 	if (psd.width > psd.height) {
 		canvas.width = 160;
-		canvas.height = Math.floor(psd.height * (canvas.width / psd.width));
+		canvas.height = Math.max(1, Math.floor(psd.height * (canvas.width / psd.width)));
 		scale = canvas.width / psd.width;
 	} else {
 		canvas.height = 160;
-		canvas.width = Math.floor(psd.width * (canvas.height / psd.height));
+		canvas.width = Math.max(1, Math.floor(psd.width * (canvas.height / psd.height)));
 		scale = canvas.height / psd.height;
 	}
 
@@ -607,7 +640,7 @@ function createThumbnail(psd: Psd) {
 	return canvas;
 }
 
-function getMaskChannels(tempBuffer: Uint8Array, layerData: LayerChannelData, layer: Layer, mask: LayerMaskData, options: WriteOptions, realMask: boolean) {
+function getMaskChannels(tempBuffer: Uint8Array, layerData: LayerChannelData, mask: LayerMaskData, options: WriteOptions, realMask: boolean) {
 	let top = (mask.top as any) | 0;
 	let left = (mask.left as any) | 0;
 	let right = (mask.right as any) | 0;
@@ -629,17 +662,14 @@ function getMaskChannels(tempBuffer: Uint8Array, layerData: LayerChannelData, la
 	let buffer: Uint8Array;
 	let compression: Compression;
 
-	if (RAW_IMAGE_DATA && (layer as any)[realMask ? 'realMaskDataRaw' : 'maskDataRaw']) {
-		buffer = (layer as any)[realMask ? 'realMaskDataRaw' : 'maskDataRaw'];
-		compression = (layer as any)[realMask ? 'realMaskDataRawCompression' : 'maskDataRawCompression'];
-	} else if (!imageData) {
+	if (!imageData) {
 		buffer = new Uint8Array(0);
 		compression = Compression.RleCompressed;
 	} else if (options.compress) {
 		buffer = writeDataZipWithoutPrediction(imageData, [0]);
 		compression = Compression.ZipWithoutPrediction;
 	} else {
-		buffer = writeDataRLE(tempBuffer, imageData, [0], !!options.psb)!;
+		buffer = writeDataRLE(tempBuffer, imageData, [0], !!options.psb).slice(); // copy, temp buffer is reused
 		compression = Compression.RleCompressed;
 	}
 
@@ -657,20 +687,47 @@ function bounds(obj: { top?: number; left?: number; bottom?: number; right?: num
 	} : undefined;
 }
 
-function getChannels(tempBuffer: Uint8Array, layer: Layer, background: boolean, options: WriteOptions): LayerChannelData {
+function getChannels(writer: PsdWriter, layer: Layer, background: boolean, options: WriteOptions): LayerChannelData {
+	let source = layer;
+
 	if (layer.rawData) {
-		return {
-			layer,
-			channels: layer.rawData.channels.map(c => ({ ...c, length: 2 + (c.data?.byteLength ?? 0) })),
-			...bounds(layer)!,
-			mask: bounds(layer.mask),
-			realMask: bounds(layer.realMask),
+		const { colorMode, bitsPerChannel, large } = layer.rawData;
+
+		if (large === !!options.psb && colorMode === ColorMode.RGB && bitsPerChannel === 8) {
+			// same mask mapping as in writeLayerMaskData
+			const { mask, realMask } = getMasks(layer);
+			return {
+				layer,
+				channels: layer.rawData.channels.map(c => ({ ...c, length: 2 + (c.data?.byteLength ?? 0) })),
+				...bounds(layer)!,
+				mask: bounds(mask),
+				realMask: bounds(realMask),
+			};
+		}
+
+		if (bitsPerChannel !== 8) throw new Error('Layer raw data with bitsPerChannel other than 8 is not supported for writing');
+
+		// raw data is in different format than the one we're writing, decode it so it can be re-encoded
+		source = {
+			...layer,
+			rawData: undefined,
+			canvas: undefined,
+			imageData: getLayerImageData(layer),
+			mask: layer.mask && { ...layer.mask, canvas: undefined, imageData: getLayerMaskImageData(layer) },
+			realMask: layer.realMask && { ...layer.realMask, canvas: undefined, imageData: getLayerRealMaskImageData(layer) },
 		};
+
+		// temp buffer is sized only for layers with image data, grow it and keep it for following layers
+		const size = getLargestLayerSize([{ ...source, children: undefined }], !!options.psb);
+		if (writer.tempBuffer!.byteLength < size) writer.tempBuffer = new Uint8Array(size);
 	}
 
-	const layerData = getLayerChannels(tempBuffer, layer, background, options);
-	if (layer.mask) getMaskChannels(tempBuffer, layerData, layer, layer.mask, options, false);
-	if (layer.realMask) getMaskChannels(tempBuffer, layerData, layer, layer.realMask, options, true);
+	const tempBuffer = writer.tempBuffer!;
+	const { mask, realMask } = getMasks(source);
+	const layerData = getLayerChannels(tempBuffer, source, background, options);
+	if (mask) getMaskChannels(tempBuffer, layerData, mask, options, false);
+	if (realMask) getMaskChannels(tempBuffer, layerData, realMask, options, true);
+	layerData.layer = layer;
 	return layerData;
 }
 
@@ -751,24 +808,20 @@ function getLayerChannels(tempBuffer: Uint8Array, layer: Layer, background: bool
 		ChannelID.Color2,
 	];
 
-	if (!background || options.noBackground || layer.mask || hasAlpha(imageData) || (RAW_IMAGE_DATA && (layer as any).imageDataRaw?.['-1'])) {
+	if (!background || options.noBackground || layer.mask || hasAlpha(imageData)) {
 		channelIds.unshift(ChannelID.Transparency);
 	}
 
 	channels = channelIds.map(id => {
-		const offset = offsetForChannel(id, false); // TODO: psd.colorMode === ColorMode.CMYK);
+		const offset = offsetForChannel(id, false); // image data is always RGBA
 		let data: Uint8Array;
 		let compression: Compression;
 
-		if (RAW_IMAGE_DATA && (layer as any).imageDataRaw) {
-			// console.log('written raw layer image data');
-			data = (layer as any).imageDataRaw[id];
-			compression = (layer as any).imageDataRawCompression[id];
-		} else if (options.compress) {
+		if (options.compress) {
 			data = writeDataZipWithoutPrediction(imageData, [offset]);
 			compression = Compression.ZipWithoutPrediction;
 		} else {
-			data = writeDataRLE(tempBuffer, imageData, [offset], !!options.psb)!;
+			data = writeDataRLE(tempBuffer, imageData, [offset], !!options.psb).slice(); // copy, temp buffer is reused
 			compression = Compression.RleCompressed;
 		}
 
@@ -841,8 +894,8 @@ export function writeColor(writer: PsdWriter, color: Color | undefined) {
 	} else if ('l' in color) {
 		writeUint16(writer, ColorSpace.Lab);
 		writeInt16(writer, Math.round(color.l * 10000));
-		writeInt16(writer, Math.round(color.a < 0 ? (color.a * 12800) : (color.a * 12700)));
-		writeInt16(writer, Math.round(color.b < 0 ? (color.b * 12800) : (color.b * 12700)));
+		writeInt16(writer, Math.round(denormalizeLabAB(color.a, 100)));
+		writeInt16(writer, Math.round(denormalizeLabAB(color.b, 100)));
 		writeUint16(writer, 0);
 	} else if ('h' in color) {
 		writeUint16(writer, ColorSpace.HSB);
@@ -851,11 +904,12 @@ export function writeColor(writer: PsdWriter, color: Color | undefined) {
 		writeUint16(writer, Math.round(color.b * 0xffff));
 		writeUint16(writer, 0);
 	} else if ('c' in color) {
+		// 0 = 100% ink
 		writeUint16(writer, ColorSpace.CMYK);
-		writeUint16(writer, Math.round(color.c * 257));
-		writeUint16(writer, Math.round(color.m * 257));
-		writeUint16(writer, Math.round(color.y * 257));
-		writeUint16(writer, Math.round(color.k * 257));
+		writeUint16(writer, 0xffff - Math.round(clamp(color.c, 0, 255) * 257));
+		writeUint16(writer, 0xffff - Math.round(clamp(color.m, 0, 255) * 257));
+		writeUint16(writer, 0xffff - Math.round(clamp(color.y, 0, 255) * 257));
+		writeUint16(writer, 0xffff - Math.round(clamp(color.k, 0, 255) * 257));
 	} else {
 		writeUint16(writer, ColorSpace.Grayscale);
 		writeUint16(writer, Math.round(color.k * 10000 / 255));
@@ -899,6 +953,10 @@ export function writePattern(writer: PsdWriter, pattern: PatternInfo) {
 
 	writeUint32(writer, 24); // channels count
 
+	// ponytail: pattern channels always use small (2-byte) RLE scanline headers, matching
+	// readPattern which reads them as non-large
+	const buffer = new Uint8Array(getRLEChannelBound(width, height, false));
+
 	// channels: RGB at indices 0,1,2 and alpha at index 25
 	for (let i = 0; i < 24 + 2; i++) {
 		const offset = i < 3 ? i : (i === 25 ? 3 : -1);
@@ -908,11 +966,7 @@ export function writePattern(writer: PsdWriter, pattern: PatternInfo) {
 			continue;
 		}
 
-		// worst-case RLE size for a single channel: width + 1 per scanline, plus scanline length headers
-		const buffer = new Uint8Array(width * height + 2 * height + 2 * width + 16);
-		// ponytail: pattern channels always use small (2-byte) RLE scanline headers, matching
-		// readPattern which reads them as non-large; `large` here only affects the header width.
-		const data = writeDataRLE(buffer, pixelData, [offset], false)!;
+		const data = writeDataRLE(buffer, pixelData, [offset], false);
 
 		writeUint32(writer, 1); // has
 		writeUint32(writer, data.length + 4 + 16 + 2 + 1); // length