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; } } }
public void CompressImageData() { if (m_imageCompression == ImageCompression.Rle) { MemoryStream dataStream = new MemoryStream(); BinaryReverseWriter writer = new BinaryReverseWriter(dataStream); // we will write the correct lengths later, so remember // the position long lengthPosition = writer.BaseStream.Position; int[] rleRowLengths = new int[m_layer.m_rect.Height]; for (int i = 0; i < rleRowLengths.Length; i++) { writer.Write((short)0x1234); } //--------------------------------------------------------------- int bytesPerRow = 0; switch (m_layer.PsdFile.Depth) { case 1: bytesPerRow = ImageDecoder.BytesFromBits(m_layer.m_rect.Width); break; case 8: bytesPerRow = m_layer.m_rect.Width; break; case 16: bytesPerRow = m_layer.m_rect.Width * 2; break; } //--------------------------------------------------------------- for (int row = 0; row < m_layer.m_rect.Height; row++) { int rowIndex = row * m_layer.m_rect.Width; rleRowLengths[row] = RleHelper.EncodedRow(writer.BaseStream, m_imageData, rowIndex, bytesPerRow); } //--------------------------------------------------------------- long endPosition = writer.BaseStream.Position; writer.BaseStream.Position = lengthPosition; for (int i = 0; i < rleRowLengths.Length; i++) { writer.Write((short)rleRowLengths[i]); } writer.BaseStream.Position = endPosition; dataStream.Close(); m_data = dataStream.ToArray(); dataStream.Dispose(); } else { m_data = (byte[])m_imageData.Clone(); } }
/////////////////////////////////////////////////////////////////////////// private void LoadImage(BinaryReverseReader reader) { Debug.WriteLine("LoadImage started at " + reader.BaseStream.Position.ToString()); 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 = ImageDecoder.BytesFromBits(m_columns); 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 * bytesPerRow; RleHelper.DecodedRow(reader.BaseStream, m_imageData[ch], rowIndex, bytesPerRow); } } break; default: break; } } }