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