Пример #1
0
        public Layer(PsdBinaryReader reader, PsdFile psdFile)
            : this(psdFile)
        {
            Util.DebugMessage(reader.BaseStream, "Load, Begin, Layer");

            Rect = reader.ReadRectangle();

            //-----------------------------------------------------------------------
            // Read channel headers.  Image data comes later, after the layer header.

            int numberOfChannels = reader.ReadUInt16();
            for (int channel = 0; channel < numberOfChannels; channel++)
            {
                var ch = new Channel(reader, this);
                Channels.Add(ch);
            }

            //-----------------------------------------------------------------------
            //

            var signature = reader.ReadAsciiChars(4);
            if (signature != "8BIM")
            {
                throw (new PsdInvalidException("Invalid signature in layer header."));
            }

            BlendModeKey = reader.ReadAsciiChars(4);
            Opacity      = reader.ReadByte();
            Clipping     = reader.ReadBoolean();

            var flagsByte = reader.ReadByte();
            flags = new BitVector32(flagsByte);
            reader.ReadByte(); //padding

            //-----------------------------------------------------------------------

            // This is the total size of the MaskData, the BlendingRangesData, the
            // Name and the AdjustmentLayerInfo.
            var extraDataSize          = reader.ReadUInt32();
            var extraDataStartPosition = reader.BaseStream.Position;

            Masks = new MaskInfo(reader, this);
            BlendingRangesData = new BlendingRanges(reader, this);
            Name = reader.ReadPascalString(4);

            //-----------------------------------------------------------------------
            // Process Additional Layer Information

            long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;
            while (reader.BaseStream.Position < adjustmentLayerEndPos)
            {
                var layerInfo = LayerInfoFactory.Load(reader,
                                                      psdFile: this.PsdFile,
                                                      globalLayerInfo: false);
                AdditionalInfo.Add(layerInfo);
            }

            foreach (var adjustmentInfo in AdditionalInfo)
            {
                switch (adjustmentInfo.Key)
                {
                case "luni":
                    Name = ((LayerUnicodeName)adjustmentInfo).Name;
                    break;
                }
            }

            Util.DebugMessage(reader.BaseStream, "Load, End, Layer, {0}", Name);

            PsdFile.LoadContext.OnLoadLayerHeader(this);
        }
Пример #2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Layer"/> class using the provided reader containing the PSD file data.
        /// </summary>
        /// <param name="reader">The reader containing the PSD file data.</param>
        /// <param name="psdFile">The PSD file to set as the parent.</param>
        public Layer(BinaryReverseReader reader, PsdFile psdFile)
        {
            Children = new List <Layer>();
            PsdFile  = psdFile;

            // read the rect
            Rect rect = new Rect();

            rect.y      = reader.ReadInt32();
            rect.x      = reader.ReadInt32();
            rect.height = reader.ReadInt32() - rect.y;
            rect.width  = reader.ReadInt32() - rect.x;
            Rect        = rect;

            // read the channels
            int channelCount = reader.ReadUInt16();

            Channels       = new List <Channel>();
            SortedChannels = new SortedList <short, Channel>();
            for (int index = 0; index < channelCount; ++index)
            {
                Channel channel = new Channel(reader, this);
                Channels.Add(channel);
                SortedChannels.Add(channel.ID, channel);
            }

            // read the header and verify it
            if (new string(reader.ReadChars(4)) != "8BIM")
            {
                throw new IOException("Layer Channelheader error!");
            }

            // read the blend mode key (unused) (defaults to "norm")
            reader.ReadChars(4);

            // read the opacity
            Opacity = reader.ReadByte();

            // read the clipping (unused) (< 0 = base, > 0 = non base)
            reader.ReadByte();

            // read all of the flags (protectTrans, visible, obsolete, ver5orLater, pixelDataIrrelevant)
            flags = new BitVector32(reader.ReadByte());

            // skip a padding byte
            reader.ReadByte();

            uint num3      = reader.ReadUInt32();
            long position1 = reader.BaseStream.Position;

            MaskData           = new Mask(reader, this);
            BlendingRangesData = new BlendingRanges(reader);
            long position2 = reader.BaseStream.Position;

            // read the name
            Name = reader.ReadPascalString();

            // read the adjustment info
            int count = (int)((reader.BaseStream.Position - position2) % 4L);

            reader.ReadBytes(count);
            AdjustmentInfo = new List <AdjustmentLayerInfo>();
            long num4 = position1 + num3;

            while (reader.BaseStream.Position < num4)
            {
                try
                {
                    AdjustmentInfo.Add(new AdjustmentLayerInfo(reader, this));
                }
                catch
                {
                    reader.BaseStream.Position = num4;
                }
            }

            foreach (AdjustmentLayerInfo adjustmentLayerInfo in AdjustmentInfo)
            {
                if (adjustmentLayerInfo.Key == "TySh")
                {
                    ReadTextLayer(adjustmentLayerInfo.DataReader);
                }
                else if (adjustmentLayerInfo.Key == "luni")
                {
                    // read the unicode name
                    BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader;
                    dataReader.ReadBytes(3);
                    dataReader.ReadByte();
                    Name = dataReader.ReadString().TrimEnd(new char[1]);
                }
            }

            reader.BaseStream.Position = num4;
        }
