ag-psd 28.4.1 → 28.5.0

package/src/abr.ts

@@ -1,9 +1,6 @@
 import { BlnM, DescriptorUnitsValue, parseAngle, parsePercent, parseUnitsToNumber, readVersionAndDescriptor } from './descriptor';
 import { BlendMode, PatternInfo } from './psd';
-import {
-	checkSignature, createReader, readBytes, readDataRLE, readInt16, readInt32, readPascalString, readPattern,
-	readSignature, readUint16, readUint32, readUint8, skipBytes
-} from './psdReader';
+import { checkSignature, createReader, readBytes, readDataRLE, readInt16, readInt32, readPascalString, readPattern, readSignature, readUint16, readUint32, readUint8, skipBytes } from './psdReader';
 
 export interface Abr {
 	brushes: Brush[];
@@ -26,17 +23,78 @@ export interface BrushDynamics {
 
 const dynamicsControl = ['off', 'fade', 'pen pressure', 'pen tilt', 'stylus wheel', 'initial direction', 'direction', 'initial rotation', 'rotation'];
 
-export interface BrushShape {
-	name?: string;
+type DynamicBrushShapeShape = 'round point' | 'round blunt' | 'round curve' | 'round angle' | 'round fan' | 'flat point' | 'flat blunt' | 'flat curve' | 'flat angle' | 'flat fan';
+
+const dynamicBrushShapeShapes: DynamicBrushShapeShape[] = ['round point', 'round blunt', 'round curve', 'round angle', 'round fan', 'flat point', 'flat blunt', 'flat curve', 'flat angle', 'flat fan'];
+
+type TipsBrushShapeShape = 'erodible point' | 'erodible flat' | 'erodible round' | 'erodible square' | 'erodible triangle' | 'custom';
+
+const tipsBrushShapeShapes: TipsBrushShapeShape[] = ['erodible point', 'erodible flat', 'erodible round', 'erodible square', 'erodible triangle', 'custom'];
+
+export type BrushShape = ComputedBrushShape | SampledBrushShape | TipsBrushShape | DynamicBrushShape;
+
+interface ComputedBrushShape {
+	type: 'computed';
+	size: number;
+	angle: number;
+	roundness: number;
+	hardness: number;
+	spacingOn: boolean;
+	spacing: number;
+	flipX: boolean;
+	flipY: boolean;
+}
+
+interface SampledBrushShape {
+	type: 'sampled';
+	name: string;
 	size: number;
 	angle: number;
 	roundness: number;
-	hardness?: number;
 	spacingOn: boolean;
 	spacing: number;
 	flipX: boolean;
 	flipY: boolean;
-	sampledData?: string;
+	sampledData: string;
+}
+
+interface TipsBrushShape {
+	type: 'tips';
+	angle: number;
+	size: number;
+	shape: DynamicBrushShapeShape;
+	physics: boolean;
+	spacing: number,
+	spacingOn: boolean;
+	flipX: boolean;
+	flipY: boolean;
+	tipsType: TipsBrushShapeShape;
+	tipsLengthRatio: number;
+	tipsHardness: number;
+	tipsGridSize?: number;
+	tipsErodibleTipHeightMap?: number[];
+	tipsAirbrushCutoffAngle: number;
+	tipsAirbrushGranularity: number;
+	tipsAirbrushStreakiness: number;
+	tipsAirbrushSplatSize: number;
+	tipsAirbrushSplatCount: number;
+}
+
+interface DynamicBrushShape {
+	type: 'dynamic';
+	size: number;
+	angle: number;
+	shape: DynamicBrushShapeShape;
+	density: number;
+	length: number;
+	clumping: number; // bristles
+	thickness: number;
+	stiffness: number;
+	physics: boolean;
+	spacing: number;
+	spacingOn: boolean;
+	flipX: boolean;
+	flipY: boolean;
 }
 
 export interface Brush {
@@ -164,17 +222,74 @@ interface DynamicsDescriptor {
 	'Mnm ': DescriptorUnitsValue;
 }
 
-interface BrushShapeDescriptor {
+type BrushShapeDescriptor = ComputedBrushDescriptor | SampledBrushDescriptor | TipsBrushDescriptor | DynamicBrushDescriptor;
+
+interface ComputedBrushDescriptor {
+	_name: '';
+	_classID: 'computedBrush',
+	Dmtr: DescriptorUnitsValue,
+	Hrdn: DescriptorUnitsValue,
+	Angl: DescriptorUnitsValue,
+	Rndn: DescriptorUnitsValue,
+	Spcn: DescriptorUnitsValue,
+	Intr: boolean,
+	flipX: boolean,
+	flipY: boolean,
+}
+
+interface SampledBrushDescriptor {
+	_name: '';
+	_classID: 'sampledBrush';
 	Dmtr: DescriptorUnitsValue;
 	Angl: DescriptorUnitsValue;
 	Rndn: DescriptorUnitsValue;
-	'Nm  '?: string;
+	'Nm  ': string;
+	Spcn: DescriptorUnitsValue;
+	Intr: boolean;
+	flipX: boolean;
+	flipY: boolean;
+	sampledData: string;
+}
+
+interface TipsBrushDescriptor {
+	_name: '';
+	_classID: 'dTips';
+	Angl: DescriptorUnitsValue;
+	Dmtr: DescriptorUnitsValue;
+	dtipsType: number;
+	'Shp ': number;
+	dtipsLengthRatio: DescriptorUnitsValue;
+	dtipsHardness: DescriptorUnitsValue;
+	dtipsGridSize: number;
+	dtipsErodibleTipHeightMap?: Uint8Array;
+	physics: boolean;
+	dtipsAirbrushCutoffAngle: number;
+	dtipsAirbrushGranularity: DescriptorUnitsValue;
+	dtipsAirbrushStreakiness: DescriptorUnitsValue;
+	dtipsAirbrushSplatSize: DescriptorUnitsValue;
+	dtipsAirbrushSplatCount: number;
+	Spcn: DescriptorUnitsValue,
+	Intr: boolean;
+	flipX: boolean;
+	flipY: boolean;
+}
+
+interface DynamicBrushDescriptor {
+	_name: '';
+	_classID: 'dBrush';
+	'Shp ': number;
+	Angl: DescriptorUnitsValue;
+	Dmtr: DescriptorUnitsValue;
+	Dnst: DescriptorUnitsValue;
+	Lngt: DescriptorUnitsValue;
+	clumping: DescriptorUnitsValue;
+	thickness: DescriptorUnitsValue;
+	stiffness: DescriptorUnitsValue;
+	physics: boolean;
 	Spcn: DescriptorUnitsValue;
 	Intr: boolean;
-	Hrdn?: DescriptorUnitsValue;
 	flipX: boolean;
 	flipY: boolean;
-	sampledData?: string;
 }
 
 interface DescDescriptor {
@@ -305,21 +420,96 @@ function parseDynamics(desc: DynamicsDescriptor): BrushDynamics {
 }
 
 function parseBrushShape(desc: BrushShapeDescriptor): BrushShape {
-	const shape: BrushShape = {
-		size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
-		angle: parseAngle(desc.Angl),
-		roundness: parsePercent(desc.Rndn),
-		spacingOn: desc.Intr,
-		spacing: parsePercent(desc.Spcn),
-		flipX: desc.flipX,
-		flipY: desc.flipY,
-	};
-
-	if (desc['Nm  ']) shape.name = desc['Nm  '];
-	if (desc.Hrdn) shape.hardness = parsePercent(desc.Hrdn);
-	if (desc.sampledData) shape.sampledData = desc.sampledData;
+	switch (desc._classID) {
+		case 'computedBrush': {
+			return {
+				type: 'computed',
+				size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
+				angle: parseAngle(desc.Angl),
+				roundness: parsePercent(desc.Rndn),
+				spacingOn: desc.Intr,
+				spacing: parsePercent(desc.Spcn),
+				flipX: desc.flipX,
+				flipY: desc.flipY,
+				hardness: parsePercent(desc.Hrdn),
+			};
+		}
+		case 'sampledBrush': {
+			return {
+				type: 'sampled',
+				size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
+				angle: parseAngle(desc.Angl),
+				roundness: parsePercent(desc.Rndn),
+				spacingOn: desc.Intr,
+				spacing: parsePercent(desc.Spcn),
+				flipX: desc.flipX,
+				flipY: desc.flipY,
+				name: desc['Nm  '],
+				sampledData: desc.sampledData,
+			};
+		}
+		case 'dBrush':
+			return {
+				type: 'dynamic',
+				shape: dynamicBrushShapeShapes[desc['Shp ']],
+				angle: parseAngle(desc.Angl),
+				size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
+				density: parsePercent(desc.Dnst),
+				length: parsePercent(desc.Lngt),
+				clumping: parsePercent(desc.clumping),
+				thickness: parsePercent(desc.thickness),
+				stiffness: parsePercent(desc.stiffness),
+				physics: desc.physics,
+				spacing: parsePercent(desc.Spcn),
+				spacingOn: desc.Intr,
+				flipX: desc.flipX,
+				flipY: desc.flipY,
+			};
+		case 'dTips': {
+			return {
+				type: 'tips',
+				angle: parseAngle(desc.Angl),
+				size: parseUnitsToNumber(desc.Dmtr, 'Pixels'),
+				shape: dynamicBrushShapeShapes[desc['Shp ']],
+				physics: desc.physics,
+				spacing: parsePercent(desc.Spcn),
+				spacingOn: desc.Intr,
+				flipX: desc.flipX,
+				flipY: desc.flipY,
+				// tips:
+				tipsType: tipsBrushShapeShapes[desc.dtipsType],
+				tipsLengthRatio: parsePercent(desc.dtipsLengthRatio),
+				tipsHardness: parsePercent(desc.dtipsHardness),
+				...(desc.dtipsGridSize && desc.dtipsErodibleTipHeightMap ? {
+					tipsGridSize: desc.dtipsGridSize,
+					tipsErodibleTipHeightMap: parseHeightmap(desc.dtipsErodibleTipHeightMap),
+				} : {}),
+				// airbrush
+				tipsAirbrushCutoffAngle: desc.dtipsAirbrushCutoffAngle,
+				tipsAirbrushGranularity: parsePercent(desc.dtipsAirbrushGranularity),
+				tipsAirbrushStreakiness: parsePercent(desc.dtipsAirbrushStreakiness),
+				tipsAirbrushSplatSize: parsePercent(desc.dtipsAirbrushSplatSize),
+				tipsAirbrushSplatCount: desc.dtipsAirbrushSplatCount,
+			};
+		}
+		default:
+			console.log(require('util').inspect(desc, false, 99, true));
+			throw new Error(`Unknown brush classId: ${(desc as any)._classID}`);
+	}
+}
 
-	return shape;
+function parseHeightmap(array: Uint8Array) {
+	const result: number[] = [];
+	for (let i = 0; i < array.byteLength; i++) {
+		result.push(array[i]);
+	}
+	return result;
+	// const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+	// const result: number[] = [];
+	// for (let i = 0, len = (array.byteLength / 4) | 0; i < len; i++) {
+	// 	result.push(view.getInt32(i * 4)); ????
+	// }
+	// return result;
 }
 
 export function readAbr(buffer: ArrayBufferView, options: { logMissingFeatures?: boolean; } = {}): Abr {

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.