ag-psd 28.4.0 → 28.5.0

package/src/additionalInfo.ts

@@ -4,7 +4,7 @@ import { clamp, createEnum, layerColors, MOCK_HANDLERS } from './helpers';
 import { LayerAdditionalInfo, BezierPath, Psd, BrightnessAdjustment, ExposureAdjustment, VibranceAdjustment, ColorBalanceAdjustment, BlackAndWhiteAdjustment, PhotoFilterAdjustment, ChannelMixerChannel, ChannelMixerAdjustment, PosterizeAdjustment, ThresholdAdjustment, GradientMapAdjustment, CMYK, SelectiveColorAdjustment, ColorLookupAdjustment, LevelsAdjustmentChannel, LevelsAdjustment, CurvesAdjustment, CurvesAdjustmentChannel, HueSaturationAdjustment, HueSaturationAdjustmentChannel, PresetInfo, Color, ColorBalanceValues, WriteOptions, LinkedFile, PlacedLayerType, Warp, KeyDescriptorItem, BooleanOperation, LayerEffectsInfo, Annotation, LayerVectorMask, AnimationFrame, Timeline, PlacedLayerFilter, UnitsValue, Filter, PlacedLayer, ReadOptions, Layer } from './psd';
 import { PsdReader, readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16, readBytes, readInt16, checkSignature, readFloat32, readFixedPointPath32, readSection, readColor, readInt32, readPascalString, readUnicodeStringWithLength, readAsciiString, readPattern, readLayerInfo } from './psdReader';
 import { PsdWriter, writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8, writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding, writeColor, writePascalString, writeInt32 } from './psdWriter';
-import { Annt, BlnM, DescriptorColor, DescriptorUnitsValue, parsePercent, parseUnits, parseUnitsOrNumber, QuiltWarpDescriptor, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, TextDescriptor, textGridding, unitsPercent, unitsValue, WarpDescriptor, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor, FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, FractionDescriptor, BlrM, BlrQ, SmBQ, SmBM, DspM, UndA, Cnvr, RplS, SphM, Wvtp, ZZTy, Dstr, Chnl, MztT, Lns, blurType, DfsM, ExtT, ExtR, FlCl, CntE, WndM, Drct, IntE, IntC, FlMd, unitsPercentF, frac, ClrS, descBoundsToBounds, boundsToDescBounds, presetKindType, gradientInterpolationMethodType } from './descriptor';
+import { Annt, BlnM, DescriptorColor, DescriptorUnitsValue, parsePercent, parseUnits, parseUnitsOrNumber, QuiltWarpDescriptor, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, TextDescriptor, textGridding, unitsPercent, unitsValue, WarpDescriptor, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, StrokeDescriptor, Ornt, horzVrtcToXY, LmfxDescriptor, Lfx2Descriptor, FrameListDescriptor, TimelineDescriptor, FrameDescriptor, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, FractionDescriptor, BlrM, BlrQ, SmBQ, SmBM, DspM, UndA, Cnvr, RplS, SphM, Wvtp, ZZTy, Dstr, Chnl, MztT, Lns, blurType, DfsM, ExtT, ExtR, FlCl, CntE, WndM, Drct, IntE, IntC, FlMd, unitsPercentF, frac, ClrS, descBoundsToBounds, boundsToDescBounds, presetKindType, gradientInterpolationMethodType, PxScDescriptor } from './descriptor';
 import { serializeEngineData, parseEngineData } from './engineData';
 import { encodeEngineData, decodeEngineData } from './text';
 import { decodeEngineData2 } from './engineData2';
@@ -978,6 +978,76 @@ addHandler(
 	},
 );
 
