示例#1
0
			internal void LoadPixelData(BinaryReverseReader reverseReader)
			{
				Debug.WriteLine("Channel.LoadPixelData started at " + reverseReader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));

				Data = reverseReader.ReadBytes(Length);

				using (BinaryReverseReader imageReader = DataReader)
				{
					ImageCompression = (ImageCompression)imageReader.ReadInt16();

					Int32 bytesPerRow = 0;

					switch (Layer.PsdFile.Depth)
					{
						case 1:
							bytesPerRow = Layer.Rect.Width;//NOT sure
							break;
						case 8:
							bytesPerRow = Layer.Rect.Width;
							break;
						case 16:
							bytesPerRow = Layer.Rect.Width * 2;
							break;
					}

					ImageData = new Byte[Layer.Rect.Height * bytesPerRow];

					switch (ImageCompression)
					{
						case ImageCompression.Raw:
							imageReader.Read(ImageData, 0, ImageData.Length);
							break;
						case ImageCompression.Rle:
							{
								Int32[] rowLengthList = new Int32[Layer.Rect.Height];

								for (Int32 i = 0; i < rowLengthList.Length; i++) rowLengthList[i] = imageReader.ReadInt16();

								for (Int32 i = 0; i < Layer.Rect.Height; i++)
								{
									Int32 rowIndex = i * Layer.Rect.Width;
									RleHelper.DecodedRow(imageReader.BaseStream, ImageData, rowIndex, bytesPerRow);

									//if (rowLenghtList[i] % 2 == 1)
									//  readerImg.ReadByte();
								}
							}
							break;
					}
				}
			}
示例#2
0
            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();

                    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:
                            {
                                int[] 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++)
                                {
                                    int rowIndex = i * m_layer.m_rect.Width;
                                    RleHelper.DecodedRow(readerImg.BaseStream, m_imageData, rowIndex, bytesPerRow);

                                    //if (rowLenghtList[i] % 2 == 1)
                                    //    readerImg.ReadByte();
                                }
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
示例#3
0
        ///////////////////////////////////////////////////////////////////////////

        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;
                }
            }
        }
示例#4
0
            //////////////////////////////////////////////////////////////////
            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;
                  }
                }
            }
示例#5
0
        public void Load(Stream stream)
        {
            //binary reverse reader reads data types in big-endian format.
            BinaryReverseReader reader = new BinaryReverseReader(stream);

            //The headers area is used to check for a valid PSD file
            Debug.WriteLine("LoadHeader started at " + reader.BaseStream.Position.ToString());

            string signature = new string(reader.ReadChars(4));
            if (signature != "8BPS")
                throw new IOException("Bad or invalid file stream supplied");

            //get the version number, should be 1 always
            if ((m_version = reader.ReadInt16()) != 1)
                throw new IOException("Invalid version number supplied");

            //get rid of the 6 bytes reserverd in PSD format
            reader.BaseStream.Position += 6;

            //get the rest of the information from the PSD file.
            //Everytime ReadInt16() is called, it reads 2 bytes.
            //Everytime ReadInt32() is called, it reads 4 bytes.
            m_channels = reader.ReadInt16();
            m_rows = reader.ReadInt32();
            m_columns = reader.ReadInt32();
            m_depth = reader.ReadInt16();
            m_colorMode = (ColorModes)reader.ReadInt16();

            //by end of headers, the reader has read 26 bytes into the file.

            /// <summary>
            /// If ColorMode is ColorModes.Indexed, the following 768 bytes will contain
            /// a 256-color palette. If the ColorMode is ColorModes.Duotone, the data
            /// following presumably consists of screen parameters and other related information.
            /// Unfortunately, it is intentionally not documented by Adobe, and non-Photoshop
            /// readers are advised to treat duotone images as gray-scale images.
            /// </summary>
            Debug.WriteLine("LoadColorModeData started at " + reader.BaseStream.Position.ToString());

            uint paletteLength = reader.ReadUInt32(); //readUint32() advances the reader 4 bytes.
            if (paletteLength > 0)
            {
                ColorModeData = reader.ReadBytes((int)paletteLength);
            }

            //This part takes extensive use of classes that I didn't write therefore
            //I can't document much on what they do.

            Debug.WriteLine("LoadingImageResources started at " + reader.BaseStream.Position.ToString());

            m_imageResources.Clear();

            uint imgResLength = reader.ReadUInt32();
            if (imgResLength > 0)
            {
                long startPosition = reader.BaseStream.Position;

                while ((reader.BaseStream.Position - startPosition) < imgResLength)
                {
                    ImageResource imgRes = new ImageResource(reader);

                    ResourceIDs resID = (ResourceIDs)imgRes.ID;
                    switch (resID)
                    {
                        case ResourceIDs.ResolutionInfo:
                            imgRes = new ResolutionInfo(imgRes);
                            break;
                        case ResourceIDs.Thumbnail1:
                        case ResourceIDs.Thumbnail2:
                            imgRes = new Thumbnail(imgRes);
                            break;
                        case ResourceIDs.AlphaChannelNames:
                            imgRes = new AlphaChannels(imgRes);
                            break;
                    }

                    m_imageResources.Add(imgRes);
                }
                // make sure we are not on a wrong offset, so set the stream position
                // manually
                reader.BaseStream.Position = startPosition + imgResLength;

                //We are gonna load up all the layers and masking of the PSD now.
                Debug.WriteLine("LoadLayerAndMaskInfo - Part1 started at " + reader.BaseStream.Position.ToString());
                uint layersAndMaskLength = reader.ReadUInt32();

                if (layersAndMaskLength > 0)
                {
                    //new start position
                    startPosition = reader.BaseStream.Position;

                    //Lets start by loading up all the layers
                    LoadLayers(reader);
                    //we are done the layers, load up the masks
                    LoadGlobalLayerMask(reader);

                    // make sure we are not on a wrong offset, so set the stream position
                    // manually
                    reader.BaseStream.Position = startPosition + layersAndMaskLength;

                    //we have loaded up all the information from the PSD file
                    //into variables we can use later on.

                    //lets finish loading the raw data that defines the image
                    //in the picture.

                    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 = m_columns;//NOT Sure
                            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;
                            default:
                                break;
                        }
                    }
                }
            }
        }