Пример #3
0
        //public BitVector32 Flags
        //{
        //    get { return flags; }
        //}
        /// <summary>
        /// Initializes a new instance of the <see cref="Layer"/> class using the provided reader containing the PSD file data.
        /// </summary>
        /// <param name="reader">The reader containing the PSD file data.</param>
        /// <param name="psdFile">The PSD file to set as the parent.</param>
        public Layer(BinaryReverseReader reader, PsdFile psdFile)
        {
            Children = new List<Layer>();
            PsdFile = psdFile;

            // read the rect
            Rect rect = new Rect();
            rect.y = reader.ReadInt32();
            rect.x = reader.ReadInt32();
            rect.height = reader.ReadInt32() - rect.y;
            rect.width = reader.ReadInt32() - rect.x;
            Rect = rect;

            // read the channels
            int channelCount = reader.ReadUInt16();
            Channels = new List<Channel>();
            SortedChannels = new SortedList<short, Channel>();
            for (int index = 0; index < channelCount; ++index)
            {
                Channel channel = new Channel(reader, this);
                Channels.Add(channel);
                SortedChannels.Add(channel.ID, channel);
            }

            // read the header and verify it
            if (new string(reader.ReadChars(4)) != "8BIM")
            {
                throw new IOException("Layer Channelheader error!");
            }

            // read the blend mode key (unused) (defaults to "norm")
            reader.ReadChars(4);

            // read the opacity
            Opacity = reader.ReadByte();

            // read the clipping (unused) (< 0 = base, > 0 = non base)
            reader.ReadByte();

            // read all of the flags (protectTrans, visible, obsolete, ver5orLater, pixelDataIrrelevant)
            flags = new BitVector32(reader.ReadByte());

            // skip a padding byte
            reader.ReadByte();

            uint num3 = reader.ReadUInt32();
            long position1 = reader.BaseStream.Position;
            MaskData = new Mask(reader, this);
            BlendingRangesData = new BlendingRanges(reader);
            long position2 = reader.BaseStream.Position;

            // read the name
            Name = reader.ReadPascalString();

            // read the adjustment info
            int count = (int)((reader.BaseStream.Position - position2) % 4L);
            reader.ReadBytes(count);
            AdjustmentInfo = new List<AdjustmentLayerInfo>();
            long num4 = position1 + num3;
            while (reader.BaseStream.Position < num4)
            {
                try
                {
                    AdjustmentInfo.Add(new AdjustmentLayerInfo(reader, this));
                }
                catch
                {
                    reader.BaseStream.Position = num4;
                }
            }

            foreach (AdjustmentLayerInfo adjustmentLayerInfo in AdjustmentInfo)
            {
                if (adjustmentLayerInfo.Key == "TySh")
                {
                    ReadTextLayer(adjustmentLayerInfo.DataReader);
                }
                else if (adjustmentLayerInfo.Key == "luni")
                {
                    // read the unicode name
                    BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader;
                    dataReader.ReadBytes(3);
                    dataReader.ReadByte();
                    Name = dataReader.ReadString().TrimEnd(new char[1]);
                }
            }

            reader.BaseStream.Position = num4;
        }
