////////////////////////////////////////////////////////////////// internal void LoadPixelData(PsdBinaryReader reader) { Debug.WriteLine("Channel.LoadPixelData started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); var endPosition = reader.BaseStream.Position + this.Length; ImageCompression = (ImageCompression)reader.ReadInt16(); imageDataCompressed = true; var dataLength = this.Length - 2; switch (ImageCompression) { case ImageCompression.Raw: ImageData = reader.ReadBytes(dataLength); break; case ImageCompression.Rle: // RLE row lengths RleHeader = reader.ReadBytes(2 * Rect.Height); var rleDataLength = dataLength - 2 * Rect.Height; // The PSD specification states that rows are padded to even sizes. // However, PSD files generated by Photoshop CS4 do not actually // follow this stipulation. Data = reader.ReadBytes(rleDataLength); break; case ImageCompression.Zip: case ImageCompression.ZipPrediction: Data = reader.ReadBytes(dataLength); break; } Debug.Assert(reader.BaseStream.Position == endPosition, "Pixel data successfully read in."); }
////////////////////////////////////////////////////////////////// internal void LoadPixelData(PsdBinaryReader reader) { var endPosition = reader.BaseStream.Position + this.Length; ImageCompression = (ImageCompression)reader.ReadInt16(); var dataLength = this.Length - 2; switch (ImageCompression) { case ImageCompression.Raw: ImageDataRaw = reader.ReadBytes(dataLength); break; case ImageCompression.Rle: // RLE row lengths RleRowLengths = new RleRowLengths(reader, (int)Rect.height); var rleDataLength = (int)(endPosition - reader.BaseStream.Position); // The PSD specification states that rows are padded to even sizes. // However, Photoshop doesn't actually do this. RLE rows can have // odd lengths in the header, and there is no padding between rows. ImageDataRaw = reader.ReadBytes(rleDataLength); break; case ImageCompression.Zip: case ImageCompression.ZipPrediction: ImageDataRaw = reader.ReadBytes(dataLength); break; } }
/////////////////////////////////////////////////////////////////////////// #endregion /////////////////////////////////////////////////////////////////////////// #region ImageData /////////////////////////////////////////////////////////////////////////// private void LoadImage(PsdBinaryReader reader) { Debug.WriteLine("LoadImage started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); BaseLayer.Rect = new Rectangle(0, 0, ColumnCount, RowCount); ImageCompression = (ImageCompression)reader.ReadInt16(); switch (ImageCompression) { case ImageCompression.Raw: var length = this.RowCount * Util.BytesPerRow(BaseLayer.Rect, BitDepth); for (Int16 i = 0; i < ChannelCount; i++) { var channel = new Channel(i, this.BaseLayer); channel.ImageCompression = ImageCompression; channel.Length = length; channel.ImageData = reader.ReadBytes(length); BaseLayer.Channels.Add(channel); } break; case ImageCompression.Rle: // Store RLE data length for (Int16 i = 0; i < ChannelCount; i++) { var channel = new Channel(i, this.BaseLayer); channel.RleHeader = reader.ReadBytes(2 * RowCount); int totalRleLength = 0; using (var memoryStream = new MemoryStream(channel.RleHeader)) using (var memoryReader = new PsdBinaryReader(memoryStream, Encoding.ASCII)) { for (int j = 0; j < RowCount; j++) { totalRleLength += memoryReader.ReadUInt16(); } } channel.ImageCompression = this.ImageCompression; channel.Length = (int)totalRleLength; this.BaseLayer.Channels.Add(channel); } foreach (var channel in this.BaseLayer.Channels) { channel.Data = reader.ReadBytes(channel.Length); } break; } // If there is one more channel than we need, then it is the alpha channel if (ChannelCount == ColorMode.ChannelCount() + 1) { var alphaChannel = BaseLayer.Channels.Last(); alphaChannel.ID = -1; } }
//internal void Save(PsdBinaryWriter writer) //{ // Util.DebugMessage(writer.BaseStream, "Save, Begin, Channel"); // writer.Write(ID); // if (Layer.PsdFile.IsLargeDocument) // { // writer.Write(Length); // } // else // { // writer.Write((Int32)Length); // } // Util.DebugMessage(writer.BaseStream, "Save, End, Channel, {0}", ID); //} ////////////////////////////////////////////////////////////////// internal void LoadPixelData(PsdBinaryReader reader) { Util.DebugMessage(reader.BaseStream, "Load, Begin, Channel image"); if (Length == 0) { ImageCompression = ImageCompression.Raw; ImageDataRaw = new byte[0]; return; } var endPosition = reader.BaseStream.Position + this.Length; ImageCompression = (ImageCompression)reader.ReadInt16(); var longDataLength = this.Length - 2; Util.CheckByteArrayLength(longDataLength); var dataLength = (int)longDataLength; switch (ImageCompression) { case ImageCompression.Raw: ImageDataRaw = reader.ReadBytes(dataLength); break; case ImageCompression.Rle: // RLE row lengths RleRowLengths = new RleRowLengths(reader, Rect.Height, Layer.PsdFile.IsLargeDocument); var rleDataLength = (int)(endPosition - reader.BaseStream.Position); Debug.Assert(rleDataLength == RleRowLengths.Total, "RLE row lengths do not sum to length of channel image data."); // The PSD specification states that rows are padded to even sizes. // However, Photoshop doesn't actually do this. RLE rows can have // odd lengths in the header, and there is no padding between rows. ImageDataRaw = reader.ReadBytes(rleDataLength); break; case ImageCompression.Zip: case ImageCompression.ZipPrediction: ImageDataRaw = reader.ReadBytes(dataLength); break; } Util.DebugMessage(reader.BaseStream, "Load, End, Channel image, {0}", ID, Layer.Name); Debug.Assert(reader.BaseStream.Position == endPosition, "Pixel data was not fully read in."); }
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 RawImageResource(PsdBinaryReader reader, string signature, ResourceID resourceId, string name, int numBytes) : base(name) { this.Signature = signature; this.id = resourceId; Data = reader.ReadBytes(numBytes); }
public Metadata(PsdBinaryReader reader) { string signature = reader.ReadAsciiChars(4); if (signature != "8BIM") { throw new PsdInvalidException("Could not read LayerInfo due to signature mismatch." + signature); } Key = reader.ReadAsciiChars(4); bool sheetCopy = reader.ReadBoolean(); byte[] padding = reader.ReadBytes(3); uint length = reader.ReadUInt32(); byte[] datas = reader.ReadBytes((int)length); }
private void LoadColorModeData(PsdBinaryReader reader) { var paletteLength = reader.ReadUInt32(); if (paletteLength > 0) { ColorModeData = reader.ReadBytes((int)paletteLength); } }
public RawLayerInfo(PsdBinaryReader reader, string signature, string key, long dataLength) { this.signature = signature; this.key = key; Util.CheckByteArrayLength(dataLength); Data = reader.ReadBytes((int)dataLength); }
/// <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))); }
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); }
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); }
/////////////////////////////////////////////////////////////////////////// public BlendingRanges(PsdBinaryReader reader, Layer layer) { Debug.WriteLine("BlendingRanges started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); Layer = layer; var dataLength = reader.ReadInt32(); if (dataLength <= 0) return; Data = reader.ReadBytes(dataLength); }
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"); }
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 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(); // widthBytes reader.ReadUInt32(); // size reader.ReadUInt32(); // compressedSize reader.ReadUInt32(); // bitPerPixel reader.ReadUInt16(); // planes reader.ReadUInt16(); // Raw RGB bitmap if (format == 0) { Image = new Texture2D((int)width, (int)height, TextureFormat.RGB24, true); } // JPEG bitmap else if (format == 1) { byte[] imgData = reader.ReadBytes(numBytes - HEADER_LENGTH); Image = new Texture2D((int)width, (int)height, TextureFormat.RGB24, true); Image.LoadImage(imgData); // 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."); } } }
/////////////////////////////////////////////////////////////////////////// public BlendingRanges(PsdBinaryReader reader, Layer layer) { Debug.WriteLine("BlendingRanges started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); Layer = layer; var dataLength = reader.ReadInt32(); if (dataLength <= 0) { return; } Data = reader.ReadBytes(dataLength); }
/////////////////////////////////////////////////////////////////////////// public BlendingRanges(PsdBinaryReader reader, Layer layer) { Debug.WriteLine("BlendingRanges started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); Layer = layer; var dataLength = reader.ReadInt32(); if (dataLength <= 0) { Data = new byte[0]; // modified to avoid exception at Save method (butaman) return; } Data = reader.ReadBytes(dataLength); }
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."); } } }
/////////////////////////////////////////////////////////////////////////// public BlendingRanges(PsdBinaryReader reader, Layer layer) { Util.DebugMessage(reader.BaseStream, "Load, Begin, BlendingRanges"); Layer = layer; var dataLength = reader.ReadInt32(); if (dataLength <= 0) { return; } Data = reader.ReadBytes(dataLength); Util.DebugMessage(reader.BaseStream, "Load, End, BlendingRanges"); }
private void LoadGlobalLayerMask(PsdBinaryReader reader) { Util.DebugMessage(reader.BaseStream, "Load, Begin, GlobalLayerMask"); var maskLength = reader.ReadUInt32(); if (maskLength <= 0) { Util.DebugMessage(reader.BaseStream, "Load, End, GlobalLayerMask"); return; } m_GlobalLayerMaskData = reader.ReadBytes((int)maskLength); Util.DebugMessage(reader.BaseStream, "Load, End, GlobalLayerMask"); }
private void LoadImage(PsdBinaryReader reader) { Util.DebugMessage(reader.BaseStream, "Load, Begin, Composite image"); ImageCompression = (ImageCompression)reader.ReadInt16(); // Create channels for (Int16 i = 0; i < ChannelCount; i++) { Util.DebugMessage(reader.BaseStream, "Load, Begin, Channel image data"); var channel = new Channel(i, this.BaseLayer); channel.ImageCompression = ImageCompression; channel.Length = this.RowCount * Util.BytesPerRow(BaseLayer.Rect.Size, BitDepth); // The composite image stores all RLE headers up-front, rather than // with each channel. if (ImageCompression == ImageCompression.Rle) { channel.RleRowLengths = new RleRowLengths(reader, RowCount, IsLargeDocument); channel.Length = channel.RleRowLengths.Total; } BaseLayer.Channels.Add(channel); Util.DebugMessage(reader.BaseStream, "Load, End, Channel image data"); } foreach (var channel in this.BaseLayer.Channels) { Util.DebugMessage(reader.BaseStream, "Load, Begin, Channel image data"); Util.CheckByteArrayLength(channel.Length); channel.ImageDataRaw = reader.ReadBytes((int)channel.Length); Util.DebugMessage(reader.BaseStream, "Load, End, Channel image data"); } // If there is exactly one more channel than we need, then it is the // alpha channel. if ((ColorMode != PsdColorMode.Multichannel) && (ChannelCount == ColorMode.MinChannelCount() + 1)) { var alphaChannel = BaseLayer.Channels.Last(); alphaChannel.ID = -1; } Util.DebugMessage(reader.BaseStream, "Load, End, Composite image"); }
/////////////////////////////////////////////////////////////////////////// private void LoadImage(PsdBinaryReader reader) { Debug.WriteLine("LoadImage started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture)); BaseLayer.Rect = new Rectangle(0, 0, ColumnCount, RowCount); ImageCompression = (ImageCompression)reader.ReadInt16(); switch (ImageCompression) { case ImageCompression.Raw: var length = this.RowCount * Util.BytesPerRow(BaseLayer.Rect, BitDepth); for (Int16 i = 0; i < ChannelCount; i++) { var channel = new Channel(i, this.BaseLayer); channel.ImageCompression = ImageCompression; channel.Length = length; channel.ImageData = reader.ReadBytes(length); BaseLayer.Channels.Add(channel); } break; case ImageCompression.Rle: // Store RLE data length for (Int16 i = 0; i < ChannelCount; i++) { var channel = new Channel(i, this.BaseLayer); channel.RleHeader = reader.ReadBytes(2 * RowCount); int totalRleLength = 0; using (var memoryStream = new MemoryStream(channel.RleHeader)) using (var memoryReader = new PsdBinaryReader(memoryStream, Encoding.ASCII)) { for (int j = 0; j < RowCount; j++) totalRleLength += memoryReader.ReadUInt16(); } channel.ImageCompression = this.ImageCompression; channel.Length = (int)totalRleLength; this.BaseLayer.Channels.Add(channel); } foreach (var channel in this.BaseLayer.Channels) { channel.Data = reader.ReadBytes(channel.Length); } break; } // If there is one more channel than we need, then it is the alpha channel if (ChannelCount == ColorMode.ChannelCount() + 1) { var alphaChannel = BaseLayer.Channels.Last(); alphaChannel.ID = -1; } }
/////////////////////////////////////////////////////////////////////////// #endregion /////////////////////////////////////////////////////////////////////////// #region ImageData /////////////////////////////////////////////////////////////////////////// private void LoadImage(PsdBinaryReader reader) { ImageCompression = (ImageCompression)reader.ReadInt16(); // Create channels for (Int16 i = 0; i < ChannelCount; i++) { var channel = new Channel(i, this.BaseLayer); channel.ImageCompression = ImageCompression; channel.Length = this.RowCount * Util.BytesPerRow(BaseLayer.Rect, BitDepth); // The composite image stores all RLE headers up-front, rather than // with each channel. if (ImageCompression == ImageCompression.Rle) { channel.RleRowLengths = new RleRowLengths(reader, RowCount); channel.Length = channel.RleRowLengths.Total; } BaseLayer.Channels.Add(channel); } foreach (var channel in this.BaseLayer.Channels) { channel.ImageDataRaw = reader.ReadBytes(channel.Length); } // If there is exactly one more channel than we need, then it is the // alpha channel. if ((ColorMode != PsdColorMode.Multichannel) && (ChannelCount == ColorMode.MinChannelCount() + 1)) { var alphaChannel = BaseLayer.Channels.Last(); alphaChannel.ID = -1; } }
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 RawLayerInfo(PsdBinaryReader reader, string key, int dataLength) { this.key = key; Data = reader.ReadBytes((int)dataLength); }
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 ushort wrapVersion = reader.ReadUInt16(); //2 bytes, =1. For Photoshop 6.0. // DescriptorVersion uint wrapDescriptorVersion = reader.ReadUInt32(); DynVal warpDescriptor = DynVal.ReadDescriptor(reader); // double left = reader.ReadDouble(); // double top = reader.ReadDouble(); // double right = reader.ReadDouble(); // double bottom = reader.ReadDouble(); byte[] datas = reader.ReadBytes(32); 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"); if (d.ContainsKey("FauxBold")) { FauxBold = TdTaParser.getBool(d, "FauxBold"); } if (d.ContainsKey("FauxItalic")) { FauxItalic = TdTaParser.getBool(d, "FauxItalic"); } if (d.ContainsKey("Underline")) { Underline = TdTaParser.getBool(d, "Underline"); } if (d.ContainsKey("StyleRunAlignment")) { int styleRunAlignment = (int)TdTaParser.query(d, "StyleRunAlignment");//No idea what this maps to. } FillColor = Color.black; if (d.ContainsKey("FillColor")) { FillColor = TdTaParser.getColor(d, "FillColor"); } if (d.ContainsKey("OutlineWidth")) { OutlineWidth = (double)TdTaParser.query(d, "OutlineWidth"); } if (d.ContainsKey("StrokeFlag")) { StrokeFlag = TdTaParser.getBool(d, "StrokeFlag"); } if (d.ContainsKey("StrokeColor")) { StrokeColor = TdTaParser.getColor(d, "StrokeColor"); } if (d.ContainsKey("Strikethrough")) { Strikethrough = TdTaParser.getBool(d, "Strikethrough"); } if (d.ContainsKey("FontBaseline")) { FontBaseline = TdTaParser.getIntger(d, "FontBaseline"); } //Fix newlines try { //Remove MT if (FontName.EndsWith("MT")) { FontName = FontName.Substring(0, FontName.Length - 2); } //Remove -Bold, -Italic, -BoldItalic if (FontName.EndsWith("-Bold", StringComparison.OrdinalIgnoreCase)) { Style |= FontStyle.Bold; } if (FontName.EndsWith("-Italic", StringComparison.OrdinalIgnoreCase)) { Style |= FontStyle.Italic; } if (FontName.EndsWith("-BoldItalic", StringComparison.OrdinalIgnoreCase)) { Style |= FontStyle.Bold | FontStyle.Italic; } //Remove from FontName FontName = new Regex("\\-(Bold|Italic|BoldItalic)$", RegexOptions.IgnoreCase | RegexOptions.IgnoreCase).Replace(FontName, ""); //Remove PS if (FontName.EndsWith("PS")) { FontName = FontName.Substring(0, FontName.Length - 2); } //Find font family if (FauxBold) { Style |= FontStyle.Bold; } if (FauxItalic) { Style |= FontStyle.Italic; } // if (underline) style |= FontStyle.Underline; // if (strikethrough) style |= FontStyle.Strikeout; } finally { } }
public RowData(PsdBinaryReader reader) { int length = reader.ReadInt32(); Data = reader.ReadBytes(length); }
private void LoadGlobalLayerMask(PsdBinaryReader reader) { var maskLength = reader.ReadUInt32(); if (maskLength <= 0) return; GlobalLayerMaskData = reader.ReadBytes((int)maskLength); }
public static DynVal ReadValue(PsdBinaryReader r, bool skipKey) { DynVal vt = new DynVal(); if (!skipKey) { vt.Name = GetMeaningOfFourCC(ReadSpecialString(r)); } //TODO: should be assigned a sequential number? vt.Type = parseTypeString(System.Text.Encoding.ASCII.GetString(r.ReadBytes(4))); switch (vt.Type) { case OSType.tdta: // unknown r.ReadUInt32(); TdTaParser p = new TdTaParser(r); object o = p.ParseOneTree(); vt.Value = o; break; case OSType.Descriptor: vt = DynVal.ReadDescriptor(r); break; case OSType.List: vt.Children = ReadValues(r, true); break; case OSType.Double: vt.Value = r.ReadDouble(); break; case OSType.UnitFloat: //Unif float //TODO: need a specific type for this, with a double and a type (percent/pixel)? string tst = GetMeaningOfFourCC(System.Text.Encoding.ASCII.GetString(r.ReadBytes(4))); //#Prc #Pxl #Ang = percent / pixels / angle? double d = r.ReadDouble(); tst += ": " + d; vt.Value = tst; break; case OSType.Enumerated: string namesp = ReadSpecialString(r); string item = ReadSpecialString(r); //vt.Value = namesp + "." + item; //TODO: cast to real enum vt.Value = GetMeaningOfFourCC(namesp) + "." + GetMeaningOfFourCC(item); break; case OSType.Integer: vt.Value = r.ReadInt32(); //4 byte integer break; case OSType.Boolean: vt.Value = r.ReadBoolean(); break; case OSType.String: vt.Value = r.ReadUnicodeString(); //r.ReadPSDUnicodeString(); break; default: throw new Exception("Unhandled type: " + vt.Type); } return(vt); }