ag-psd 23.1.0 → 24.0.0

package/src/descriptor.ts

@@ -138,6 +138,7 @@ const fieldToExtType: ExtTypeDict = {
 	customShape: makeType('', 'customShape'),
 	origFXRefPoint: nullType,
 	FXRefPoint: nullType,
+	ClMg: makeType('', 'ClMg'),
 };
 
 const fieldToArrayExtType: ExtTypeDict = {
@@ -171,6 +172,7 @@ const fieldToArrayExtType: ExtTypeDict = {
 	ShrP: makeType('', 'Pnt '),
 	layerSettings: nullType,
 	list: nullType,
+	Adjs: makeType('', 'CrvA'),
 };
 
 const typeToField: { [key: string]: string[]; } = {
@@ -186,7 +188,7 @@ const typeToField: { [key: string]: string[]; } = {
 	],
 	'long': [
 		'TextIndex', 'RndS', 'Mdpn', 'Smth', 'Lctn', 'strokeStyleVersion', 'LaID', 'Vrsn', 'Cnt ',
-		'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'presetKind', 'comp', 'compID', 'originalCompID',
+		'Brgh', 'Cntr', 'means', 'vibrance', 'Strt', 'bwPresetKind', 'comp', 'compID', 'originalCompID',
 		'curvesPresetKind', 'mixerPresetKind', 'uOrder', 'vOrder', 'PgNm', 'totalPages', 'Crop',
 		'numerator', 'denominator', 'frameCount', 'Annt', 'keyOriginType', 'unitValueQuadVersion',
 		'keyOriginIndex', 'major', 'minor', 'fix', 'docDefaultNewArtboardBackgroundType', 'artboardBackgroundType',
@@ -206,7 +208,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'tableOrder', 'enableCompCore', 'enableCompCoreGPU', 'compCoreSupport', 'compCoreGPUSupport', 'Engn',
 		'enableCompCoreThreads', 'gs99', 'FrDs', 'trackID', 'animInterpStyle', 'horzAlign',
 		'vertAlign', 'bgColorType', 'shapeOperation', 'UndA', 'Wvtp', 'Drct', 'WndM', 'Edg ', 'FlCl', 'IntE',
-		'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ',
+		'IntC', 'Cnvr', 'Fl  ', 'Dstr', 'MztT', 'Lns ', 'ExtT', 'DspM', 'ExtR', 'ZZTy', 'SphM', 'SmBQ', 'placedLayerOCIOConversion',
 	],
 	'bool': [
 		'PstS', 'printSixteenBit', 'masterFXSwitch', 'enab', 'uglg', 'antialiasGloss',
@@ -219,7 +221,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'materialsDisclosed', 'hasMotion', 'muted', 'Effc', 'selected', 'autoScope', 'fillCanvas',
 		'cellTextIsHTML', 'Smoo', 'Clsp', 'validAtPosition', 'rigidType', 'hasoptions', 'filterMaskEnable',
 		'filterMaskLinked', 'filterMaskExtendWithWhite', 'removeJPEGArtifact', 'Mnch', 'ExtF', 'ExtM',
-		'moreAccurate', 'GpuY', 'LIWy',
+		'moreAccurate', 'GpuY', 'LIWy', 'Cnty',
 	],
 	'doub': [
 		'warpValue', 'warpPerspective', 'warpPerspectiveOther', 'Intr', 'Wdth', 'Hght',
@@ -241,7 +243,7 @@ const typeToField: { [key: string]: string[]; } = {
 		'sheetTimelineOptions', 'audioClipList', 'trackList', 'globalTrackList', 'keyList', 'audioClipList',
 		'warpValues', 'selectedPin', 'Pts ', 'SbpL', 'pathComponents', 'pinOffsets', 'posFinalPins',
 		'pinVertexIndices', 'PinP', 'PnRt', 'PnOv', 'PnDp', 'filterFXList', 'puppetShapeList', 'ShrP',
-		'channelDenoise', 'Mtrx', 'layerSettings', 'list', 'compList',
+		'channelDenoise', 'Mtrx', 'layerSettings', 'list', 'compList', 'Adjs',
 	],
 	'ObAr': ['meshPoints', 'quiltSliceX', 'quiltSliceY'],
 	'obj ': ['null', 'Chnl'],
@@ -290,6 +292,7 @@ const fieldToArrayType: Dict = {
 	channelDenoise: 'Objc',
 	Mtrx: 'long',
 	compList: 'long',
+	Chnl: 'enum',
 };
 
 const fieldToType: Dict = {};
@@ -309,7 +312,9 @@ for (const field of Object.keys(fieldToArrayExtType)) {
 }
 
 function getTypeByKey(key: string, value: any, root: string, parent: any) {
-	if (key === 'null' && root === 'slices') {
+	if (key === 'presetKind') {
+		return typeof value === 'string' ? 'enum' : 'long';
+	} if (key === 'null' && root === 'slices') {
 		return 'TEXT';
 	} else if (key === 'groupID') {
 		return root === 'slices' ? 'long' : 'TEXT';
@@ -319,7 +324,7 @@ function getTypeByKey(key: string, value: any, root: string, parent: any) {
 		return typeof value === 'string' ? 'enum' : 'long';
 	} else if (key === 'AntA') {
 		return typeof value === 'string' ? 'enum' : 'bool';
-	} else if ((key === 'Hrzn' || key === 'Vrtc') && parent.Type === 'keyType.Pstn') {
+	} else if ((key === 'Hrzn' || key === 'Vrtc') && (parent.Type === 'keyType.Pstn' || parent._classID === 'Ofst')) {
 		return 'long';
 	} else if (key === 'Hrzn' || key === 'Vrtc' || key === 'Top ' || key === 'Left' || key === 'Btom' || key === 'Rght') {
 		if (root === 'slices') return 'long';
@@ -405,12 +410,18 @@ export function writeDescriptorStructure(writer: PsdWriter, name: string, classI
 			type = 'long';
 		} else if (/^PF[a-z][a-z]$/.test(key)) {
 			type = 'doub';
+		} else if ((key === 'Rds ' || key === 'Thsh') && typeof value[key] === 'number' && value._classID === 'SmrB') {
+			type = 'doub';
 		} else if (key === 'ClSz' || key === 'Rds ' || key === 'Amnt') {
 			type = typeof value[key] === 'number' ? 'long' : 'UntF';
 		} else if ((key === 'sdwM' || key === 'hglM') && typeof value[key] === 'string') {
 			type = 'enum';
 		} else if (key === 'blur' && typeof value[key] === 'string') {
 			type = 'enum';
+		} else if (key === 'Hght' && typeof value[key] === 'number' && value._classID === 'Embs') {
+			type = 'long';
+		} else if (key === 'Angl' && typeof value[key] === 'number' && (value._classID === 'Embs' || value._classID === 'smartSharpen' || value._classID === 'Twrl' || value._classID === 'MtnB')) {
+			type = 'long';
 		} else if (key === 'Angl' && typeof value[key] === 'number') {
 			type = 'doub'; // ???
 		} else if (key === 'bounds' && root === 'slices') {
@@ -727,7 +738,7 @@ function writeReferenceStructure(writer: PsdWriter, _key: string, items: any[])
 		let type = 'unknown';
 
 		if (typeof value === 'string') {
-			if (/^[a-z]+\.[a-z]+$/i.test(value)) {
+			if (/^[a-z ]+\.[a-z ]+$/i.test(value)) {
 				type = 'Enmr';
 			} else {
 				type = 'name';
@@ -2146,3 +2157,8 @@ export const prjM = createEnum<'fisheye' | 'perspective' | 'auto' | 'full spheri
 	'auto': 'auto',
 	'full spherical': 'fusP',
 });
+
+export const presetKindType = createEnum<'custom' | 'default'>('presetKindType', 'presetKindCustom', {
+	custom: 'presetKindCustom',
+	default: 'presetKindDefault',
+});

package/src/engineData2.ts

@@ -58,7 +58,7 @@ const keysStyleSheet: KeysDict = {
 
 	'52': { name: 'NoBreak' },
 	'53': { name: 'FillColor', children: keysColor },
-	'54': { name: 'StrokeColor?', children: keysColor },
+	'54': { name: 'StrokeColor', children: keysColor },
 	'55': { children: { '99': { uproot: true } } },
 
 	// '68': ???
@@ -321,6 +321,13 @@ const keysRoot: KeysDict = {
 						// 		// '6'
 						// 	},
 						// }
+						//     "1": [ // this is probably bounding box? there seem to be many of them nested
+						//       0,
+						//       0,
+						//       999,
+						//       176.30014
+						//     ],
+						// various types: /PC, /F, /R, /L, /S, /G
 					},
 				},
 			},

package/src/psd.ts

@@ -1125,7 +1125,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 +1379,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 +1420,10 @@ export interface LayerAdditionalInfo {
 			data: Uint8Array;
 		} | undefined)[];
 		extra?: {
+			top: number;
+			left: number;
+			bottom: number;
+			right: number;
 			compressionMode: number;
 			data: Uint8Array;
 		};
@@ -1665,6 +1684,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());
 	});
 
@@ -447,7 +452,9 @@ function readLayerRecord(reader: PsdReader, psd: Psd) {
 		// HACK: fix for sometimes layer.name string not being padded correctly, just skip until we get valid signature
 		while (left() > 4 && !validSignatureAt(reader, reader.offset)) reader.offset++;
 
-		while (left() > 4) readAdditionalLayerInfo(reader, layer, psd);
+		while (left() >= 12) readAdditionalLayerInfo(reader, layer, psd);
+
+		skipBytes(reader, left());
 	});
 
 	return { layer, channels };
@@ -533,7 +540,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;
@@ -573,6 +583,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);
 				}
 
@@ -605,6 +616,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);
 			}
 