Пример #4
0
        public Layer(BinaryReverseReader reader, PsdFile psdFile)
        {
            //从文档 五 - 4 - 1) 开始读
            Children = new List <Layer>();
            PsdFile  = psdFile;

            Rect rect = new Rect();

            rect.y      = reader.ReadInt32();
            rect.x      = reader.ReadInt32();
            rect.height = reader.ReadInt32() - rect.y;
            rect.width  = reader.ReadInt32() - rect.x;
            Rect        = rect;

            int channelCount = reader.ReadUInt16();

            Channels       = new List <Channel>();
            SortedChannels = new SortedList <short, Channel>();
            for (int index = 0; index < channelCount; ++index)
            {
                Channel channel = new Channel(reader, this);
                Channels.Add(channel);
                SortedChannels.Add(channel.ID, channel);
            }

            string head = reader.ReadStringNew(4);

            if (head != "8BIM")
            {
                throw new IOException("Layer Channelheader error!");
            }

            string layerRecordsBlendModeKey = reader.ReadStringNew(4);

            Opacity = reader.ReadByte();

            int Clipping = reader.ReadByte();

            _flags = new BitVector32(reader.ReadByte());

            int Filler = reader.ReadByte();

            _imageTransparent = Convert.ToSingle(Opacity) / byte.MaxValue;

            //文档 五 - 4 - 13)
            uint num3      = reader.ReadUInt32();
            long position1 = reader.BaseStream.Position;

            MaskData = new Mask(reader, this);

            _blendingRangesData = new BlendingRanges(reader);
            long position2 = reader.BaseStream.Position;

            // 文档 五 - 4 - 21)
            Name = reader.ReadPascalString();
            // read the adjustment info
            int count = (int)((reader.BaseStream.Position - position2) % 4L);

            reader.ReadBytes(count);

            _adjustmentInfo = new List <AdjustmentLayerInfo>();
            long num4 = position1 + num3;

            while (reader.BaseStream.Position < num4)
            {
                try
                {
                    _adjustmentInfo.Add(new AdjustmentLayerInfo(reader, this));
                }
                catch
                {
                    reader.BaseStream.Position = num4;
                }
            }


            foreach (AdjustmentLayerInfo adjustmentLayerInfo in _adjustmentInfo)
            {
                if (adjustmentLayerInfo.Key == "TySh")
                {
                    ReadTextLayer(adjustmentLayerInfo.DataReader);
                }
                else if (adjustmentLayerInfo.Key == "luni")
                {
                    // read the unicode name
                    BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader;
                    byte[] temp1     = dataReader.ReadBytes(3);
                    byte   charCount = dataReader.ReadByte();
                    //本来 charCount 是文本串的长度,可以传入ReadString()限定读取长度,但Text除串头无文本长度信息,因此改为读一段Unicode字符串
                    Name = dataReader.ReadString();
                    if (Name == "")
                    {
                        Name = DefaultLayerName;
                    }
                }
                //此处针对字体  图层样式
                else if (adjustmentLayerInfo.Key == "lrFX") //样式 相关,对于字体来说,就是描边之类的
                {
                    ParseLrfxKeyword(adjustmentLayerInfo);  //yanruTODO测试屏蔽
                }
                //仅对于图片的
                else if (adjustmentLayerInfo.Key == "lspf")
                {
                    BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader;
                    byte[] data = dataReader.ReadBytes(4);
                }
                else if (adjustmentLayerInfo.Key == "lclr")
                {
                    BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader;
                    byte[] data = dataReader.ReadBytes(10);
                }
            }

            reader.BaseStream.Position = num4;

            int deltaL = (int)(MaskData.Rect.x - Rect.x);
            int deltaR = (int)(Rect.xMax - MaskData.Rect.xMax);
            int deltaT = (int)(MaskData.Rect.y - Rect.y);
            int deltaB = (int)(Rect.yMax - MaskData.Rect.yMax);
            int l      = deltaL > 0 ? deltaL : 0;
            int r      = deltaR > 0 ? deltaR : 0;
            int t      = deltaT > 0 ? deltaT : 0;
            int b      = deltaB > 0 ? deltaB : 0;

            //Unity Document TextureImporter.spriteBorder  X=left, Y=bottom, Z=right, W=top.
            _border = new Vector4(l, b, r, t);
            //_is9Slice = SLICE_REG.Match(_name).Success;
            _is9Slice = _name.Contains(SLICE_HEAD);
        }
