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); } }