@@ -631,7 +643,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) {
@@ -690,13 +702,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})`);
 	}
@@ -761,8 +777,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];
@@ -782,10 +819,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;
@@ -846,6 +885,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');
@@ -953,7 +1006,7 @@ export function readDataZip(reader: PsdReader, length: number, pixelData: PixelD
 	}
 }
 
-export function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined, _width: number, height: number, bitDepth: number, step: number, offsets: number[], large: boolean) {
+export function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined, width: number, height: number, bitDepth: number, step: number, offsets: number[], large: boolean) {
 	const data = pixelData && pixelData.data;
 	let lengths: Uint16Array | Uint32Array;
 
@@ -992,19 +1045,19 @@ export function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined,
 				const length = lengths[li];
 				const buffer = readBytes(reader, length);
 
-				for (let i = 0; i < length; i++) {
+				for (let i = 0, x = 0; i < length; i++) {
 					let header = buffer[i];
 
 					if (header > 128) {
 						const value = buffer[++i];
 						header = (256 - header) | 0;
 
-						for (let j = 0; j <= header; j = (j + 1) | 0) {
+						for (let j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
 							data[p] = value;
 							p = (p + step) | 0;
 						}
 					} else if (header < 128) {
-						for (let j = 0; j <= header; j = (j + 1) | 0) {
+						for (let j = 0; j <= header && x < width; j = (j + 1) | 0, x = (x + 1) | 0) {
 							data[p] = buffer[++i];
 							p = (p + step) | 0;
 						}

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) {
@@ -449,10 +461,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 +474,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 +490,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 +605,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 +710,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;