Пример #5
0
        public Layer(BinaryReverseReader reader, PsdFile psdFile)
        {
            Debug.WriteLine("Layer started at " + reader.BaseStream.Position);

            m_psdFile = psdFile;
            m_rect    = new Rectangle
            {
                Y = reader.ReadInt32(),
                X = reader.ReadInt32()
            };
            m_rect.Height = reader.ReadInt32() - m_rect.Y;
            m_rect.Width  = reader.ReadInt32() - m_rect.X;


            //-----------------------------------------------------------------------

            int numberOfChannels = reader.ReadUInt16();

            m_channels.Clear();
            for (int channel = 0; channel < numberOfChannels; channel++)
            {
                var ch = new Channel(reader, this);
                m_channels.Add(ch);
                m_sortedChannels.Add(ch.ID, ch);
            }

            //-----------------------------------------------------------------------

            var signature = new string(reader.ReadChars(4));

            if (signature != LayerConstants.EightBimSignature)
            {
                throw (new IOException("Layer Channelheader error!"));
            }

            m_blendModeKey = new string(reader.ReadChars(4));
            m_opacity      = reader.ReadByte();

            m_clipping = reader.ReadByte() > 0;

            //-----------------------------------------------------------------------

            byte flags = reader.ReadByte();

            m_flags = new BitVector32(flags);

            //-----------------------------------------------------------------------

            reader.ReadByte(); //padding

            //-----------------------------------------------------------------------

            Debug.WriteLine("Layer extraDataSize started at " + reader.BaseStream.Position);

            // this is the total size of the MaskData, the BlendingRangesData, the
            // Name and the AdjustmenLayerInfo
            uint extraDataSize = reader.ReadUInt32();


            // remember the start position for calculation of the
            // AdjustmenLayerInfo size
            long extraDataStartPosition = reader.BaseStream.Position;

            m_maskData           = new Mask(reader, this);
            m_blendingRangesData = new BlendingRanges(reader, this);

            //-----------------------------------------------------------------------

            var namePosition = reader.BaseStream.Position;

            m_name = reader.ReadPascalString();

            var paddingBytes = (int)((reader.BaseStream.Position - namePosition) % 4);

            Debug.Print("Layer {0} padding bytes after name", paddingBytes);
            reader.ReadBytes(paddingBytes);

            //-----------------------------------------------------------------------

            m_adjustmentInfo.Clear();

            long adjustmenLayerEndPos = extraDataStartPosition + extraDataSize;

            while (reader.BaseStream.Position < adjustmenLayerEndPos)
            {
                try
                {
                    m_adjustmentInfo.Add(new AdjusmentLayerInfo(reader, this));
                }
                catch
                {
                    reader.BaseStream.Position = adjustmenLayerEndPos;
                }
            }


            //-----------------------------------------------------------------------
            // make shure we are not on a wrong offset, so set the stream position
            // manually
            reader.BaseStream.Position = adjustmenLayerEndPos;
        }
