//this is where all the main layer information is parsed
private void parseLayerInfo()
{
Console.Out.WriteLine("parsing layer info");
//get the length of the layers data
uint lengthOfLayersData = bytes.getUI32();
//and the number of layers
short layerCount = bytes.getI16();
traceProperty("number of layers", layerCount);
//if the layers count is negative, it maens there is something special
//about the alpha channel
if (layerCount < 0)
{
layerCount *= -1;
//throw new Exception("negative layers not implemented yet");
}
//numberOfLayers is a uint
numberOfLayers = (uint)layerCount;
//cycle through each layer and parse it
for (uint i = 0; i < layerCount; i++)
{
//using the builder pattern here to avoid a massive constructor
Layer layer = new Layer();
//doing the parsing here rather than delegating it to the layer class for readability
//think these are ints
layer.top = bytes.getI32();
layer.left = bytes.getI32();
layer.bottom = bytes.getI32();
layer.right = bytes.getI32();
//although the channels are stored in a different section, the number
//of channels is stored here
layer.numberOfChannels = bytes.getUI16();
layer.hasTransparency = layer.numberOfChannels > 3;
//parse the channels info, (not actually the channels yet/0
for (uint a = 0; a < layer.numberOfChannels; a++)
{
LayerChannelData channelData = new LayerChannelData();
channelData.ID = bytes.getI16();
channelData.channelDataLength = bytes.getUI32();
layer.channels.Add(channelData);
}
layer.signiture = bytes.getString(4);
if (layer.signiture != "8BIM")
{
throw new Exception("Encountered layer with signiture: " + layer.signiture);
}
//options like the blendModeKey arent used, but still parsed
bytes.skipBytes(4);
//between 0-255
layer.opacity = bytes.getByte();
//the base
bytes.skipBytes(1);
//the flags are booleans which are stored as single bits in one byte
byte flags = bytes.getByte();
//checked in libpsd, its a bit cryptic, but looks like 0 is true, 1 is false
layer.visible = (flags & 2) == 0;
//padding
bytes.skipBytes(1);
//the extra data fields are tags found at the end of the layer
//and are very similar to image resource blocks
uint extraDataFieldLength = bytes.getUI32();
//end of the whole layer, i think
uint possibleEnd = (uint)bytes.Position + extraDataFieldLength;
//parse the layer mask, dont think this is implemented yet
parseLayerMask(layer);
//parse the blending ranges, dont think this is implemented yet
parseLayerBlendingRanges(layer);
//read the name of the layer, the name also exists as a unicode name
//in an extra tag block
layer.name = bytes.getPascalString(4);
//cycle through the extra tags
while (bytes.Position != possibleEnd)
{
if (bytes.Position > possibleEnd)
{
throw new Exception("overflow when parsing extra layer tags");
}
String sig = bytes.getString(4);
if (sig != "8BIM")
{
//really screwed up here
throw new Exception("unknown sig for layer tag: " + sig);
}
//get the tag name and the tag length
String tagName = bytes.getString(4);
int tagLength = bytes.getI32();
//the tag length is padded to an even number
if (tagLength % 2 == 1)
{
tagLength++;
}
uint tagEnd = (uint)(bytes.Position + tagLength);
//i dont like giving 'bytes' to the layer, but im resetting the position afterwards
//so it should be fine.
//parse the tag
layer.parseAdditionalLayerInfo(tagName, tagLength, bytes);
//make sure that we are at the start of the next tag,
bytes.Position = tagEnd;
}
//make sure we are at the end of the section
bytes.Position = possibleEnd;
layers.Add(layer);
}
}
internal void parseImageChannelData(ByteArray bytes)
{
Console.Out.WriteLine("layer: " + name);
//dont want to render folders or invalid bounds
if (type != Layer.TYPE_NORMAL || bottom <= top || right <= left)
{
return;
}
image = new Bitmap(right - left, bottom - top, PixelFormat.Format32bppArgb);
//cycle through the layers, parsing the bytes, and decoding if necessary
foreach (LayerChannelData channel in channels)
{
//get the next channel pos, so if something goes wrong parsing
//this channel, it wont screw up the next one
uint nextChannelPos = (uint)(bytes.Position + channel.channelDataLength);
if (channel.ID < -1)
{
//skipping user supplied masks
bytes.Position = nextChannelPos;
continue;
}
//lets hope bytes.position is in the right place
uint compressionMethod = bytes.getUI16();
//if it needs decompressing
switch (compressionMethod)
{
case 0:
//not compressed
//get the data and store it in the individual channel objects
//-2 is for the 2 bytes taken up by the compression type
channel.data = bytes.getBytes((uint)(image.Width * image.Height));
channel.data.Position = 0;
break;
case 1:
//rle
channel.data = new ByteArray(new byte[0]);
//each scan line is compressed seperately, so we need to get the
//length of each encoded line
List <uint> lineLengths = new List <uint>(image.Height);
//then we can cycle though each line and decode it
for (int i = 0; i < image.Height; ++i)
{
lineLengths.Add(bytes.getUI16());
}
//now that the lines have been decoded, we can write them back to
//the channel
MemoryStream data = new MemoryStream();
for (int i = 0; i < image.Height; ++i)
{
ByteArray line = bytes.getBytes(lineLengths[i]);
byte[] unrle = ByteArray.unRLE(line);
data.Write(unrle, 0, unrle.Length);
}
channel.data = new ByteArray(data.ToArray());
break;
case 2:
case 3:
//cant handle these compression methods,
//going to skip for now
return;
}
//just in case the rle doesnt reset the position properly
channel.data.Position = 0;
bytes.Position = nextChannelPos;
}
//will be null if it doesnt exist
LayerChannelData alphaChannel = getChannel(LayerChannelData.TRANSPARENCY_MASK);
LayerChannelData redChannel = getChannel(LayerChannelData.RED);
LayerChannelData greenChannel = getChannel(LayerChannelData.GREEN);
LayerChannelData blueChannel = getChannel(LayerChannelData.BLUE);
for (uint j = 0; j < image.Height; j++)
{
for (uint k = 0; k < image.Width; k++)
{
//if there is alpha we have to use setPixel32 as there are 4 bytes
//to worry about
if (alphaChannel != null)
{
image.SetPixel((int)k, (int)j, Color.FromArgb(alphaChannel.data.getByte(),
redChannel.data.getByte(),
greenChannel.data.getByte(),
blueChannel.data.getByte()));
}
else
{
image.SetPixel((int)k, (int)j, Color.FromArgb(redChannel.data.getByte(),
greenChannel.data.getByte(),
blueChannel.data.getByte()));
}
}
}
//now sort out out the mask, cant do masks very well
if (mask != null && mask.right > mask.left && mask.top < mask.bottom)
{
//this represents the bounds of the image
Rectangle realRect = new Rectangle(left, top, right - left, bottom - top);
//this represents the bounds of the mask
Rectangle maskRect = new Rectangle(mask.left, mask.top, mask.right - mask.left, mask.bottom - mask.top);
//we combine them to get the new bounds
Rectangle insideRect = new Rectangle();
insideRect.X = Math.Max(realRect.X, maskRect.X);
insideRect.Y = Math.Max(realRect.Y, maskRect.Y);
insideRect.Width = Math.Min(realRect.Right, maskRect.Right) - insideRect.X;
insideRect.Height = Math.Min(realRect.Bottom, maskRect.Bottom) - insideRect.Y;
image = image.Clone(insideRect, PixelFormat.Format32bppArgb);
left = insideRect.X;
right = insideRect.Right;
top = insideRect.Y;
bottom = insideRect.Bottom;
}
}