private void LoadHeader(BinaryReverseReader reader) { string strHead = reader.ReadStringNew(4); if (strHead != "8BPS") { UnityEngine.Debug.LogError("The given stream is not a valid PSD file"); throw new IOException("The given stream is not a valid PSD file"); } _version = reader.ReadInt16(); if (_version != 1) { UnityEngine.Debug.LogError("The PSD file has an invalid version"); throw new IOException("The PSD file has an invalid version"); } reader.BaseStream.Position += 6L; _channels = reader.ReadInt16(); _height = reader.ReadInt32(); _width = reader.ReadInt32(); _depth = reader.ReadInt16(); ColorMode = (ColorModes)reader.ReadInt16(); }
/////////////////////////////////////////////////////////////////////////// private void LoadHeader(BinaryReverseReader reader) { Debug.WriteLine("LoadHeader started at " + reader.BaseStream.Position.ToString()); string signature = new string(reader.ReadChars(4)); if (signature != "8BPS") { throw new IOException("The given stream is not a valid PSD file"); } m_version = reader.ReadInt16(); if (m_version != 1) { throw new IOException("The PSD file has an unknown version"); } //6 bytes reserved reader.BaseStream.Position += 6; m_channels = reader.ReadInt16(); m_rows = reader.ReadInt32(); m_columns = reader.ReadInt32(); m_depth = reader.ReadInt16(); m_colorMode = (ColorModes)reader.ReadInt16(); }
////////////////////////////////////////////////////////////////// internal void LoadPixelData(BinaryReverseReader reader) { Debug.WriteLine("Channel.LoadPixelData started at " + reader.BaseStream.Position); m_data = reader.ReadBytes(Length); using (BinaryReverseReader readerImg = DataReader) { m_imageCompression = (ImageCompression)readerImg.ReadInt16(); int bytesPerRow = 0; switch (m_layer.PsdFile.Depth) { case 1: bytesPerRow = m_layer.m_rect.Width; //NOT Shure break; case 8: bytesPerRow = m_layer.m_rect.Width; break; case 16: bytesPerRow = m_layer.m_rect.Width * 2; break; } m_imageData = new byte[m_layer.m_rect.Height * bytesPerRow]; switch (m_imageCompression) { case ImageCompression.Raw: readerImg.Read(m_imageData, 0, m_imageData.Length); break; case ImageCompression.Rle: { var rowLenghtList = new int[m_layer.m_rect.Height]; for (int i = 0; i < rowLenghtList.Length; i++) { rowLenghtList[i] = readerImg.ReadInt16(); } for (int i = 0; i < m_layer.m_rect.Height; i++) { var rowIndex = i * m_layer.m_rect.Width; RleHelper.DecodedRow(readerImg.BaseStream, m_imageData, rowIndex, bytesPerRow); //if (rowLenghtList[i] % 2 == 1) // readerImg.ReadByte(); } } break; } } }
internal void LoadPixelData(BinaryReverseReader reader) { Data = reader.ReadBytes(Length); using (BinaryReverseReader dataReader = DataReader) { //从文档 五 - 5 读取信息 ImageCompression = (ImageCompression)dataReader.ReadInt16(); int columns = 0; switch (Layer.PsdFile.Depth) { case 1: columns = (int)Layer.Rect.width; break; case 8: columns = (int)Layer.Rect.width; break; case 16: columns = (int)Layer.Rect.width * 2; break; } ImageData = new byte[(int)Layer.Rect.height * columns]; switch (ImageCompression) { case ImageCompression.Raw: dataReader.Read(ImageData, 0, ImageData.Length); break; case ImageCompression.Rle: int[] nums = new int[(int)Layer.Rect.height]; for (int i = 0; i < Layer.Rect.height; i++) { nums[i] = dataReader.ReadInt16(); } for (int index = 0; index < Layer.Rect.height; ++index) { int startIdx = index * (int)Layer.Rect.width; RleHelper.DecodedRow(dataReader.BaseStream, ImageData, startIdx, columns); } break; } } }
public ResolutionInfo(ImageResource imgRes) : base(imgRes) { BinaryReverseReader reader = imgRes.DataReader; this.m_hRes = reader.ReadInt16(); this.m_hResUnit = (ResUnit)reader.ReadInt32(); this.m_widthUnit = (Unit)reader.ReadInt16(); this.m_vRes = reader.ReadInt16(); this.m_vResUnit = (ResUnit)reader.ReadInt32(); this.m_heightUnit = (Unit)reader.ReadInt16(); reader.Close(); }
internal Channel(BinaryReverseReader reader, Layer layer) { //从文档 五 - 4- 6) 开始读 ID = reader.ReadInt16(); Length = reader.ReadInt32(); Layer = layer; }
/////////////////////////////////////////////////////////////////////////// private void LoadImage(BinaryReverseReader reader) { Debug.WriteLine("LoadImage started at " + reader.BaseStream.Position); m_imageCompression = (ImageCompression)reader.ReadInt16(); m_imageData = new byte[m_channels][]; //--------------------------------------------------------------- if (m_imageCompression == ImageCompression.Rle) { // The RLE-compressed data is proceeded by a 2-byte data count for each row in the data, // which we're going to just skip. reader.BaseStream.Position += m_rows * m_channels * 2; } //--------------------------------------------------------------- int bytesPerRow = 0; switch (m_depth) { case 1: bytesPerRow = m_columns; //NOT Shure break; case 8: bytesPerRow = m_columns; break; case 16: bytesPerRow = m_columns * 2; break; } //--------------------------------------------------------------- for (int ch = 0; ch < m_channels; ch++) { m_imageData[ch] = new byte[m_rows * bytesPerRow]; switch (m_imageCompression) { case ImageCompression.Raw: reader.Read(m_imageData[ch], 0, m_imageData[ch].Length); break; case ImageCompression.Rle: { for (int i = 0; i < m_rows; i++) { int rowIndex = i * m_columns; RleHelper.DecodedRow(reader.BaseStream, m_imageData[ch], rowIndex, bytesPerRow); } } break; } } }
/// <summary> /// Initializes a new instance of the <see cref="ImageResource"/> class using a reader. /// </summary> /// <param name="reader">The reader to use to create the instance.</param> public ImageResource(BinaryReverseReader reader) { // read the OS type string osType = new string(reader.ReadChars(4)); if (osType != "8BIM" && osType != "MeSa") { throw new InvalidOperationException("Could not read an image resource"); } // read the ID ID = reader.ReadInt16(); // read the name Name = string.Empty; Name = reader.ReadPascalString(); // read the length of the data in bytes uint length = reader.ReadUInt32(); // read the actual data Data = reader.ReadBytes((int)length); if (reader.BaseStream.Position % 2L != 1L) { return; } reader.ReadByte(); }
internal Channel(BinaryReverseReader reader, Layer layer) { Debug.WriteLine("Channel started at " + reader.BaseStream.Position.ToString()); m_id = reader.ReadInt16(); Length = reader.ReadInt32(); m_layer = layer; }
/// <summary> /// Reads all of the layers from the reader. /// </summary> /// <param name="reader">The reader to use to read the layers.</param> private void LoadLayers(BinaryReverseReader reader) { int num1 = reader.ReadInt32(); //.ReadUInt32(); ;// reader.ReadUInt32(); // Debug.Log(Time.time + "LoadLayers num1=" + num1 + ",return ?" + (num1 <= 0U)); if (num1 <= 0U) { return; } long position = reader.BaseStream.Position; short num2 = reader.ReadInt16(); if (num2 < 0) { AbsoluteAlpha = true; num2 = Math.Abs(num2); } Layers.Clear(); //Debug.Log(Time.time + "LoadLayers num2=" + num2 + ",return ?" + (num2 == 0)); if (num2 == 0) { return; } for (int index = 0; index < (int)num2; ++index) { Layers.Add(new Layer(reader, this)); } foreach (Layer layer in Layers) { foreach (Channel channel in layer.Channels) { if (channel.ID != -2) { channel.LoadPixelData(reader); } } layer.MaskData.LoadPixelData(reader); } if (reader.BaseStream.Position % 2L == 1L) { reader.ReadByte(); } reader.BaseStream.Position = position + num1; }
public Thumbnail(ImageResource imgRes) : base(imgRes) { using (BinaryReverseReader reader = DataReader) { int format = reader.ReadInt32(); int width = reader.ReadInt32(); int height = reader.ReadInt32(); int widthBytes = reader.ReadInt32(); int size = reader.ReadInt32(); int compressedSize = reader.ReadInt32(); short bitPerPixel = reader.ReadInt16(); short planes = reader.ReadInt16(); if (format == 1) { byte[] imgData = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position)); using (MemoryStream strm = new MemoryStream(imgData)) { m_thumbnailImage = (Bitmap)(Bitmap.FromStream(strm).Clone()); } if (this.ID == 1033) { //// BGR //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 { m_thumbnailImage = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format24bppRgb); } } }
/// <summary> /// Loads the header data from a PSD file /// </summary> /// <param name="reader">The reader containing the PSD file data</param> private void LoadHeader(BinaryReverseReader reader) { if (new string(reader.ReadChars(4)) != "8BPS") { UnityEngine.Debug.LogError("The given stream is not a valid PSD file"); throw new IOException("The given stream is not a valid PSD file"); } Version = reader.ReadInt16(); if (Version != 1) { UnityEngine.Debug.LogError("The PSD file has an invalid version"); throw new IOException("The PSD file has an invalid version"); } reader.BaseStream.Position += 6L; channels = reader.ReadInt16(); height = reader.ReadInt32(); width = reader.ReadInt32(); depth = reader.ReadInt16(); ColorMode = (ColorModes)reader.ReadInt16(); }
private void LoadImage(BinaryReverseReader reader) { _imageCompression = (ImageCompression)reader.ReadInt16(); _imageData = new byte[_channels][]; if (_imageCompression == ImageCompression.Rle) { reader.BaseStream.Position += _height * _channels * 2; } int columns = 0; switch (_depth) { case 1: columns = _width; break; case 8: columns = _width; break; case 16: columns = _width * 2; break; } for (int index1 = 0; index1 < (int)_channels; ++index1) { _imageData[index1] = new byte[_height * columns]; switch (_imageCompression) { case ImageCompression.Raw: reader.Read(_imageData[index1], 0, _imageData[index1].Length); break; case ImageCompression.Rle: for (int index2 = 0; index2 < _height; ++index2) { int startIdx = index2 * _width; RleHelper.DecodedRow(reader.BaseStream, _imageData[index1], startIdx, columns); } break; } } }
////////////////////////////////////////////////////////////////// public ImageResource(BinaryReverseReader reader) { m_osType = new string(reader.ReadChars(4)); if (m_osType != "8BIM" && m_osType != "MeSa") { throw new InvalidOperationException("Could not read an image resource"); } m_id = reader.ReadInt16(); m_name = reader.ReadPascalString(); uint settingLength = reader.ReadUInt32(); m_data = reader.ReadBytes((int)settingLength); if (reader.BaseStream.Position % 2 == 1) { reader.ReadByte(); } }
/////////////////////////////////////////////////////////////////////////// private void LoadHeader(BinaryReverseReader reader) { Debug.WriteLine("LoadHeader started at " + reader.BaseStream.Position); var signature = new string(reader.ReadChars(4)); if (signature != "8BPS") throw new IOException("The given stream is not a valid PSD file"); m_version = reader.ReadInt16(); if (m_version != 1) throw new IOException("The PSD file has an unkown version"); //6 bytes reserved reader.BaseStream.Position += 6; m_channels = reader.ReadInt16(); m_rows = reader.ReadInt32(); m_columns = reader.ReadInt32(); m_depth = reader.ReadInt16(); m_colorMode = (ColorModes) reader.ReadInt16(); }
private void ParseLrfxKeyword(AdjustmentLayerInfo adjustmentLayerInfo) { BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader; int version = dataReader.ReadInt16(); int effectCount = dataReader.ReadInt16(); for (int index = 0; index < effectCount; index++) { string sigNature = dataReader.ReadStringNew(4); string type = dataReader.ReadStringNew(4); switch (type) { case "cmnS": //OK int cmnsSize = dataReader.ReadInt32(); int cmnsVersion = dataReader.ReadInt32(); bool cmnsBool = dataReader.ReadBoolean(); int cmnsUnused = dataReader.ReadInt16(); break; case "dsdw": // 投影效果 byte[] testbyte2 = dataReader.ReadBytes(55); break; case "isdw": //内阴影效果 int dropSize = dataReader.ReadInt32(); int dropVersion = dataReader.ReadInt32(); int dropBlurValue = dataReader.ReadInt32(); int Intensityasapercent = dataReader.ReadInt32(); int angleindegrees = dataReader.ReadInt32(); int distanceinp = dataReader.ReadInt32(); byte[] colortest = dataReader.ReadBytes(10); dataReader.ReadBytes(4); string dropBlendmode = dataReader.ReadStringNew(4); bool dropeffectEnable = dataReader.ReadBoolean(); byte usethisangle = dataReader.ReadByte(); int dropOpacity = dataReader.ReadByte(); int dropSpace11 = dataReader.ReadInt16(); int color111 = dataReader.ReadInt16(); int color211 = dataReader.ReadInt16(); int color311 = dataReader.ReadInt16(); int color411 = dataReader.ReadInt16(); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(10); string sign1 = dataReader.ReadStringNew(4); string key1 = dataReader.ReadStringNew(4); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); if (dropVersion == 2) { dataReader.ReadBytes(10); } break; case "oglw": //有用:字体的描边! int sizeofRemainItems = dataReader.ReadInt32(); int oglwversion = dataReader.ReadInt32(); byte[] blurdata = dataReader.ReadBytes(4); _outLineDis = Convert.ToInt32(blurdata[1]); //也是小坑,四个故意放在第二个字节 也不说明( ▼-▼ ) //int blurvalue = dataReader.ReadInt32(); int intensityPercent = dataReader.ReadInt32(); byte outline_r = 0; byte outline_g = 0; byte outline_b = 0; byte outline_a = 0; dataReader.ReadBytes(2); outline_r = dataReader.ReadByte(); dataReader.ReadByte(); outline_g = dataReader.ReadByte(); dataReader.ReadByte(); outline_b = dataReader.ReadByte(); dataReader.ReadByte(); outline_a = dataReader.ReadByte(); dataReader.ReadByte(); string curSign = dataReader.ReadStringNew(4); string key = dataReader.ReadStringNew(4); bool effectEnable = dataReader.ReadBoolean(); //yanruTODO 不可靠,如果整个effect 层 禁用了,子字段可能依然为true,暂时找不到上层effect开关 byte opacityPercent = dataReader.ReadByte(); //描边透明度 if (oglwversion == 2) { byte[] oglwColor2 = dataReader.ReadBytes(10); } if (!effectEnable) //指明了没有描边 { TextOutlineColor = new Color(0, 0, 0, 0); } else { TextOutlineColor = new Color(outline_r / 255f, outline_g / 255f, outline_b / 255f, opacityPercent / 255f); } break; case "iglw": byte[] testdata5 = dataReader.ReadBytes(47); //effectStr += "\n" + printbytes(testdata5, "iglw"); //dataReader.ReadBytes(4); //dataReader.ReadBytes(4); //dataReader.ReadBytes(4); //dataReader.ReadBytes(4); //dataReader.ReadBytes(10); //dataReader.ReadBytes(8); //dataReader.ReadBytes(1); //dataReader.ReadBytes(1); //dataReader.ReadBytes(1); //dataReader.ReadBytes(10); break; case "bevl": int bevelSizeofRemain = dataReader.ReadInt32(); //.ReadBytes(4); int bevelversion = dataReader.ReadInt32(); //dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(8); dataReader.ReadBytes(8); dataReader.ReadBytes(10); dataReader.ReadBytes(10); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); if (bevelversion == 2) { dataReader.ReadBytes(10); dataReader.ReadBytes(10); } break; case "sofi": int solidSize = dataReader.ReadInt32(); //.ReadBytes(4); int solidVersion = dataReader.ReadInt32(); // (4); string sign = dataReader.ReadStringNew(4); string solidBlendmode = dataReader.ReadStringNew(4); //.ReadBytes(4); byte[] solidColor = dataReader.ReadBytes(10); byte opacity = dataReader.ReadByte(); byte solidenable = dataReader.ReadByte(); dataReader.ReadBytes(10); break; } } }
internal void LoadPixelData(BinaryReverseReader reader) { Debug.WriteLine("Mask.LoadPixelData started at " + reader.BaseStream.Position.ToString()); if (m_rect.IsEmpty || m_layer.SortedChannels.ContainsKey(-2) == false) { return; } Channel maskChannel = m_layer.SortedChannels[-2]; maskChannel.Data = reader.ReadBytes((int)maskChannel.Length); using (BinaryReverseReader readerImg = maskChannel.DataReader) { maskChannel.ImageCompression = (ImageCompression)readerImg.ReadInt16(); int bytesPerRow = 0; switch (m_layer.PsdFile.Depth) { case 1: bytesPerRow = ImageDecoder.BytesFromBits(m_layer.m_rect.Width); break; case 8: bytesPerRow = m_rect.Width; break; case 16: bytesPerRow = m_rect.Width * 2; break; } maskChannel.ImageData = new byte[m_rect.Height * bytesPerRow]; // Fill Array for (int i = 0; i < maskChannel.ImageData.Length; i++) { maskChannel.ImageData[i] = 0xAB; } m_imageData = (byte[])maskChannel.ImageData.Clone(); switch (maskChannel.ImageCompression) { case ImageCompression.Raw: readerImg.Read(maskChannel.ImageData, 0, maskChannel.ImageData.Length); break; case ImageCompression.Rle: { uint[] rowLengthList = new uint[m_rect.Height]; for (int i = 0; i < rowLengthList.Length; i++) { rowLengthList[i] = readerImg.ReadUInt16(); } for (int i = 0; i < m_rect.Height; i++) { int rowIndex = i * m_rect.Width; RleHelper.DecodedRow(readerImg.BaseStream, maskChannel.ImageData, rowIndex, bytesPerRow); } } break; default: break; } m_imageData = (byte[])maskChannel.ImageData.Clone(); } }
////////////////////////////////////////////////////////////////// internal void LoadPixelData(BinaryReverseReader reader) { Debug.WriteLine("Channel.LoadPixelData started at " + reader.BaseStream.Position.ToString()); m_data = reader.ReadBytes((int)Length); using (BinaryReverseReader readerImg = DataReader) { m_imageCompression = (ImageCompression)readerImg.ReadInt16(); m_bytesPerRow = 0; switch (m_layer.PsdFile.Depth) { case 1: m_bytesPerRow = ImageDecoder.BytesFromBits(m_layer.m_rect.Width); break; case 8: m_bytesPerRow = m_layer.m_rect.Width; break; case 16: m_bytesPerRow = m_layer.m_rect.Width * 2; break; } m_imageData = new byte[m_layer.m_rect.Height * m_bytesPerRow]; switch (m_imageCompression) { case ImageCompression.Raw: readerImg.Read(m_imageData, 0, m_imageData.Length); break; case ImageCompression.Rle: { m_rowLengthList = new uint[m_layer.m_rect.Height]; uint totalRleLength = 0; for (int i = 0; i < m_rowLengthList.Length; i++) { m_rowLengthList[i] = readerImg.ReadUInt16(); totalRleLength += m_rowLengthList[i]; } m_data = new byte[totalRleLength]; uint idxData = 0; for (int i = 0; i < m_layer.m_rect.Height; i++) { readerImg.Read(m_data, (int)idxData, (int)m_rowLengthList[i]); idxData += m_rowLengthList[i]; // The PSD specification states that rows are padded to even sizes. // However, PSD files generated by Photoshop CS4 do not actually // follow this stipulation. } } break; default: break; } } }
/////////////////////////////////////////////////////////////////////////// private void LoadLayers(BinaryReverseReader reader) { Debug.WriteLine("LoadLayers started at " + reader.BaseStream.Position.ToString()); uint layersInfoSectionLength = reader.ReadUInt32(); if (layersInfoSectionLength <= 0) { return; } long startPosition = reader.BaseStream.Position; short numberOfLayers = reader.ReadInt16(); // If <0, then number of layers is absolute value, // and the first alpha channel contains the transparency data for // the merged result. if (numberOfLayers < 0) { AbsoluteAlpha = true; numberOfLayers = Math.Abs(numberOfLayers); } m_layers.Clear(); if (numberOfLayers == 0) { return; } for (int i = 0; i < numberOfLayers; i++) { m_layers.Add(new Layer(reader, this)); } PrivateThreadPool threadPool = new PrivateThreadPool(); foreach (Layer layer in m_layers) { foreach (Layer.Channel channel in layer.Channels) { if (channel.ID != -2) { channel.LoadPixelData(reader); DecompressChannelContext dcc = new DecompressChannelContext(channel); WaitCallback waitCallback = new WaitCallback(dcc.DecompressChannel); threadPool.QueueUserWorkItem(waitCallback); } } layer.MaskData.LoadPixelData(reader); } threadPool.Drain(); //----------------------------------------------------------------------- if (reader.BaseStream.Position % 2 == 1) { reader.ReadByte(); } //----------------------------------------------------------------------- // make sure we are not on a wrong offset, so set the stream position // manually reader.BaseStream.Position = startPosition + layersInfoSectionLength; }
/// <summary> /// Reads an image from the reader. /// </summary> /// <param name="reader">The reader to use to read the image.</param> private void LoadImage(BinaryReverseReader reader) { ImageCompression = (ImageCompression)reader.ReadInt16(); ImageData = new byte[channels][]; if (ImageCompression == ImageCompression.Rle) { reader.BaseStream.Position += height * channels * 2; } int columns = 0; switch (depth) { case 1: columns = width; break; case 8: columns = width; break; case 16: columns = width * 2; break; } for (int index1 = 0; index1 < (int)channels; ++index1) { ImageData[index1] = new byte[height * columns]; switch (ImageCompression) { case ImageCompression.Raw: reader.Read(ImageData[index1], 0, ImageData[index1].Length); break; case ImageCompression.Rle: for (int index2 = 0; index2 < height; ++index2) { int startIdx = index2 * width; RleHelper.DecodedRow(reader.BaseStream, ImageData[index1], startIdx, columns); } break; } } }
////////////////////////////////////////////////////////////////// public ImageResource(BinaryReverseReader reader) { m_osType = new string(reader.ReadChars(4)); if (m_osType != "8BIM" && m_osType != "MeSa") { throw new InvalidOperationException("Could not read an image resource"); } m_id = reader.ReadInt16(); m_name = reader.ReadPascalString(); uint settingLength = reader.ReadUInt32(); m_data = reader.ReadBytes((int) settingLength); if (reader.BaseStream.Position%2 == 1) reader.ReadByte(); }
/// <summary> /// Reads the pixel data from a reader. /// </summary> /// <param name="reader">The reader to use to read the pixel data.</param> internal void LoadPixelData(BinaryReverseReader reader) { if (rect.width <= 0 || !Layer.SortedChannels.ContainsKey(-2)) { return; } Channel channel = Layer.SortedChannels[-2]; channel.Data = reader.ReadBytes(channel.Length); using (BinaryReverseReader dataReader = channel.DataReader) { channel.ImageCompression = (ImageCompression)dataReader.ReadInt16(); int columns = 0; switch (Layer.PsdFile.Depth) { case 1: columns = (int)rect.width; break; case 8: columns = (int)rect.width; break; case 16: columns = (int)rect.width * 2; break; } channel.ImageData = new byte[(int)rect.height * columns]; for (int index = 0; index < channel.ImageData.Length; ++index) { channel.ImageData[index] = 171; } ImageData = (byte[])channel.ImageData.Clone(); switch (channel.ImageCompression) { case ImageCompression.Raw: dataReader.Read(channel.ImageData, 0, channel.ImageData.Length); break; case ImageCompression.Rle: int[] nums = new int[(int)rect.height]; for (int i = 0; i < (int)rect.height; i++) { nums[i] = dataReader.ReadInt16(); } for (int index = 0; index < (int)rect.height; ++index) { int startIdx = index * (int)rect.width; RleHelper.DecodedRow(dataReader.BaseStream, channel.ImageData, startIdx, columns); } break; } ImageData = (byte[])channel.ImageData.Clone(); } }
private short readShort(BinaryReverseReader stream) { cachedByte = -1; useCachedByte = false; return(stream.ReadInt16()); }
/// <summary> /// Reads all of the layers from the reader. /// </summary> /// <param name="reader">The reader to use to read the layers.</param> private void LoadLayers(BinaryReverseReader reader) { uint num1 = reader.ReadUInt32(); if (num1 <= 0U) { return; } long position = reader.BaseStream.Position; short num2 = reader.ReadInt16(); if (num2 < 0) { AbsoluteAlpha = true; num2 = Math.Abs(num2); } Layers.Clear(); if (num2 == 0) { return; } for (int index = 0; index < (int)num2; ++index) { Layers.Add(new Layer(reader, this)); } foreach (Layer layer in Layers) { foreach (Channel channel in layer.Channels) { if (channel.ID != -2) { channel.LoadPixelData(reader); } } layer.MaskData.LoadPixelData(reader); } if (reader.BaseStream.Position % 2L == 1L) { reader.ReadByte(); } reader.BaseStream.Position = position + num1; }
/////////////////////////////////////////////////////////////////////////// private void LoadLayers(BinaryReverseReader reader) { Debug.WriteLine("LoadLayers started at " + reader.BaseStream.Position); uint layersInfoSectionLength = reader.ReadUInt32(); if (layersInfoSectionLength <= 0) return; long startPosition = reader.BaseStream.Position; short numberOfLayers = reader.ReadInt16(); // If <0, then number of layers is absolute value, // and the first alpha channel contains the transparency data for // the merged result. if (numberOfLayers < 0) { AbsoluteAlpha = true; numberOfLayers = Math.Abs(numberOfLayers); } m_layers.Clear(); if (numberOfLayers == 0) return; for (int i = 0; i < numberOfLayers; i++) { m_layers.Add(new Layer(reader, this)); } foreach (Layer layer in m_layers) { foreach (Layer.Channel channel in layer.Channels) { if (channel.ID != -2) channel.LoadPixelData(reader); } layer.MaskData.LoadPixelData(reader); } //----------------------------------------------------------------------- if (reader.BaseStream.Position%2 == 1) reader.ReadByte(); //----------------------------------------------------------------------- // make shure we are not on a wrong offset, so set the stream position // manually reader.BaseStream.Position = startPosition + layersInfoSectionLength; }
/// <summary> /// Initializes a new instance of the <see cref="Channel"/> class. /// </summary> /// <param name="reader">The reader to use to initialize the instance.</param> /// <param name="layer">The layer this channel belongs to.</param> internal Channel(BinaryReverseReader reader, Layer layer) { ID = reader.ReadInt16(); Length = reader.ReadInt32(); Layer = layer; }
/////////////////////////////////////////////////////////////////////////// private void LoadImage(BinaryReverseReader reader) { Debug.WriteLine("LoadImage started at " + reader.BaseStream.Position); m_imageCompression = (ImageCompression) reader.ReadInt16(); m_imageData = new byte[m_channels][]; //--------------------------------------------------------------- if (m_imageCompression == ImageCompression.Rle) { // The RLE-compressed data is proceeded by a 2-byte data count for each row in the data, // which we're going to just skip. reader.BaseStream.Position += m_rows*m_channels*2; } //--------------------------------------------------------------- int bytesPerRow = 0; switch (m_depth) { case 1: bytesPerRow = m_columns; //NOT Shure break; case 8: bytesPerRow = m_columns; break; case 16: bytesPerRow = m_columns*2; break; } //--------------------------------------------------------------- for (int ch = 0; ch < m_channels; ch++) { m_imageData[ch] = new byte[m_rows*bytesPerRow]; switch (m_imageCompression) { case ImageCompression.Raw: reader.Read(m_imageData[ch], 0, m_imageData[ch].Length); break; case ImageCompression.Rle: { for (int i = 0; i < m_rows; i++) { int rowIndex = i*m_columns; RleHelper.DecodedRow(reader.BaseStream, m_imageData[ch], rowIndex, bytesPerRow); } } break; } } }
//图层效果相关 private void parseLrfxKeyword(AdjustmentLayerInfo adjustmentLayerInfo) { BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader; int version = dataReader.ReadInt16(); int effectCount = dataReader.ReadInt16(); //Debug.Log("lrfx version=" + version + ",effectCount=" + effectCount); string effectStr = ""; for (int index = 0; index < effectCount; index++) { string sigNature = dataReader.readStringNew(4); string type = dataReader.readStringNew(4); //Debug.Log("cur read type=" + type + ",sigNature=" + sigNature); switch (type) { case "cmnS": //OK int cmnsSize = dataReader.ReadInt32(); int cmnsVersion = dataReader.ReadInt32(); bool cmnsBool = dataReader.ReadBoolean(); int cmnsUnused = dataReader.ReadInt16(); Debug.Log("cmnsSize =" + cmnsSize + ",cmnsBool=" + cmnsBool); break; case "dsdw": //可能有用 //byte[] testbyte2 = dataReader.ReadBytes(55); //effectStr += "\n" + printbytes(testbyte2, "dsdw"); //break; case "isdw": int dropSize = dataReader.ReadInt32(); int dropVersion = dataReader.ReadInt32(); int dropBlurValue = dataReader.ReadInt32(); int Intensityasapercent = dataReader.ReadInt32(); int angleindegrees = dataReader.ReadInt32(); int distanceinp = dataReader.ReadInt32(); byte[] colortest = dataReader.ReadBytes(10); dataReader.ReadBytes(4); string dropBlendmode = dataReader.readStringNew(4); bool dropeffectEnable = dataReader.ReadBoolean(); byte usethisangle = dataReader.ReadByte(); int dropOpacity = dataReader.ReadByte(); int dropSpace11 = dataReader.ReadInt16(); int color111 = dataReader.ReadInt16(); int color211 = dataReader.ReadInt16(); int color311 = dataReader.ReadInt16(); int color411 = dataReader.ReadInt16(); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); effectStr += "\n" + dataReader.ReadBytes(10); string sign1 = dataReader.readStringNew(4); string key1 = dataReader.readStringNew(4); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); if (dropVersion == 2) { dataReader.ReadBytes(10); } break; case "oglw": //有用:字体的描边! int sizeofRemainItems = dataReader.ReadInt32(); int oglwversion = dataReader.ReadInt32(); byte[] blurdata = dataReader.ReadBytes(4); outLineDis = Convert.ToInt32(blurdata[1]); //也是小坑,四个故意放在第二个字节 也不说明( ▼-▼ ) effectStr += printbytes(blurdata, "blurdata "); //int blurvalue = dataReader.ReadInt32(); int intensityPercent = dataReader.ReadInt32(); byte outline_r = 0; byte outline_g = 0; byte outline_b = 0; byte outline_a = 0; dataReader.ReadBytes(2); outline_r = dataReader.ReadByte(); dataReader.ReadByte(); outline_g = dataReader.ReadByte(); dataReader.ReadByte(); outline_b = dataReader.ReadByte(); dataReader.ReadByte(); outline_a = dataReader.ReadByte(); dataReader.ReadByte(); string curSign = dataReader.readStringNew(4); string key = dataReader.readStringNew(4); bool effectEnable = dataReader.ReadBoolean(); //yanruTODO 不可靠,如果整个effect 层 禁用了,子字段可能依然为true,暂时找不到上层effect开关 byte opacityPercent = dataReader.ReadByte(); //描边透明度 if (oglwversion == 2) { byte[] oglwColor2 = dataReader.ReadBytes(10); } if (!effectEnable) //指明了没有描边 { TextOutlineColor = new Color(0, 0, 0, 0); } else { TextOutlineColor = new Color(outline_r / 255f, outline_g / 255f, outline_b / 255f, opacityPercent / 255f); } Debug.Log("sizeofRemainItems=" + sizeofRemainItems + ",oglwversion=" + oglwversion + ",intensityPercent=" + intensityPercent + ",curSign=" + curSign + ",key=" + key + ",color_r=" + outline_r + ",color_g=" + outline_g + ",color_b=" + outline_b + ",color_a=" + outline_a + ",effectEnable=" + effectEnable + ",opacityPercent=" + opacityPercent + ",outLineDis=" + outLineDis ); break; case "iglw": byte[] testdata5 = dataReader.ReadBytes(47); //effectStr += "\n" + printbytes(testdata5, "iglw"); //dataReader.ReadBytes(4); //dataReader.ReadBytes(4); //dataReader.ReadBytes(4); //dataReader.ReadBytes(4); //dataReader.ReadBytes(10); //dataReader.ReadBytes(8); //dataReader.ReadBytes(1); //dataReader.ReadBytes(1); //dataReader.ReadBytes(1); //dataReader.ReadBytes(10); break; case "bevl": int bevelSizeofRemain = dataReader.ReadInt32(); //.ReadBytes(4); int bevelversion = dataReader.ReadInt32(); //dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(4); dataReader.ReadBytes(8); dataReader.ReadBytes(8); dataReader.ReadBytes(10); dataReader.ReadBytes(10); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); dataReader.ReadBytes(1); if (bevelversion == 2) { dataReader.ReadBytes(10); dataReader.ReadBytes(10); } break; //case "sofi": // int solidSize = dataReader.ReadInt32();//.ReadBytes(4); // int solidVersion = dataReader.ReadInt32();// (4); // string solidBlendmode = dataReader.readStringNew(4);//.ReadBytes(4); // byte[] solidColor = dataReader.ReadBytes(10); // effectStr += printbytes(solidColor, "sofi solidColor"); // byte opacity = dataReader.ReadByte(); // byte solidenable = dataReader.ReadByte(); // //dataReader.ReadBytes(1); // //dataReader.ReadBytes(1); // dataReader.ReadBytes(10); // Debug.Log("sofi solidSize=" + solidSize // + ",solidVersion=" + solidVersion // + ",solidBlendmode=" + solidBlendmode // + ",opacity=" + opacity // + ",solidenable=" + solidenable // ); // break; } } Debug.Log("effectStr=" + effectStr); }
internal Channel(BinaryReverseReader reader, Layer layer) { Debug.WriteLine("Channel started at " + reader.BaseStream.Position); m_id = reader.ReadInt16(); Length = reader.ReadInt32(); m_layer = layer; }
/////////////////////////////////////////////////////////////////////////// private void LoadLayers(BinaryReverseReader reader) { Debug.WriteLine("LoadLayers started at " + reader.BaseStream.Position.ToString()); uint layersInfoSectionLength = reader.ReadUInt32(); if (layersInfoSectionLength <= 0) return; long startPosition = reader.BaseStream.Position; short numberOfLayers = reader.ReadInt16(); // If <0, then number of layers is absolute value, // and the first alpha channel contains the transparency data for // the merged result. if (numberOfLayers < 0) { AbsoluteAlpha = true; numberOfLayers = Math.Abs(numberOfLayers); } m_layers.Clear(); if (numberOfLayers == 0) return; for (int i = 0; i < numberOfLayers; i++) { m_layers.Add(new Layer(reader, this)); } PrivateThreadPool threadPool = new PrivateThreadPool(); foreach (Layer layer in m_layers) { foreach (Layer.Channel channel in layer.Channels) { if (channel.ID != -2) { channel.LoadPixelData(reader); DecompressChannelContext dcc = new DecompressChannelContext(channel); WaitCallback waitCallback = new WaitCallback(dcc.DecompressChannel); threadPool.QueueUserWorkItem(waitCallback); } } layer.MaskData.LoadPixelData(reader); } threadPool.Drain(); //----------------------------------------------------------------------- if (reader.BaseStream.Position % 2 == 1) reader.ReadByte(); //----------------------------------------------------------------------- // make sure we are not on a wrong offset, so set the stream position // manually reader.BaseStream.Position = startPosition + layersInfoSectionLength; }