Пример #6
0
        public Layer(BinaryReverseReader reader, PsdFile psdFile)
        {
            Debug.WriteLine("Layer started at " + reader.BaseStream.Position.ToString());

            m_psdFile     = psdFile;
            m_rect        = new Rectangle();
            m_rect.Y      = reader.ReadInt32();
            m_rect.X      = reader.ReadInt32();
            m_rect.Height = reader.ReadInt32() - m_rect.Y;
            m_rect.Width  = reader.ReadInt32() - m_rect.X;

            //-----------------------------------------------------------------------

            int numberOfChannels = reader.ReadUInt16();

            this.m_channels.Clear();
            for (int channel = 0; channel < numberOfChannels; channel++)
            {
                Channel ch = new Channel(reader, this);
                m_channels.Add(ch);
                m_sortedChannels.Add(ch.ID, ch);
            }

            //-----------------------------------------------------------------------

            string signature = new string(reader.ReadChars(4));

            if (signature != "8BIM")
            {
                throw (new IOException("Layer Channelheader error!"));
            }

            m_blendModeKey = new string(reader.ReadChars(4));
            m_opacity      = reader.ReadByte();

            m_clipping = reader.ReadByte() > 0;

            //-----------------------------------------------------------------------

            byte flags = reader.ReadByte();

            m_flags = new BitVector32(flags);

            //-----------------------------------------------------------------------

            reader.ReadByte(); //padding

            //-----------------------------------------------------------------------

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

            // this is the total size of the MaskData, the BlendingRangesData, the
            // Name and the AdjustmentLayerInfo
            uint extraDataSize = reader.ReadUInt32();

            // remember the start position for calculation of the
            // AdjustmentLayerInfo size
            long extraDataStartPosition = reader.BaseStream.Position;

            m_maskData           = new Mask(reader, this);
            m_blendingRangesData = new BlendingRanges(reader, this);

            //-----------------------------------------------------------------------

            long namePosition = reader.BaseStream.Position;

            m_name = reader.ReadPascalString();

            int paddingBytes = (int)((reader.BaseStream.Position - namePosition) % 4);

            Debug.Print("Layer {0} padding bytes after name", paddingBytes);
            reader.ReadBytes(paddingBytes);

            //-----------------------------------------------------------------------

            m_adjustmentInfo.Clear();

            long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;

            while (reader.BaseStream.Position < adjustmentLayerEndPos)
            {
                try
                {
                    AdjustmentLayerInfo ali = new AdjustmentLayerInfo(reader, this);
                    if (ali.Key.Equals("lrFX"))
                    {
                        //A sub-key - we want to merge its sub-layer info items with this dict.
                        m_adjustmentInfo.AddRange(new Effects(ali)._resources.Values);
                    }
                    else
                    {
                        m_adjustmentInfo.Add(ali); // Just add the items
                    }
                }
                catch
                {
                    reader.BaseStream.Position = adjustmentLayerEndPos;
                }
            }


            //-----------------------------------------------------------------------
            // make sure we are not on a wrong offset, so set the stream position
            // manually
            reader.BaseStream.Position = adjustmentLayerEndPos;
        }
Пример #7
0
        public Layer(BinaryReverseReader reader, PsdFile psdFile)
        {
            Debug.WriteLine("Layer started at " + reader.BaseStream.Position);

            m_psdFile = psdFile;
            m_rect = new Rectangle
            {
                Y = reader.ReadInt32(),
                X = reader.ReadInt32()
            };
            m_rect.Height = reader.ReadInt32() - m_rect.Y;
            m_rect.Width = reader.ReadInt32() - m_rect.X;


            //-----------------------------------------------------------------------

            int numberOfChannels = reader.ReadUInt16();
            m_channels.Clear();
            for (int channel = 0; channel < numberOfChannels; channel++)
            {
                var ch = new Channel(reader, this);
                m_channels.Add(ch);
                m_sortedChannels.Add(ch.ID, ch);
            }

            //-----------------------------------------------------------------------

            var signature = new string(reader.ReadChars(4));
            if (signature != LayerConstants.EightBimSignature)
                throw (new IOException("Layer Channelheader error!"));

            m_blendModeKey = new string(reader.ReadChars(4));
            m_opacity = reader.ReadByte();

            m_clipping = reader.ReadByte() > 0;

            //-----------------------------------------------------------------------

            byte flags = reader.ReadByte();
            m_flags = new BitVector32(flags);

            //-----------------------------------------------------------------------

            reader.ReadByte(); //padding

            //-----------------------------------------------------------------------

            Debug.WriteLine("Layer extraDataSize started at " + reader.BaseStream.Position);

            // this is the total size of the MaskData, the BlendingRangesData, the 
            // Name and the AdjustmenLayerInfo
            uint extraDataSize = reader.ReadUInt32();


            // remember the start position for calculation of the 
            // AdjustmenLayerInfo size
            long extraDataStartPosition = reader.BaseStream.Position;

            m_maskData = new Mask(reader, this);
            m_blendingRangesData = new BlendingRanges(reader, this);

            //-----------------------------------------------------------------------

            var namePosition = reader.BaseStream.Position;

            m_name = reader.ReadPascalString();

            var paddingBytes = (int)((reader.BaseStream.Position - namePosition) % 4);

            Debug.Print("Layer {0} padding bytes after name", paddingBytes);
            reader.ReadBytes(paddingBytes);

            //-----------------------------------------------------------------------

            m_adjustmentInfo.Clear();

            long adjustmenLayerEndPos = extraDataStartPosition + extraDataSize;
            while (reader.BaseStream.Position < adjustmenLayerEndPos)
            {
                try
                {
                    m_adjustmentInfo.Add(new AdjusmentLayerInfo(reader, this));
                }
                catch
                {
                    reader.BaseStream.Position = adjustmenLayerEndPos;
                }
            }


            //-----------------------------------------------------------------------
            // make shure we are not on a wrong offset, so set the stream position 
            // manually
            reader.BaseStream.Position = adjustmenLayerEndPos;
        }
