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