public GlowEffect(PsdBinaryReader r, string key)
{
m_key = key;
uint version = r.ReadUInt32(); //two version
this.Blur = r.ReadUInt32();
this.Intensity = r.ReadUInt32();
Color golwColor = readColor(r);
this.BlendModeKey = this.ReadBlendKey(r);
this.Enabled = r.ReadBoolean();
this.Opacity = r.ReadByte();
this.Color = Util.FromArgb(Opacity, golwColor);
switch (version)
{
case 0:
break;
case 2:
//TODO!
if (this.Inner)
{
this.Unknown = r.ReadByte();
}
this.UnknownColor = r.ReadPSDColor(16, true); //unknown color
// byte[] Data = r.ReadBytes((int)r.BytesToEnd);
break;
}
}
public BevelEffect(PsdBinaryReader r, string key)
{
m_key = key;
uint version = r.ReadUInt32();
this.Angle = r.ReadUInt32();
this.Strength = r.ReadUInt32();
this.Blur = r.ReadUInt32();
this.BlendModeKey = this.ReadBlendKey(r);
this.ShadowBlendModeKey = this.ReadBlendKey(r);
this.Color = r.ReadPSDColor(16, true);
this.ShadowColor = r.ReadPSDColor(16, true);
this.BevelStyle = r.ReadByte();
this.Opacity = r.ReadByte();
this.ShadowOpacity = r.ReadByte();
this.Enabled = r.ReadBoolean();
this.UseGlobalAngle = r.ReadBoolean();
this.Inverted = r.ReadBoolean();
switch (version)
{
case 0:
break;
case 2:
Color someColor = r.ReadPSDColor(16, true);
Color someColor2 = r.ReadPSDColor(16, true);
break;
}
}
public VersionInfo(PsdBinaryReader reader, string name)
: base(name)
{
Version = reader.ReadUInt32();
HasRealMergedData = reader.ReadBoolean();
ReaderName = reader.ReadUnicodeString();
WriterName = reader.ReadUnicodeString();
FileVersion = reader.ReadUInt32();
}
public VersionInfo(PsdBinaryReader reader, string name)
: base(name)
{
Version = reader.ReadUInt32();
HasRealMergedData = reader.ReadBoolean();
ReaderName = reader.ReadUnicodeString();
WriterName = reader.ReadUnicodeString();
FileVersion = reader.ReadUInt32();
}
public ResolutionInfo(PsdBinaryReader reader, string name)
: base(name)
{
this.HDpi = new UFixed16_16(reader.ReadUInt32());
this.HResDisplayUnit = (ResUnit)reader.ReadInt16();
this.WidthDisplayUnit = (Unit)reader.ReadInt16();
this.VDpi = new UFixed16_16(reader.ReadUInt32());
this.VResDisplayUnit = (ResUnit)reader.ReadInt16();
this.HeightDisplayUnit = (Unit)reader.ReadInt16();
}
public ResolutionInfo(PsdBinaryReader reader, string name)
: base(name)
{
this.HDpi = new UFixed16_16(reader.ReadUInt32());
this.HResDisplayUnit = (ResUnit)reader.ReadInt16();
this.WidthDisplayUnit = (Unit)reader.ReadInt16();
this.VDpi = new UFixed16_16(reader.ReadUInt32());
this.VResDisplayUnit = (ResUnit)reader.ReadInt16();
this.HeightDisplayUnit = (Unit)reader.ReadInt16();
}
public ObjectBasedEffect(PsdBinaryReader reader, int dataLength)
{
uint version = reader.ReadUInt32();
uint descriptorVersion = reader.ReadUInt32();
Descriptor = DynVal.ReadDescriptor(reader);
DynVal grad = Descriptor.FindDynVal("Grad");
if (grad != null)
{
Gradient = new GradientEffect();
Gradient.ParseDescriptor(grad);
}
}
public MaskInfo(PsdBinaryReader reader, Layer layer)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, MaskInfo");
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
{
return;
}
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + maskLength;
// Read layer mask
var rectangle = reader.ReadRectangle();
var backgroundColor = reader.ReadByte();
var flagsByte = reader.ReadByte();
LayerMask = new Mask(layer, rectangle, backgroundColor, new BitVector32(flagsByte));
// User mask is supplied separately when there is also a vector mask.
if (maskLength == 36)
{
var userFlagsByte = reader.ReadByte();
var userBackgroundColor = reader.ReadByte();
var userRectangle = reader.ReadRectangle();
UserMask = new Mask(layer, userRectangle, userBackgroundColor, new BitVector32(userFlagsByte));
}
// 20-byte mask data will end with padding.
reader.BaseStream.Position = endPosition;
Util.DebugMessage(reader.BaseStream, "Load, End, MaskInfo");
}
///////////////////////////////////////////////////////////////////////////
/// <summary>
/// Load Layers Info section, including image data.
/// </summary>
/// <param name="reader">PSD reader.</param>
/// <param name="hasHeader">Whether the Layers Info section has a length header.</param>
private void LoadLayers(PsdBinaryReader reader, bool hasHeader)
{
UInt32 sectionLength = 0;
if (hasHeader)
{
sectionLength = reader.ReadUInt32();
if (sectionLength <= 0)
{
return;
}
}
var startPosition = reader.BaseStream.Position;
var numLayers = reader.ReadInt16();
// If numLayers < 0, then number of layers is absolute value,
// and the first alpha channel contains the transparency data for
// the merged result.
if (numLayers < 0)
{
AbsoluteAlpha = true;
numLayers = Math.Abs(numLayers);
}
if (numLayers == 0)
{
return;
}
for (int i = 0; i < numLayers; i++)
{
var layer = new Layer(reader, this);
Layers.Add(layer);
}
//-----------------------------------------------------------------------
// Load image data for all channels.
foreach (var layer in Layers)
{
foreach (var channel in layer.Channels)
{
channel.LoadPixelData(reader);
}
}
// Length is set to 0 when called on higher bitdepth layers.
if (sectionLength > 0)
{
// Layers Info section is documented to be even-padded, but Photoshop
// actually pads to 4 bytes.
var endPosition = startPosition + sectionLength;
var positionOffset = reader.BaseStream.Position - endPosition;
if (reader.BaseStream.Position < endPosition)
{
reader.BaseStream.Position = endPosition;
}
}
}
public MaskInfo(PsdBinaryReader reader, Layer layer)
{
Debug.WriteLine("MaskInfo started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
{
return;
}
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + maskLength;
// Read layer mask
var rectangle = reader.ReadRectangle();
var backgroundColor = reader.ReadByte();
var flagsByte = reader.ReadByte();
LayerMask = new Mask(layer, rectangle, backgroundColor, new BitVector32(flagsByte));
// User mask is supplied separately when there is also a vector mask.
if (maskLength == 36)
{
var userFlagsByte = reader.ReadByte();
var userBackgroundColor = reader.ReadByte();
var userRectangle = reader.ReadRectangle();
UserMask = new Mask(layer, userRectangle, userBackgroundColor,
new BitVector32(userFlagsByte));
}
// 20-byte mask data will end with padding.
reader.BaseStream.Position = endPosition;
}
///////////////////////////////////////////////////////////////////////////
private void LoadImageResources(PsdBinaryReader reader)
{
Debug.WriteLine("LoadImageResources started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
ImageResources.Clear();
var imageResourcesLength = reader.ReadUInt32();
if (imageResourcesLength <= 0)
{
return;
}
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + imageResourcesLength;
while (reader.BaseStream.Position < endPosition)
{
var imageResource = ImageResourceFactory.CreateImageResource(reader);
ImageResources.Add(imageResource);
}
//-----------------------------------------------------------------------
// make sure we are not on a wrong offset, so set the stream position
// manually
reader.BaseStream.Position = startPosition + imageResourcesLength;
}
public ColorStop(PsdBinaryReader reader)
{
uint localColorStop = reader.ReadUInt32();
uint midpointColorStop = reader.ReadUInt32();
ushort followColorMode = reader.ReadUInt16();
ActualColor = reader.ReadPSDColor(16, true);
ushort numTransparency = reader.ReadUInt16();
Trsps = new List <Transparency>(numTransparency);
for (int j = 0; j < numTransparency; j++)
{
Trsps.Add(new Transparency(reader));
}
}
public static ImageResource CreateImageResource(PsdBinaryReader reader)
{
Debug.Print("ImageResource started at {0}", reader.BaseStream.Position);
var signature = reader.ReadAsciiChars(4);
var resourceIdInt = reader.ReadUInt16();
var name = reader.ReadPascalString(2);
var dataLength = (int)reader.ReadUInt32();
var dataPaddedLength = Util.RoundUp(dataLength, 2);
var endPosition = reader.BaseStream.Position + dataPaddedLength;
ImageResource resource = null;
var resourceId = (ResourceID)resourceIdInt;
switch (resourceId)
{
case ResourceID.ResolutionInfo:
resource = new ResolutionInfo(reader, name);
break;
case ResourceID.ThumbnailRgb:
case ResourceID.ThumbnailBgr:
resource = new Thumbnail(reader, resourceId, name, dataLength);
break;
case ResourceID.AlphaChannelNames:
resource = new AlphaChannelNames(reader, name, dataLength);
break;
case ResourceID.UnicodeAlphaNames:
resource = new UnicodeAlphaNames(reader, name, dataLength);
break;
case ResourceID.VersionInfo:
resource = new VersionInfo(reader, name);
break;
default:
resource = new RawImageResource(reader, signature, resourceId, name, dataLength);
break;
}
// Reposition the reader if we do not consume the full resource block.
// This takes care of the even-padding, and also preserves forward-
// compatibility in case a resource block is later extended with
// additional properties.
if (reader.BaseStream.Position < endPosition)
{
reader.BaseStream.Position = endPosition;
}
// However, overruns are definitely an error.
if (reader.BaseStream.Position > endPosition)
{
throw new PsdInvalidException("Corruption detected in resource.");
}
return(resource);
}
///////////////////////////////////////////////////////////////////////////
private void LoadImageResources(PsdBinaryReader reader)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, ImageResources");
var imageResourcesLength = reader.ReadUInt32();
if (imageResourcesLength <= 0)
{
return;
}
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + imageResourcesLength;
while (reader.BaseStream.Position < endPosition)
{
var imageResource = ImageResourceFactory.CreateImageResource(reader);
ImageResources.Add(imageResource);
}
Util.DebugMessage(reader.BaseStream, "Load, End, ImageResources");
//-----------------------------------------------------------------------
// make sure we are not on a wrong offset, so set the stream position
// manually
reader.BaseStream.Position = startPosition + imageResourcesLength;
}
public LayerText(PsdBinaryReader psdReader, int dataLength)
{
Data = psdReader.ReadBytes((int)dataLength);
var reader = new PsdBinaryReader(new System.IO.MemoryStream(Data), psdReader);
// PhotoShop version
reader.ReadUInt16();
Transform = new Matrix2D(reader);
// TextVersion
reader.ReadUInt16(); //2 bytes, =50. For Photoshop 6.0.
// DescriptorVersion
reader.ReadUInt32(); //4 bytes,=16. For Photoshop 6.0.
TxtDescriptor = DynVal.ReadDescriptor(reader); //Text descriptor
// WarpVersion
reader.ReadUInt16(); //2 bytes, =1. For Photoshop 6.0.
engineData = (Dictionary <string, object>)TxtDescriptor.Children.Find(c => c.Name == "EngineData").Value;
StylesheetReader = new TdTaStylesheetReader(engineData);
Dictionary <string, object> d = StylesheetReader.GetStylesheetDataFromLongestRun();
Text = StylesheetReader.Text;
FontName = TdTaParser.getString(StylesheetReader.getFontSet()[(int)TdTaParser.query(d, "Font")], "Name$");
FontSize = (double)TdTaParser.query(d, "FontSize");
try
{
FauxBold = TdTaParser.getBool(d, "FauxBold");
}
catch (KeyNotFoundException)
{
FauxBold = false;
}
try
{
FauxItalic = TdTaParser.getBool(d, "FauxItalic");
}
catch (KeyNotFoundException)
{
FauxItalic = false;
}
try
{
Underline = TdTaParser.getBool(d, "Underline");
}
catch (KeyNotFoundException)
{
Underline = false;
}
FillColor = TdTaParser.getColor(d, "FillColor");
}
public FontInfo(PsdBinaryReader r)
{
Mark = r.ReadUInt16();
FontType = r.ReadUInt32();
FontName = r.ReadPascalString(2);
FontFamilyName = r.ReadPascalString(2);
FontStyleName = r.ReadPascalString(2);
Script = r.ReadUInt16();
ushort NumDesignAxesVectors = r.ReadUInt16();
DesignVectors = new List <uint>();
for (int vectorNum = 0; vectorNum < NumDesignAxesVectors; vectorNum++)
{
DesignVectors.Add(r.ReadUInt32());
}
}
private void LoadColorModeData(PsdBinaryReader reader)
{
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0)
{
ColorModeData = reader.ReadBytes((int)paletteLength);
}
}
/// <summary>
/// A peculiar type of ascii string frequently used throughout the Descriptor data structure.
/// First 4 bytes are length (in bytes), followed by string. If length is 0, length is assumed to be 4. No idea why they did this... RLE compression?
/// </summary>
/// <param name="r"></param>
/// <returns></returns>
public static string ReadSpecialString(PsdBinaryReader r)
{
uint length = r.ReadUInt32();
if (length == 0)
{
length = 4;
}
return(System.Text.Encoding.ASCII.GetString(r.ReadBytes((int)length)));
}
/// <summary>
/// A peculiar type of ascii string frequently used throughout the Descriptor data structure.
/// First 4 bytes are length (in bytes), followed by string. If length is 0, length is assumed to be 4. No idea why they did this... RLE compression?
/// </summary>
/// <param name="r"></param>
/// <returns></returns>
public static string ReadSpecialString(PsdBinaryReader r)
{
uint length = r.ReadUInt32();
if (length == 0)
{
length = 4;
}
return(r.ReadAsciiChars((int)length));
}
public MetadataSetting(PsdBinaryReader reader)
{
uint metadataCount = reader.ReadUInt32();
Metadatas = new List <Metadata>((int)metadataCount);
for (int i = 0; i < metadataCount; i++)
{
Metadatas.Add(new Metadata(reader));
}
}
public static DynVal ReadAlias(PsdBinaryReader r)
{
DynVal v = new DynVal();
v.Type = OSType.Alias;
uint length = r.ReadUInt32();
v.Value = r.ReadBytes((int)length);
return(v);
}
public ShadowEffect(PsdBinaryReader r, string key)
{
m_key = key;
int version = r.ReadInt32();
this.Blur = r.ReadUInt32();
this.Intensity = r.ReadUInt32();
this.Angle = r.ReadUInt32();
this.Distance = r.ReadUInt32();
Color shadowColor = r.ReadPSDColor(16, true);
this.BlendModeKey = this.ReadBlendKey(r);
this.Enabled = r.ReadBoolean();
this.UseGlobalAngle = r.ReadBoolean();
this.Opacity = r.ReadByte();
NativeColor = r.ReadPSDColor(16, true);
this.Color = Util.FromArgb(Opacity, shadowColor);
}
public static DynVal ReadOffset(PsdBinaryReader r)
{
DynVal v = new DynVal();
v.Type = OSType.OffestRef;
v.UnicodeName = r.ReadUnicodeString();
v.classID = ReadSpecialString(r);
v.Name = GetMeaningOfFourCC(v.classID);
v.Value = r.ReadUInt32();
return(v);
}
private void LoadGlobalLayerMask(PsdBinaryReader reader)
{
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
{
return;
}
GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
}
private void LoadColorModeData(PsdBinaryReader reader)
{
Debug.WriteLine("LoadColorModeData started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0)
{
ColorModeData = reader.ReadBytes((int)paletteLength);
}
}
public Transparency(PsdBinaryReader reader)
{
uint localColorStop = reader.ReadUInt32();
uint midpointColorStop = reader.ReadUInt32();
Opacity = reader.ReadUInt16();
ushort expansionCount = reader.ReadUInt16();
ushort interpolation = reader.ReadUInt16();
ushort length = reader.ReadUInt16();
ushort gradientMode = reader.ReadUInt16();
uint randomNumSeed = reader.ReadUInt32();
ushort showFlag = reader.ReadUInt16();
ushort usingVectorColorFlag = reader.ReadUInt16();
uint roughnessFactor = reader.ReadUInt16();
ushort colorModel = reader.ReadUInt16();
MinColor = reader.ReadPSDColor(16, true);
MaxColor = reader.ReadPSDColor(16, true);
ushort dummy = reader.ReadUInt16();
}
///////////////////////////////////////////////////////////////////////////
private void LoadLayerAndMaskInfo(PsdBinaryReader reader)
{
Debug.WriteLine("LoadLayerAndMaskInfo started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var layersAndMaskLength = reader.ReadUInt32();
if (layersAndMaskLength <= 0)
{
return;
}
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + layersAndMaskLength;
LoadLayers(reader, true);
LoadGlobalLayerMask(reader);
//-----------------------------------------------------------------------
// Load Additional Layer Information
while (reader.BaseStream.Position < endPosition)
{
var info = LayerInfoFactory.Load(reader);
AdditionalInfo.Add(info);
if (info is RawLayerInfo)
{
var layerInfo = (RawLayerInfo)info;
switch (info.Key)
{
case "Layr":
case "Lr16":
case "Lr32":
using (var memoryStream = new MemoryStream(layerInfo.Data))
using (var memoryReader = new PsdBinaryReader(memoryStream, reader))
{
LoadLayers(memoryReader, false);
}
break;
case "LMsk":
GlobalLayerMaskData = layerInfo.Data;
break;
}
}
}
//-----------------------------------------------------------------------
// make sure we are not on a wrong offset, so set the stream position
// manually
reader.BaseStream.Position = startPosition + layersAndMaskLength;
}
private void LoadGlobalLayerMask(PsdBinaryReader reader)
{
Debug.WriteLine("LoadGlobalLayerMask started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
{
return;
}
GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
}
private void LoadColorModeData(PsdBinaryReader reader)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, ColorModeData");
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0)
{
ColorModeData = reader.ReadBytes((int)paletteLength);
}
Util.DebugMessage(reader.BaseStream, "Load, End, ColorModeData");
}
public Thumbnail(PsdBinaryReader psdReader, ResourceID id, string name, int numBytes)
: base(psdReader, "8BIM", id, name, numBytes)
{
using (var memoryStream = new MemoryStream(Data))
using (var reader = new PsdBinaryReader(memoryStream, psdReader))
{
const int HEADER_LENGTH = 28;
var format = reader.ReadUInt32();
//var width = reader.ReadUInt32();
//var height = reader.ReadUInt32();
//var widthBytes = reader.ReadUInt32();
//var size = reader.ReadUInt32();
//var compressedSize = reader.ReadUInt32();
//var bitPerPixel = reader.ReadUInt16();
//var planes = reader.ReadUInt16();
// Raw RGB bitmap
if (format == 0)
{
//Image = new Bitmap((int)width, (int)height, PixelFormat.Format24bppRgb);
}
// JPEG bitmap
else if (format == 1)
{
byte[] imgData = reader.ReadBytes(numBytes - HEADER_LENGTH);
using (MemoryStream stream = new MemoryStream(imgData))
{
//var bitmap = new Bitmap(stream);
//Image = (Bitmap)bitmap.Clone();
}
// Reverse BGR pixels from old thumbnail format
if (id == ResourceID.ThumbnailBgr)
{
//for(int y=0;y<m_thumbnailImage.Height;y++)
// for (int x = 0; x < m_thumbnailImage.Width; x++)
// {
// Color c=m_thumbnailImage.GetPixel(x,y);
// Color c2=Color.FromArgb(c.B, c.G, c.R);
// m_thumbnailImage.SetPixel(x, y, c);
// }
}
}
else
{
throw new PsdInvalidException("Unknown thumbnail format.");
}
}
}
/// <summary>
/// Parses either a list format or a dictionary format. Specify skipKeys=true to parse the list format
/// </summary>
/// <param name="r"></param>
/// <param name="skipKeys"></param>
/// <returns></returns>
public static List <DynVal> ReadValues(PsdBinaryReader r, bool skipKeys)
{
// if (!r.CanReadByte())
// return null;
int numValues = (int)r.ReadUInt32();
List <DynVal> values = new List <DynVal>(numValues);
for (int i = 0; i < numValues; i++)
{
values.Add(ReadValue(r, skipKeys));
}
return(values);
}
///////////////////////////////////////////////////////////////////////////
private void LoadLayerAndMaskInfo(PsdBinaryReader reader)
{
Util.DebugMessage(reader.BaseStream, "Load, Begin, Layer and mask info");
var layersAndMaskLength = IsLargeDocument
? reader.ReadInt64()
: reader.ReadUInt32();
if (layersAndMaskLength <= 0)
{
return;
}
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + layersAndMaskLength;
LoadLayers(reader, true);
LoadGlobalLayerMask(reader);
//-----------------------------------------------------------------------
// Load Additional Layer Information
while (reader.BaseStream.Position < endPosition)
{
var info = LayerInfoFactory.Load(reader,
psdFile: this,
globalLayerInfo: true, endPosition);
AdditionalInfo.Add(info);
if (info is RawLayerInfo)
{
var layerInfo = (RawLayerInfo)info;
switch (info.Key)
{
case "LMsk":
m_GlobalLayerMaskData = layerInfo.Data;
break;
}
}
}
Util.DebugMessage(reader.BaseStream, "Load, End, Layer and mask info");
//-----------------------------------------------------------------------
// make sure we are not on a wrong offset, so set the stream position
// manually
reader.BaseStream.Position = startPosition + layersAndMaskLength;
}
public Thumbnail(PsdBinaryReader psdReader, ResourceID id, string name, int numBytes)
: base(psdReader, "8BIM", id, name, numBytes)
{
using (var memoryStream = new MemoryStream(Data))
using (var reader = new PsdBinaryReader(memoryStream, psdReader))
{
const int HEADER_LENGTH = 28;
var format = reader.ReadUInt32();
var width = reader.ReadUInt32();
var height = reader.ReadUInt32();
var widthBytes = reader.ReadUInt32();
var size = reader.ReadUInt32();
var compressedSize = reader.ReadUInt32();
var bitPerPixel = reader.ReadUInt16();
var planes = reader.ReadUInt16();
// Raw RGB bitmap
if (format == 0)
{
Image = new Bitmap((int)width, (int)height, PixelFormat.Format24bppRgb);
}
// JPEG bitmap
else if (format == 1)
{
byte[] imgData = reader.ReadBytes(numBytes - HEADER_LENGTH);
using (MemoryStream stream = new MemoryStream(imgData))
{
var bitmap = new Bitmap(stream);
Image = (Bitmap)bitmap.Clone();
}
// Reverse BGR pixels from old thumbnail format
if (id == ResourceID.ThumbnailBgr)
{
//for(int y=0;y<m_thumbnailImage.Height;y++)
// for (int x = 0; x < m_thumbnailImage.Width; x++)
// {
// Color c=m_thumbnailImage.GetPixel(x,y);
// Color c2=Color.FromArgb(c.B, c.G, c.R);
// m_thumbnailImage.SetPixel(x, y, c);
// }
}
}
else
{
throw new PsdInvalidException("Unknown thumbnail format.");
}
}
}
///////////////////////////////////////////////////////////////////////////
/// <summary>
/// Load Layers Info section, including image data.
/// </summary>
/// <param name="reader">PSD reader.</param>
/// <param name="hasHeader">Whether the Layers Info section has a length header.</param>
private void LoadLayers(PsdBinaryReader reader, bool hasHeader) {
UInt32 sectionLength = 0;
if (hasHeader) {
sectionLength = reader.ReadUInt32();
if (sectionLength <= 0)
return;
}
var startPosition = reader.BaseStream.Position;
var numLayers = reader.ReadInt16();
// If numLayers < 0, then number of layers is absolute value,
// and the first alpha channel contains the transparency data for
// the merged result.
if (numLayers < 0) {
AbsoluteAlpha = true;
numLayers = Math.Abs(numLayers);
}
if (numLayers == 0)
return;
for (int i = 0; i < numLayers; i++) {
var layer = new Layer(reader, this);
Layers.Add(layer);
}
//-----------------------------------------------------------------------
// Load image data for all channels.
foreach (var layer in Layers) {
foreach (var channel in layer.Channels) {
channel.LoadPixelData(reader);
}
}
// Length is set to 0 when called on higher bitdepth layers.
if (sectionLength > 0) {
// Layers Info section is documented to be even-padded, but Photoshop
// actually pads to 4 bytes.
var endPosition = startPosition + sectionLength;
var positionOffset = reader.BaseStream.Position - endPosition;
if (reader.BaseStream.Position < endPosition)
reader.BaseStream.Position = endPosition;
}
}
private void LoadGlobalLayerMask(PsdBinaryReader reader)
{
Debug.WriteLine("LoadGlobalLayerMask started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
return;
GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
}
public MaskInfo(PsdBinaryReader reader, Layer layer)
{
Debug.WriteLine("MaskInfo started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
return;
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + maskLength;
// Read layer mask
var rectangle = reader.ReadRectangle();
var backgroundColor = reader.ReadByte();
var flagsByte = reader.ReadByte();
LayerMask = new Mask(layer, rectangle, backgroundColor, new BitVector32(flagsByte));
// User mask is supplied separately when there is also a vector mask.
if (maskLength == 36)
{
var userFlagsByte = reader.ReadByte();
var userBackgroundColor = reader.ReadByte();
var userRectangle = reader.ReadRectangle();
UserMask = new Mask(layer, userRectangle, userBackgroundColor,
new BitVector32(userFlagsByte));
}
// 20-byte mask data will end with padding.
reader.BaseStream.Position = endPosition;
}
///////////////////////////////////////////////////////////////////////////
private void LoadLayerAndMaskInfo(PsdBinaryReader reader) {
var layersAndMaskLength = reader.ReadUInt32();
if (layersAndMaskLength <= 0)
return;
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + layersAndMaskLength;
LoadLayers(reader, true);
LoadGlobalLayerMask(reader);
//-----------------------------------------------------------------------
// Load Additional Layer Information
while (reader.BaseStream.Position < endPosition) {
var info = LayerInfoFactory.Load(reader);
AdditionalInfo.Add(info);
if (info is RawLayerInfo) {
var layerInfo = (RawLayerInfo)info;
switch (info.Key) {
case "Layr":
case "Lr16":
case "Lr32":
using (var memoryStream = new MemoryStream(layerInfo.Data))
using (var memoryReader = new PsdBinaryReader(memoryStream, reader)) {
LoadLayers(memoryReader, false);
}
break;
case "LMsk":
GlobalLayerMaskData = layerInfo.Data;
break;
}
}
}
//-----------------------------------------------------------------------
// make sure we are not on a wrong offset, so set the stream position
// manually
reader.BaseStream.Position = startPosition + layersAndMaskLength;
}
///////////////////////////////////////////////////////////////////////////
private void LoadImageResources(PsdBinaryReader reader)
{
Debug.WriteLine("LoadImageResources started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
ImageResources.Clear();
var imageResourcesLength = reader.ReadUInt32();
if (imageResourcesLength <= 0)
return;
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + imageResourcesLength;
while (reader.BaseStream.Position < endPosition)
{
var imageResource = ImageResourceFactory.CreateImageResource(reader);
ImageResources.Add(imageResource);
}
//-----------------------------------------------------------------------
// make sure we are not on a wrong offset, so set the stream position
// manually
reader.BaseStream.Position = startPosition + imageResourcesLength;
}
///////////////////////////////////////////////////////////////////////////
private void LoadImageResources(PsdBinaryReader reader) {
var imageResourcesLength = reader.ReadUInt32();
if (imageResourcesLength <= 0)
return;
var startPosition = reader.BaseStream.Position;
var endPosition = startPosition + imageResourcesLength;
while (reader.BaseStream.Position < endPosition) {
var imageResource = ImageResourceFactory.CreateImageResource(reader);
ImageResources.Add(imageResource);
}
//-----------------------------------------------------------------------
// make sure we are not on a wrong offset, so set the stream position
// manually
reader.BaseStream.Position = startPosition + imageResourcesLength;
}
public Layer(PsdBinaryReader reader, PsdFile psdFile)
: this(psdFile)
{
Rect = reader.ReadRectangle();
//-----------------------------------------------------------------------
// Read channel headers. Image data comes later, after the layer header.
int numberOfChannels = reader.ReadUInt16();
for (int channel = 0; channel < numberOfChannels; channel++)
{
var ch = new Channel(reader, this);
Channels.Add(ch);
}
//-----------------------------------------------------------------------
//
var signature = reader.ReadAsciiChars(4);
if (signature != "8BIM")
throw (new PsdInvalidException("Invalid signature in layer header."));
BlendModeKey = reader.ReadAsciiChars(4);
Opacity = reader.ReadByte();
Clipping = reader.ReadBoolean();
var flagsByte = reader.ReadByte();
flags = new BitVector32(flagsByte);
reader.ReadByte(); //padding
//-----------------------------------------------------------------------
// This is the total size of the MaskData, the BlendingRangesData, the
// Name and the AdjustmentLayerInfo.
var extraDataSize = reader.ReadUInt32();
var extraDataStartPosition = reader.BaseStream.Position;
Masks = new MaskInfo(reader, this);
BlendingRangesData = new BlendingRanges(reader, this);
Name = reader.ReadPascalString(4);
//-----------------------------------------------------------------------
// Process Additional Layer Information
long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;
while (reader.BaseStream.Position < adjustmentLayerEndPos)
{
var layerInfo = LayerInfoFactory.Load(reader);
AdditionalInfo.Add(layerInfo);
}
foreach (var adjustmentInfo in AdditionalInfo)
{
switch (adjustmentInfo.Key)
{
case "luni":
Name = ((LayerUnicodeName)adjustmentInfo).Name;
break;
}
}
}
private void LoadColorModeData(PsdBinaryReader reader)
{
Debug.WriteLine("LoadColorModeData started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0)
{
ColorModeData = reader.ReadBytes((int)paletteLength);
}
}
private void LoadGlobalLayerMask(PsdBinaryReader reader) {
var maskLength = reader.ReadUInt32();
if (maskLength <= 0)
return;
GlobalLayerMaskData = reader.ReadBytes((int)maskLength);
}
private void LoadColorModeData(PsdBinaryReader reader) {
var paletteLength = reader.ReadUInt32();
if (paletteLength > 0) {
ColorModeData = reader.ReadBytes((int)paletteLength);
}
}