Пример #8
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Layer"/> class using the provided reader containing the PSD file data.
        /// </summary>
        /// <param name="reader">The reader containing the PSD file data.</param>
        /// <param name="psdFile">The PSD file to set as the parent.</param>
        public Layer(BinaryReverseReader reader, PsdFile psdFile)
        {
            Children = new List <Layer>();
            PsdFile  = psdFile;

            // read the rect
            Rect rect = new Rect();

            rect.y      = reader.ReadInt32();
            rect.x      = reader.ReadInt32();
            rect.height = reader.ReadInt32() - rect.y;
            rect.width  = reader.ReadInt32() - rect.x;
            Rect        = rect;

            // read the channels
            int channelCount = reader.ReadUInt16();

            Channels       = new List <Channel>();
            SortedChannels = new SortedList <short, Channel>();
            for (int index = 0; index < channelCount; ++index)
            {
                Channel channel = new Channel(reader, this);
                Channels.Add(channel);

                //Debug.Log(Time.time + "channel.ID=" + channel.ID + ",layer=" + this.Name);
                SortedChannels.Add(channel.ID, channel);
            }

            string head = reader.readStringNew(4);

            //Debug.Log(Time.time + ",head=" + head);
            // read the header and verify it
            if (head != "8BIM")
            {
                throw new IOException("Layer Channelheader error!");
            }

            // read the blend mode key (unused) (defaults to "norm")
            //reader.ReadChars(4);
            string layerRecordsBlendModeKey = reader.readStringNew(4);

            // read the opacity
            Opacity = reader.ReadByte();

            // read the clipping (unused) (< 0 = base, > 0 = non base)
            int Clipping = reader.ReadByte();

            // read all of the flags (protectTrans, visible, obsolete, ver5orLater, pixelDataIrrelevant)
            flags = new BitVector32(reader.ReadByte());

            // skip a padding byte
            int Filler = reader.ReadByte();

            imageTransparent = Convert.ToSingle(Opacity) / byte.MaxValue;
            Debug.Log("layerRecordsBlendModeKey=" + layerRecordsBlendModeKey
                      + ",Opacity=" + Opacity
                      + ",Clipping=" + Clipping
                      + ",flags=" + flags
                      + ", Filler=" + Filler
                      + ",LayerTransparent=" + imageTransparent);

            uint num3      = reader.ReadUInt32();
            long position1 = reader.BaseStream.Position;

            MaskData = new Mask(reader, this);

            BlendingRangesData = new BlendingRanges(reader);
            long position2 = reader.BaseStream.Position;

            // read the name
            Name = reader.ReadPascalString();
            //Debug.Log(Time.time + ",read layer Name=" + Name + ".end");

            // read the adjustment info
            int count = (int)((reader.BaseStream.Position - position2) % 4L);

            reader.ReadBytes(count);
            //Debug.Log(Time.time + ",read count=" + count + ".end");

            AdjustmentInfo = new List <AdjustmentLayerInfo>();
            long num4 = position1 + num3;

            while (reader.BaseStream.Position < num4)
            {
                try
                {
                    AdjustmentInfo.Add(new AdjustmentLayerInfo(reader, this));
                }
                catch
                {
                    reader.BaseStream.Position = num4;
                }
            }


            string keyInfo = "";

            foreach (AdjustmentLayerInfo adjustmentLayerInfo in AdjustmentInfo)
            {
                keyInfo += ",key=" + adjustmentLayerInfo.Key + "\n";

                if (adjustmentLayerInfo.Key == "TySh")
                {
                    ReadTextLayer(adjustmentLayerInfo.DataReader);
                }
                else if (adjustmentLayerInfo.Key == "luni")
                {
                    // read the unicode name
                    BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader;
                    byte[] temp1     = dataReader.ReadBytes(3);
                    byte   charCount = dataReader.ReadByte();
                    //本来 charCount 是文本串的长度,可以传入ReadString()限定读取长度,但Text除串头无文本长度信息,因此改为读一段Unicode字符串
                    Name = dataReader.ReadString();
                    if (Name == "")
                    {
                        Name = defaultLayerName;
                    }
                }
                //此处针对字体  图层样式
                else if (adjustmentLayerInfo.Key == "lrFX") //样式 相关,对于字体来说,就是描边之类的
                {
                    parseLrfxKeyword(adjustmentLayerInfo);  //yanruTODO测试屏蔽
                }
                //仅对于图片的
                else if (adjustmentLayerInfo.Key == "lspf")
                {
                    BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader;
                    byte[] data = dataReader.ReadBytes(4);
                    printbytes(data, "lspf data", true);
                }
                else if (adjustmentLayerInfo.Key == "lclr")
                {
                    BinaryReverseReader dataReader = adjustmentLayerInfo.DataReader;
                    byte[] data = dataReader.ReadBytes(10);
                    printbytes(data, "lclr data", true);
                }
            }

            Debug.Log("layer=" + Name + ",Totalkey=\n" + keyInfo);

            reader.BaseStream.Position = num4;
        }