+addHandler(
+	'PxSc',
+	() => false,
+	(reader, target) => {
+		const desc = readVersionAndDescriptor(reader, true) as PxScDescriptor;
+		// console.log('PxSc', require('util').inspect(desc, false, 99, true));
+
+		if (desc.pixelSourceType === 1986285651) {
+			target.pixelSource = {
+				type: 'vdPS',
+				origin: { x: desc.origin.Hrzn, y: desc.origin.Vrtc },
+				interpretation: {
+					interpretAlpha: desc.interpretation.interpretAlpha.split('.')[1] as any,
+					profile: desc.interpretation.profile,
+				},
+				frameReader: {
+					type: 'QTFR',
+					link: {
+						name: desc.frameReader['Lnk ']['Nm  '],
+						fullPath: desc.frameReader['Lnk '].fullPath,
+						originalPath: desc.frameReader['Lnk '].originalPath,
+						relativePath: desc.frameReader['Lnk '].relPath,
+						alias: desc.frameReader['Lnk '].alis,
+					},
+					mediaDescriptor: desc.frameReader.mediaDescriptor,
+				},
+				showAlteredVideo: desc.showAlteredVideo,
+			};
+		} else {
+			reader.log(`Unknown pixelSourceType`);
+		}
+	},
+	(writer, target) => {
+		const source = target.pixelSource!;
+		const desc: PxScDescriptor = {
+			_name: '',
+			_classID: 'PixelSource',
+			pixelSourceType: 1986285651, // vdP
+			descVersion: 1,
+			origin: { Hrzn: source.origin.x, Vrtc: source.origin.y },
+			interpretation: {
+				_name: '',
+				_classID: 'footageInterpretation',
+				Vrsn: 1,
+				interpretAlpha: `alphaInterpretation.${source.interpretation.interpretAlpha}` as any,
+				profile: source.interpretation.profile,
+			},
+			frameReader: {
+				_name: '',
+				_classID: 'FrameReader',
+				frameReaderType: 1364477522, // QTF
+				descVersion: 1,
+				'Lnk ': {
+					_name: '',
+					_classID: 'ExternalFileLink',
+					descVersion: 2,
+					'Nm  ': source.frameReader.link.name,
+					fullPath: source.frameReader.link.fullPath,
+					originalPath: source.frameReader.link.originalPath,
+					alis: source.frameReader.link.alias,
+					relPath: source.frameReader.link.relativePath,
+				},
+				mediaDescriptor: source.frameReader.mediaDescriptor,
+			},
+			showAlteredVideo: source.showAlteredVideo,
+		};
+		writeVersionAndDescriptor(writer, '', 'PixelSource', desc);
+	},
+);
+
 addHandler(
 	'vstk',
 	hasKey('vectorStroke'),
@@ -3627,6 +3697,8 @@ if (MOCK_HANDLERS) {
 
 /*
 interface CAIDesc {
+	_name: '';
+	_classID: 'null';
 	enab: boolean;
 	generationalGuid: string;
 }
@@ -3636,15 +3708,15 @@ addHandler(
 	() => false,
 	(reader, _target, left) => {
 		const version = readUint32(reader); // 3
-		const desc = readVersionAndDescriptor(reader) as CAIDesc;
+		const desc = readVersionAndDescriptor(reader, true) as CAIDesc;
+		console.log('CAI version', version);
 		console.log('CAI', require('util').inspect(desc, false, 99, true));
-		console.log('CAI', { version });
 		console.log('CAI left', readBytes(reader, left())); // 8 bytes left, all zeroes
 	},
 	(_writer, _target) => {
 	},
 );
-*/
+// */
 
 if (MOCK_HANDLERS) {
 	addHandler(
@@ -3659,11 +3731,25 @@ if (MOCK_HANDLERS) {
 	);
 }
 
+// interface OCIODescriptor {
+// 	_name: '';
+// 	_classID: 'documentColorManagementInfo';
+// 	'Knd ': 'icc';
+// 	ocio_display_view: {
+// 		_name: '';
+// 		_classID: 'viewColorManagementInfo';
+// 		display: string;
+// 		view: string;
+// 	};
+// }
+
 if (MOCK_HANDLERS) {
 	addHandler(
-		'OCIO', // generative tech?
+		'OCIO', // document color management info
 		target => (target as any)._OCIO !== undefined,
 		(reader, target, left) => {
+			// const desc = readVersionAndDescriptor(reader, true) as OCIODescriptor;
+			// console.log('OCIO', require('util').inspect(desc, false, 99, true));
 			(target as any)._OCIO = readBytes(reader, left());
 		},
 		(writer, target) => {
@@ -3672,8 +3758,11 @@ if (MOCK_HANDLERS) {
 	);
 }
 
-// interface GenIDesc {
+// interface GenIDescriptor {
+//  _name: '';
+//  _classID: 'genTechInfo';
 // 	isUsingGenTech: number;
+//  externalModelList?: [];
 // }
 
 if (MOCK_HANDLERS) {
@@ -3681,9 +3770,9 @@ if (MOCK_HANDLERS) {
 		'GenI', // generative tech
 		target => (target as any)._GenI !== undefined,
 		(reader, target, left) => {
+			const desc = readVersionAndDescriptor(reader, true); // as GenIDescriptor;
+			console.log('GenI', require('util').inspect(desc, false, 99, true));
 			(target as any)._GenI = readBytes(reader, left());
-			// const desc = readVersionAndDescriptor(reader) as GenIDesc;
-			// console.log('GenI', require('util').inspect(desc, false, 99, true));
 		},
 		(writer, target) => {
 			writeBytes(writer, (target as any)._GenI);

package/src/ase.ts

@@ -0,0 +1,116 @@
+import { createReader, readFloat32, readSignature, readUint16, readUint32, readUnicodeStringWithLength } from './psdReader';
+
+export type AseColorType = 'global' | 'spot' | 'normal';
+
+export interface AseColor {
+  name: string;
+  color: {
+    r: number;
+    g: number;
+    b: number;
+    type: AseColorType;
+  } | {
+    c: number;
+    m: number;
+    y: number;
+    k: number;
+    type: AseColorType;
+  } | {
+    k: number;
+    type: AseColorType;
+  } | {
+    l: number;
+    a: number;
+    b: number;
+    type: AseColorType;
+  };
+}
+
+export interface AseGroup {
+  name: string;
+  colors: AseColor[];
+}
+
+export interface Ase {
+  colors: (AseGroup | AseColor)[];
+}
+
+export function readAse(buffer: ArrayBufferView): Ase {
+  const reader = createReader(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  const signature = readSignature(reader); // ASEF
+  if (signature !== 'ASEF') throw new Error('Invalid signature');
+  const versionMajor = readUint16(reader); // 1
+  const versionMinor = readUint16(reader); // 0
+  if (versionMajor !== 1 || versionMinor !== 0) throw new Error('Invalid version');
+  const blocksCount = readUint32(reader);
+  const colorTypes: AseColorType[] = ['global', 'spot', 'normal'];
+  const ase: Ase = { colors: [] };
+  let group: Ase | AseGroup = ase;
+
+  for (let i = 0; i < blocksCount; i++) {
+    const type = readUint16(reader);
+    const length = readUint32(reader);
+    const end = reader.offset + length;
+
+    switch (type) {
+      case 0x0001: { // color
+        const nameLength = readUint16(reader);
+        const name = readUnicodeStringWithLength(reader, nameLength);
+        const colorMode = readSignature(reader);
+        let color: any;
+        switch (colorMode) {
+          case 'RGB ':
+            color = {
+              r: readFloat32(reader),
+              g: readFloat32(reader),
+              b: readFloat32(reader),
+              type: colorTypes[readUint16(reader)],
+            };
+            break;
+          case 'CMYK':
+            color = {
+              c: readFloat32(reader),
+              m: readFloat32(reader),
+              y: readFloat32(reader),
+              k: readFloat32(reader),
+              type: colorTypes[readUint16(reader)],
+            };
+            break;
+          case 'Gray':
+            color = {
+              k: readFloat32(reader),
+              type: colorTypes[readUint16(reader)],
+            };
+            break;
+          case 'LAB ':
+            color = {
+              l: readFloat32(reader),
+              a: readFloat32(reader),
+              b: readFloat32(reader),
+              type: colorTypes[readUint16(reader)],
+            };
+            break;
+          default:
+            throw new Error('Invalid color mode');
+        }
+        group.colors.push({ name, color });
+        break;
+      }
+      case 0xC001: { // group start
+        const nameLength = readUint16(reader);
+        const name = readUnicodeStringWithLength(reader, nameLength);
+        ase.colors.push(group = { name, colors: [] });
+        break;
+      }
+      case 0xC002: // group end
+        group = ase;
+        break;
+      default:
+        throw new Error('Invalid block type');
+    }
+
+    reader.offset = end;
+  }
+
+  return ase;
+}

package/src/descriptor.ts

@@ -1014,6 +1014,39 @@ export interface FrameListDescriptor {
 	LaSt: FrameDescriptor[];
 }
 
+export interface PxScDescriptor {
+	_name: '';
+	_classID: 'PixelSource';
+	pixelSourceType: 1986285651; // vdPS
+	descVersion: 1;
+	origin: { Hrzn: number; Vrtc: number; };
+	interpretation: {
+		_name: '';
+		_classID: 'footageInterpretation';
+		Vrsn: 1;
+		interpretAlpha: 'alphaInterpretation.straight';
+		profile: Uint8Array;
+	};
+	frameReader: {
+		_name: '';
+		_classID: 'FrameReader';
+		frameReaderType: 1364477522; // QTFR
+		descVersion: 1;
+		'Lnk ': {
+			_name: '';
+			_classID: 'ExternalFileLink';
+			descVersion: 2;
+			'Nm  ': string;
+			fullPath: string;
+			originalPath: string;
+			alis: string;
+			relPath: string;
+		};
+		mediaDescriptor: string;
+	};
+	showAlteredVideo: boolean;
+}
+
 export function horzVrtcToXY(hv: HrznVrtcDescriptor): { x: number; y: number; } {
 	return { x: hv.Hrzn, y: hv.Vrtc };
 }

package/src/psd.ts

@@ -1488,6 +1488,26 @@ export interface LayerAdditionalInfo {
 		ranges: { sourceRange: number[]; destRange: number[]; }[];
 	};
 	vowv?: number; // ???
+	pixelSource?: {
+		type: 'vdPS';
+		origin: { x: number; y: number; };
+		interpretation: {
+			interpretAlpha: string; // 'straight' | ...;
+			profile: Uint8Array;
+		};
+		frameReader: {
+			type: 'QTFR';
+			link: {
+				name: string;
+				fullPath: string;
+				originalPath: string;
+				relativePath: string;
+				alias: string;
+			};
+			mediaDescriptor: string;
+		};
+		showAlteredVideo: boolean;
+	};
 
 	// Base64 encoded raw EngineData, currently just kept in original state to support
 	// loading and modifying PSD file without breaking text layers.

package/src/psdReader.ts

@@ -1273,16 +1273,16 @@ export function readPattern(reader: PsdReader): PatternInfo {
 			}
 		} else if (compressionMode === 1) {
 			const pixelData: PixelData = { data, width, height };
-			const tempData: PixelData = { data: new Uint8Array(width * height), width, height };
+			const tempData: PixelData = { data: new Uint8Array(w * h), width: w, height: h };
 			const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
 
 			if (colorMode === ColorMode.RGB && ch < 3) {
-				readDataRLE(cdataReader, tempData, width, height, 8, 1, [0], false);
+				readDataRLE(cdataReader, tempData, w, h, 8, 1, [0], false);
 				copyChannelToRGBA(tempData, pixelData, ox, oy, ch);
 			}
 
 			if (colorMode === ColorMode.Grayscale && ch < 1) {
-				readDataRLE(cdataReader, tempData, width, height, 8, 1, [0], false);
+				readDataRLE(cdataReader, tempData, w, h, 8, 1, [0], false);
 				copyChannelToRGBA(tempData, pixelData, ox, oy, 0);
 				setupGrayscale(pixelData);
 			}