Пример #9
0
        public Layer(BinaryReverseReader reader, PsdFile psdFile)
        {
            Debug.WriteLine("Layer started at " + reader.BaseStream.Position.ToString());

              m_psdFile = psdFile;
              m_rect = new Rectangle();
              m_rect.Y = reader.ReadInt32();
              m_rect.X = reader.ReadInt32();
              m_rect.Height = reader.ReadInt32() - m_rect.Y;
              m_rect.Width = reader.ReadInt32() - m_rect.X;

              //-----------------------------------------------------------------------

              int numberOfChannels = reader.ReadUInt16();
              this.m_channels.Clear();
              for (int channel = 0; channel < numberOfChannels; channel++)
              {
            Channel ch = new Channel(reader, this);
            m_channels.Add(ch);
            m_sortedChannels.Add(ch.ID, ch);
              }

              //-----------------------------------------------------------------------

              string signature = new string(reader.ReadChars(4));
              if (signature != "8BIM")
            throw (new IOException("Layer Channelheader error!"));

              m_blendModeKey = new string(reader.ReadChars(4));
              m_opacity = reader.ReadByte();

              m_clipping = reader.ReadByte() > 0;

              //-----------------------------------------------------------------------

              byte flags = reader.ReadByte();
              m_flags = new BitVector32(flags);

              //-----------------------------------------------------------------------

              reader.ReadByte(); //padding

              //-----------------------------------------------------------------------

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

              // this is the total size of the MaskData, the BlendingRangesData, the
              // Name and the AdjustmentLayerInfo
              uint extraDataSize = reader.ReadUInt32();

              // remember the start position for calculation of the
              // AdjustmentLayerInfo size
              long extraDataStartPosition = reader.BaseStream.Position;

              m_maskData = new Mask(reader, this);
              m_blendingRangesData = new BlendingRanges(reader, this);

              //-----------------------------------------------------------------------

              long namePosition = reader.BaseStream.Position;

              m_name = reader.ReadPascalString();

              int paddingBytes =(int)((reader.BaseStream.Position - namePosition) % 4);

              Debug.Print("Layer {0} padding bytes after name", paddingBytes);
              reader.ReadBytes(paddingBytes);

              //-----------------------------------------------------------------------

              m_adjustmentInfo.Clear();

              long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;
              while (reader.BaseStream.Position < adjustmentLayerEndPos)
              {
            try
            {
            AdjustmentLayerInfo ali = new AdjustmentLayerInfo(reader, this);
            if (ali.Key.Equals("lrFX"))
            {
                //A sub-key - we want to merge its sub-layer info items with this dict.
                m_adjustmentInfo.AddRange(new Effects(ali)._resources.Values);
            } else
                m_adjustmentInfo.Add(ali); // Just add the items
            }
            catch
            {
              reader.BaseStream.Position = adjustmentLayerEndPos;
            }
              }

              //-----------------------------------------------------------------------
              // make sure we are not on a wrong offset, so set the stream position
              // manually
              reader.BaseStream.Position = adjustmentLayerEndPos;
        }
Пример #10
0
    public Layer(PsdBinaryReader reader, PsdFile psdFile)
      : this(psdFile)
    {
      Rect = reader.ReadRectangle();

      //-----------------------------------------------------------------------
      // Read channel headers.  Image data comes later, after the layer header.

      int numberOfChannels = reader.ReadUInt16();
      for (int channel = 0; channel < numberOfChannels; channel++)
      {
        var ch = new Channel(reader, this);
        Channels.Add(ch);
      }

      //-----------------------------------------------------------------------
      // 

      var signature = reader.ReadAsciiChars(4);
      if (signature != "8BIM")
        throw (new PsdInvalidException("Invalid signature in layer header."));

      BlendModeKey = reader.ReadAsciiChars(4);
      Opacity = reader.ReadByte();
      Clipping = reader.ReadBoolean();

      var flagsByte = reader.ReadByte();
      flags = new BitVector32(flagsByte);
      reader.ReadByte(); //padding

      //-----------------------------------------------------------------------

      // This is the total size of the MaskData, the BlendingRangesData, the 
      // Name and the AdjustmentLayerInfo.
      var extraDataSize = reader.ReadUInt32();
      var extraDataStartPosition = reader.BaseStream.Position;

      Masks = new MaskInfo(reader, this);
      BlendingRangesData = new BlendingRanges(reader, this);
      Name = reader.ReadPascalString(4);

      //-----------------------------------------------------------------------
      // Process Additional Layer Information

      long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;
      while (reader.BaseStream.Position < adjustmentLayerEndPos)
      {
        var layerInfo = LayerInfoFactory.Load(reader);
        AdditionalInfo.Add(layerInfo);
      }

      foreach (var adjustmentInfo in AdditionalInfo)
      {
        switch (adjustmentInfo.Key)
        {
          case "luni":
            Name = ((LayerUnicodeName)adjustmentInfo).Name;
            break;
        }
      }

    }
Пример #11
0
        public Layer(PsdBinaryReader reader, PsdFile psdFile)
            : this(psdFile)
        {
            IsText = false;
            Rect   = reader.ReadRectangle();

            //-----------------------------------------------------------------------
            // Read channel headers.  Image data comes later, after the layer header.

            int numberOfChannels = reader.ReadUInt16();
            for (int channel = 0; channel < numberOfChannels; channel++)
            {
                var ch = new Channel(reader, this);
                Channels.Add(ch);
            }

            //-----------------------------------------------------------------------
            //

            var signature = reader.ReadAsciiChars(4);
            if (signature != "8BIM")
            {
                throw (new PsdInvalidException("Invalid signature in layer header."));
            }

            BlendModeKey = reader.ReadAsciiChars(4);
            Opacity      = reader.ReadByte();
            Clipping     = reader.ReadBoolean();

            var flagsByte = reader.ReadByte();
            flags = new BitVector32(flagsByte);
            reader.ReadByte();             //padding

            //-----------------------------------------------------------------------

            // This is the total size of the MaskData, the BlendingRangesData, the
            // Name and the AdjustmentLayerInfo.
            var extraDataSize          = reader.ReadUInt32();
            var extraDataStartPosition = reader.BaseStream.Position;

            Masks = new MaskInfo(reader, this);
            BlendingRangesData = new BlendingRanges(reader, this);
            Name = reader.ReadPascalString(4);

            //-----------------------------------------------------------------------
            // Process Additional Layer Information

            long adjustmentLayerEndPos = extraDataStartPosition + extraDataSize;
            while (reader.BaseStream.Position < adjustmentLayerEndPos)
            {
                var layerInfo = LayerInfoFactory.Load(reader);
                AdditionalInfo.Add(layerInfo);
            }

            foreach (var adjustmentInfo in AdditionalInfo)
            {
                switch (adjustmentInfo.Key)
                {
                case "luni":
                    Name = ((LayerUnicodeName)adjustmentInfo).Name;
                    break;

                case "TySh":
                    IsText    = true;
                    LayerText = (LayerText)adjustmentInfo;
                    break;

                case "lrFX":
                    Effects = (EffectsLayer)adjustmentInfo;
                    break;

                case "lfx2":
                    BaseEffect = (ObjectBasedEffect)adjustmentInfo;
                    break;
                }
            }
        }