mirror of
https://github.com/danbulant/Cosmos
synced 2026-05-19 12:30:32 +00:00
1304 lines
48 KiB
C#
1304 lines
48 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.IO;
|
|
using Orvid.Compression.Streams;
|
|
using Orvid.Compression.Checksums;
|
|
|
|
namespace Orvid.Graphics.ImageFormats
|
|
{
|
|
public class PngImage : ImageFormat
|
|
{
|
|
public override void Save(Image i, Stream dest)
|
|
{
|
|
PngEncoder p = new PngEncoder();
|
|
p.Encode(i, dest);
|
|
}
|
|
|
|
public override Image Load(Stream s)
|
|
{
|
|
PngDecoder p = new PngDecoder();
|
|
return p.Decode(s);
|
|
}
|
|
|
|
// Please note, everything below this
|
|
// point was originally from the ImageTools
|
|
// Library, available here:
|
|
// http://imagetools.codeplex.com/
|
|
//
|
|
//
|
|
// The source has been modified for use in this library.
|
|
//
|
|
// This disclaimer was last
|
|
// modified on August 9, 2011.
|
|
|
|
#region Encoder
|
|
/// <summary>
|
|
/// Image encoder for writing image data to a stream in png format.
|
|
/// </summary>
|
|
private class PngEncoder
|
|
{
|
|
private const int MaxBlockSize = 0xFFFF;
|
|
private Stream _stream;
|
|
private Image _image;
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether this encoder
|
|
/// will write the image uncompressed the stream.
|
|
/// </summary>
|
|
/// <value>
|
|
/// <c>true</c> if the image should be written uncompressed to
|
|
/// the stream; otherwise, <c>false</c>.
|
|
/// </value>
|
|
public bool IsWritingUncompressed { get; set; }
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether this instance is writing
|
|
/// gamma information to the stream. The default value is false.
|
|
/// </summary>
|
|
/// <value>
|
|
/// <c>true</c> if this instance is writing gamma
|
|
/// information to the stream.; otherwise, <c>false</c>.
|
|
/// </value>
|
|
public bool IsWritingGamma { get; set; }
|
|
|
|
/// <summary>
|
|
/// Gets or sets the gamma value, that will be written
|
|
/// the the stream, when the <see cref="IsWritingGamma"/> property
|
|
/// is set to true. The default value is 2.2f.
|
|
/// </summary>
|
|
/// <value>The gamma value of the image.</value>
|
|
public double Gamma { get; set; }
|
|
|
|
/// <summary>
|
|
/// Gets the default file extension for this encoder.
|
|
/// </summary>
|
|
/// <value>The default file extension for this encoder.</value>
|
|
public string Extension
|
|
{
|
|
get { return "PNG"; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="PngEncoder"/> class.
|
|
/// </summary>
|
|
public PngEncoder()
|
|
{
|
|
Gamma = 2.2f;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates if the image encoder supports the specified
|
|
/// file extension.
|
|
/// </summary>
|
|
/// <param name="extension">The file extension.</param>
|
|
/// <returns><c>true</c>, if the encoder supports the specified
|
|
/// extensions; otherwise <c>false</c>.
|
|
/// </returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="extension"/>
|
|
/// is null (Nothing in Visual Basic).</exception>
|
|
/// <exception cref="ArgumentException"><paramref name="extension"/> is a string
|
|
/// of length zero or contains only blanks.</exception>
|
|
public bool IsSupportedFileExtension(string extension)
|
|
{
|
|
string extensionAsUpper = extension.ToUpper(System.Globalization.CultureInfo.CurrentCulture);
|
|
return extensionAsUpper == "PNG";
|
|
}
|
|
|
|
public void Encode(Image image, Stream stream)
|
|
{
|
|
_image = image;
|
|
_stream = stream;
|
|
// Write the png header.
|
|
stream.Write(
|
|
new byte[]
|
|
{
|
|
0x89, 0x50, 0x4E, 0x47,
|
|
0x0D, 0x0A, 0x1A, 0x0A
|
|
}, 0, 8);
|
|
|
|
PngHeader header = new PngHeader();
|
|
header.Width = image.Width;
|
|
header.Height = image.Height;
|
|
header.ColorType = 6;
|
|
header.BitDepth = 8;
|
|
header.FilterMethod = 0;
|
|
header.CompressionMethod = 0;
|
|
header.InterlaceMethod = 0;
|
|
|
|
WriteHeaderChunk(header);
|
|
|
|
WritePhysicsChunk();
|
|
WriteGammaChunk();
|
|
|
|
if (IsWritingUncompressed)
|
|
{
|
|
WriteDataChunksFast();
|
|
}
|
|
else
|
|
{
|
|
WriteDataChunks();
|
|
}
|
|
WriteEndChunk();
|
|
|
|
stream.Flush();
|
|
}
|
|
|
|
private void WritePhysicsChunk()
|
|
{
|
|
//if (_image.DensityX > 0 && _image.DensityY > 0)
|
|
{
|
|
#warning TODO: Un-Comment this when DPI is supported in Orvid.Graphics.Image
|
|
//int dpmX = (int)Math.Round(_image.DensityX * 39.3700787d);
|
|
//int dpmY = (int)Math.Round(_image.DensityY * 39.3700787d);
|
|
|
|
// DPI isn't currently supported,
|
|
// so used 75 as the default.
|
|
int dpmX = 2953;
|
|
int dpmY = 2953;
|
|
|
|
byte[] chunkData = new byte[9];
|
|
|
|
WriteInteger(chunkData, 0, dpmX);
|
|
WriteInteger(chunkData, 4, dpmY);
|
|
|
|
chunkData[8] = 1;
|
|
|
|
WriteChunk(PngChunkTypes.Physical, chunkData);
|
|
}
|
|
}
|
|
|
|
private void WriteGammaChunk()
|
|
{
|
|
if (IsWritingGamma)
|
|
{
|
|
int gammeValue = (int)(Gamma * 100000f);
|
|
|
|
byte[] fourByteData = new byte[4];
|
|
|
|
byte[] size = BitConverter.GetBytes(gammeValue);
|
|
fourByteData[0] = size[3]; fourByteData[1] = size[2]; fourByteData[2] = size[1]; fourByteData[3] = size[0];
|
|
|
|
WriteChunk(PngChunkTypes.Gamma, fourByteData);
|
|
}
|
|
}
|
|
|
|
private void WriteDataChunksFast()
|
|
{
|
|
byte[] pixels = ConvertPixelArrayToByteArray(_image.Data);
|
|
|
|
// Convert the pixel array to a new array for adding
|
|
// the filter byte.
|
|
// --------------------------------------------------
|
|
byte[] data = new byte[_image.Width * _image.Height * 4 + _image.Height];
|
|
|
|
int rowLength = _image.Width * 4 + 1;
|
|
|
|
for (int y = 0; y < _image.Height; y++)
|
|
{
|
|
data[y * rowLength] = 0;
|
|
|
|
Array.Copy(pixels, y * _image.Width * 4, data, y * rowLength + 1, _image.Width * 4);
|
|
}
|
|
// --------------------------------------------------
|
|
|
|
Adler32 adler32 = new Adler32();
|
|
adler32.Update(data);
|
|
|
|
using (MemoryStream tempStream = new MemoryStream())
|
|
{
|
|
int remainder = data.Length;
|
|
|
|
int blockCount;
|
|
if ((data.Length % MaxBlockSize) == 0)
|
|
{
|
|
blockCount = data.Length / MaxBlockSize;
|
|
}
|
|
else
|
|
{
|
|
blockCount = (data.Length / MaxBlockSize) + 1;
|
|
}
|
|
|
|
// Write headers
|
|
tempStream.WriteByte(0x78);
|
|
tempStream.WriteByte(0xDA);
|
|
|
|
for (int i = 0; i < blockCount; i++)
|
|
{
|
|
// Write the length
|
|
ushort length = (ushort)((remainder < MaxBlockSize) ? remainder : MaxBlockSize);
|
|
|
|
if (length == remainder)
|
|
{
|
|
tempStream.WriteByte(0x01);
|
|
}
|
|
else
|
|
{
|
|
tempStream.WriteByte(0x00);
|
|
}
|
|
|
|
tempStream.Write(BitConverter.GetBytes(length), 0, 2);
|
|
|
|
// Write one's compliment of length
|
|
tempStream.Write(BitConverter.GetBytes((ushort)~length), 0, 2);
|
|
|
|
// Write blocks
|
|
tempStream.Write(data, (int)(i * MaxBlockSize), length);
|
|
|
|
// Next block
|
|
remainder -= MaxBlockSize;
|
|
}
|
|
|
|
WriteInteger(tempStream, (int)adler32.Value);
|
|
|
|
tempStream.Seek(0, SeekOrigin.Begin);
|
|
|
|
byte[] zipData = new byte[tempStream.Length];
|
|
tempStream.Read(zipData, 0, (int)tempStream.Length);
|
|
|
|
WriteChunk(PngChunkTypes.Data, zipData);
|
|
}
|
|
}
|
|
|
|
private byte[] ConvertPixelArrayToByteArray(Pixel[] a)
|
|
{
|
|
byte[] b = new byte[a.Length * 4];
|
|
|
|
int indx = 0;
|
|
Pixel p;
|
|
for (uint i = 0; i < a.Length; i++)
|
|
{
|
|
p = a[i];
|
|
b[indx] = p.R;
|
|
indx++;
|
|
b[indx] = p.G;
|
|
indx++;
|
|
b[indx] = p.B;
|
|
indx++;
|
|
b[indx] = p.A;
|
|
indx++;
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
private void WriteDataChunks()
|
|
{
|
|
byte[] pixels = ConvertPixelArrayToByteArray(_image.Data);
|
|
|
|
byte[] data = new byte[_image.Width * _image.Height * 4 + _image.Height];
|
|
|
|
int rowLength = _image.Width * 4 + 1;
|
|
|
|
for (int y = 0; y < _image.Height; y++)
|
|
{
|
|
byte compression = 0;
|
|
if (y > 0)
|
|
{
|
|
compression = 2;
|
|
}
|
|
data[y * rowLength] = compression;
|
|
|
|
for (int x = 0; x < _image.Width; x++)
|
|
{
|
|
// Calculate the offset for the new array.
|
|
int dataOffset = y * rowLength + x * 4 + 1;
|
|
|
|
// Calculate the offset for the original pixel array.
|
|
int pixelOffset = (y * _image.Width + x) * 4;
|
|
|
|
data[dataOffset + 0] = pixels[pixelOffset + 0];
|
|
data[dataOffset + 1] = pixels[pixelOffset + 1];
|
|
data[dataOffset + 2] = pixels[pixelOffset + 2];
|
|
data[dataOffset + 3] = pixels[pixelOffset + 3];
|
|
|
|
if (y > 0)
|
|
{
|
|
int lastOffset = ((y - 1) * _image.Width + x) * 4;
|
|
|
|
data[dataOffset + 0] -= pixels[lastOffset + 0];
|
|
data[dataOffset + 1] -= pixels[lastOffset + 1];
|
|
data[dataOffset + 2] -= pixels[lastOffset + 2];
|
|
data[dataOffset + 3] -= pixels[lastOffset + 3];
|
|
}
|
|
}
|
|
}
|
|
|
|
byte[] buffer = null;
|
|
int bufferLength = 0;
|
|
|
|
MemoryStream memoryStream = null;
|
|
try
|
|
{
|
|
memoryStream = new MemoryStream();
|
|
using (DeflaterOutputStream zStream = new DeflaterOutputStream(memoryStream))
|
|
{
|
|
memoryStream = null;
|
|
|
|
zStream.Write(data, 0, data.Length);
|
|
zStream.Flush();
|
|
zStream.Finish();
|
|
|
|
bufferLength = (int)memoryStream.Length;
|
|
buffer = memoryStream.GetBuffer();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (memoryStream != null)
|
|
{
|
|
memoryStream.Dispose();
|
|
}
|
|
}
|
|
|
|
int numChunks = bufferLength / MaxBlockSize;
|
|
|
|
if (bufferLength % MaxBlockSize != 0)
|
|
{
|
|
numChunks++;
|
|
}
|
|
|
|
for (int i = 0; i < numChunks; i++)
|
|
{
|
|
int length = bufferLength - i * MaxBlockSize;
|
|
|
|
if (length > MaxBlockSize)
|
|
{
|
|
length = MaxBlockSize;
|
|
}
|
|
|
|
WriteChunk(PngChunkTypes.Data, buffer, i * MaxBlockSize, length);
|
|
}
|
|
}
|
|
|
|
private void WriteEndChunk()
|
|
{
|
|
WriteChunk(PngChunkTypes.End, null);
|
|
}
|
|
|
|
private void WriteHeaderChunk(PngHeader header)
|
|
{
|
|
byte[] chunkData = new byte[13];
|
|
|
|
WriteInteger(chunkData, 0, header.Width);
|
|
WriteInteger(chunkData, 4, header.Height);
|
|
|
|
chunkData[8] = header.BitDepth;
|
|
chunkData[9] = header.ColorType;
|
|
chunkData[10] = header.CompressionMethod;
|
|
chunkData[11] = header.FilterMethod;
|
|
chunkData[12] = header.InterlaceMethod;
|
|
|
|
WriteChunk(PngChunkTypes.Header, chunkData);
|
|
}
|
|
|
|
private void WriteChunk(string type, byte[] data)
|
|
{
|
|
WriteChunk(type, data, 0, data != null ? data.Length : 0);
|
|
}
|
|
|
|
private void WriteChunk(string type, byte[] data, int offset, int length)
|
|
{
|
|
WriteInteger(_stream, length);
|
|
|
|
byte[] typeArray = new byte[4];
|
|
typeArray[0] = (byte)type[0];
|
|
typeArray[1] = (byte)type[1];
|
|
typeArray[2] = (byte)type[2];
|
|
typeArray[3] = (byte)type[3];
|
|
|
|
_stream.Write(typeArray, 0, 4);
|
|
|
|
if (data != null)
|
|
{
|
|
_stream.Write(data, offset, length);
|
|
}
|
|
|
|
Crc32 crc32 = new Crc32();
|
|
crc32.Update(typeArray);
|
|
|
|
if (data != null)
|
|
{
|
|
crc32.Update(data, offset, length);
|
|
}
|
|
|
|
WriteInteger(_stream, (uint)crc32.Value);
|
|
}
|
|
|
|
private static void WriteInteger(byte[] data, int offset, int value)
|
|
{
|
|
byte[] buffer = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(buffer);
|
|
Array.Copy(buffer, 0, data, offset, 4);
|
|
}
|
|
|
|
private static void WriteInteger(Stream stream, int value)
|
|
{
|
|
byte[] buffer = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(buffer);
|
|
|
|
stream.Write(buffer, 0, 4);
|
|
}
|
|
|
|
private static void WriteInteger(Stream stream, uint value)
|
|
{
|
|
byte[] buffer = BitConverter.GetBytes(value);
|
|
|
|
Array.Reverse(buffer);
|
|
|
|
stream.Write(buffer, 0, 4);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Decoder
|
|
private class PngDecoder
|
|
{
|
|
private static readonly Dictionary<int, PngColorTypeInformation> _colorTypes = new Dictionary<int, PngColorTypeInformation>();
|
|
private Stream _stream;
|
|
private PngHeader _header;
|
|
|
|
static PngDecoder()
|
|
{
|
|
_colorTypes.Add(0,
|
|
new PngColorTypeInformation(1, new int[] { 1, 2, 4, 8 },
|
|
(p, a) => new GrayscaleReader(false)));
|
|
|
|
_colorTypes.Add(2,
|
|
new PngColorTypeInformation(3, new int[] { 8 },
|
|
(p, a) => new TrueColorReader(false)));
|
|
|
|
_colorTypes.Add(3,
|
|
new PngColorTypeInformation(1, new int[] { 1, 2, 4, 8 },
|
|
(p, a) => new PaletteIndexReader(p, a)));
|
|
|
|
_colorTypes.Add(4,
|
|
new PngColorTypeInformation(2, new int[] { 8 },
|
|
(p, a) => new GrayscaleReader(true)));
|
|
|
|
_colorTypes.Add(6,
|
|
new PngColorTypeInformation(4, new int[] { 8 },
|
|
(p, a) => new TrueColorReader(true)));
|
|
}
|
|
|
|
#region IImageDecoder Members
|
|
|
|
/// <summary>
|
|
/// Gets the size of the header for this image type.
|
|
/// </summary>
|
|
/// <value>The size of the header.</value>
|
|
public int HeaderSize
|
|
{
|
|
get { return 8; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates if the image decoder supports the specified
|
|
/// file extension.
|
|
/// </summary>
|
|
/// <param name="extension">The file extension.</param>
|
|
/// <returns>
|
|
/// <c>true</c>, if the decoder supports the specified
|
|
/// extensions; otherwise <c>false</c>.
|
|
/// </returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="extension"/>
|
|
/// is null (Nothing in Visual Basic).</exception>
|
|
/// <exception cref="ArgumentException"><paramref name="extension"/> is a string
|
|
/// of length zero or contains only blanks.</exception>
|
|
public bool IsSupportedFileExtension(string extension)
|
|
{
|
|
string extensionAsUpper = extension.ToUpper(System.Globalization.CultureInfo.CurrentCulture);
|
|
return extensionAsUpper == "PNG";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates if the image decoder supports the specified
|
|
/// file header.
|
|
/// </summary>
|
|
/// <param name="header">The file header.</param>
|
|
/// <returns>
|
|
/// <c>true</c>, if the decoder supports the specified
|
|
/// file header; otherwise <c>false</c>.
|
|
/// </returns>
|
|
/// <exception cref="ArgumentNullException"><paramref name="header"/>
|
|
/// is null (Nothing in Visual Basic).</exception>
|
|
public bool IsSupportedFileFormat(byte[] header)
|
|
{
|
|
bool isPng = false;
|
|
|
|
if (header.Length >= 8)
|
|
{
|
|
isPng =
|
|
header[0] == 0x89 &&
|
|
header[1] == 0x50 && // P
|
|
header[2] == 0x4E && // N
|
|
header[3] == 0x47 && // G
|
|
header[4] == 0x0D && // CR
|
|
header[5] == 0x0A && // LF
|
|
header[6] == 0x1A && // EOF
|
|
header[7] == 0x0A; // LF
|
|
}
|
|
|
|
return isPng;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decodes the image from the specified stream and sets
|
|
/// the data to image.
|
|
/// </summary>
|
|
/// <param name="image">The image, where the data should be set to.
|
|
/// Cannot be null (Nothing in Visual Basic).</param>
|
|
/// <param name="stream">The stream, where the image should be
|
|
/// decoded from. Cannot be null (Nothing in Visual Basic).</param>
|
|
/// <exception cref="ArgumentNullException">
|
|
/// <para><paramref name="image"/> is null (Nothing in Visual Basic).</para>
|
|
/// <para>- or -</para>
|
|
/// <para><paramref name="stream"/> is null (Nothing in Visual Basic).</para>
|
|
/// </exception>
|
|
public Image Decode(Stream stream)
|
|
{
|
|
_stream = stream;
|
|
_stream.Seek(8, SeekOrigin.Current);
|
|
|
|
bool isEndChunckReached = false;
|
|
|
|
PngChunk currentChunk = null;
|
|
|
|
byte[] palette = null;
|
|
byte[] paletteAlpha = null;
|
|
|
|
using (MemoryStream dataStream = new MemoryStream())
|
|
{
|
|
while ((currentChunk = ReadChunk()) != null)
|
|
{
|
|
if (isEndChunckReached)
|
|
{
|
|
throw new Exception("Image does not end with end chunk.");
|
|
}
|
|
|
|
if (currentChunk.Type == PngChunkTypes.Header)
|
|
{
|
|
ReadHeaderChunk(currentChunk.Data);
|
|
|
|
ValidateHeader();
|
|
}
|
|
else if (currentChunk.Type == PngChunkTypes.Physical)
|
|
{
|
|
ReadPhysicalChunk(currentChunk.Data);
|
|
}
|
|
else if (currentChunk.Type == PngChunkTypes.Data)
|
|
{
|
|
dataStream.Write(currentChunk.Data, 0, currentChunk.Data.Length);
|
|
}
|
|
else if (currentChunk.Type == PngChunkTypes.Palette)
|
|
{
|
|
palette = currentChunk.Data;
|
|
}
|
|
else if (currentChunk.Type == PngChunkTypes.PaletteAlpha)
|
|
{
|
|
paletteAlpha = currentChunk.Data;
|
|
}
|
|
else if (currentChunk.Type == PngChunkTypes.Text)
|
|
{
|
|
ReadTextChunk(currentChunk.Data);
|
|
}
|
|
else if (currentChunk.Type == PngChunkTypes.End)
|
|
{
|
|
isEndChunckReached = true;
|
|
}
|
|
}
|
|
|
|
byte[] pixels = new byte[_header.Width * _header.Height * 4];
|
|
|
|
PngColorTypeInformation colorTypeInformation = _colorTypes[_header.ColorType];
|
|
|
|
if (colorTypeInformation != null)
|
|
{
|
|
ColorReader colorReader = colorTypeInformation.CreateColorReader(palette, paletteAlpha);
|
|
|
|
ReadScanlines(dataStream, pixels, colorReader, colorTypeInformation);
|
|
}
|
|
Image i = new Image(_header.Width, _header.Height);
|
|
int indx = 0;
|
|
byte r, g, b, a;
|
|
for (uint y = 0; y < i.Height; y++)
|
|
{
|
|
for (uint x = 0; x < i.Width; x++)
|
|
{
|
|
r = pixels[indx];
|
|
indx++;
|
|
g = pixels[indx];
|
|
indx++;
|
|
b = pixels[indx];
|
|
indx++;
|
|
a = pixels[indx];
|
|
indx++;
|
|
i.SetPixel(x, y, new Pixel(r, g, b, a));
|
|
}
|
|
}
|
|
pixels = null;
|
|
System.GC.Collect();
|
|
return i;
|
|
}
|
|
}
|
|
|
|
private void ReadPhysicalChunk(byte[] data)
|
|
{
|
|
Array.Reverse(data, 0, 4);
|
|
Array.Reverse(data, 4, 4);
|
|
|
|
//_image.DensityX = BitConverter.ToInt32(data, 0) / 39.3700787d;
|
|
//_image.DensityY = BitConverter.ToInt32(data, 4) / 39.3700787d;
|
|
}
|
|
|
|
private int CalculateScanlineLength(PngColorTypeInformation colorTypeInformation)
|
|
{
|
|
int scanlineLength = (_header.Width * _header.BitDepth * colorTypeInformation.ChannelsPerColor);
|
|
|
|
int amount = scanlineLength % 8;
|
|
if (amount != 0)
|
|
{
|
|
scanlineLength += 8 - amount;
|
|
}
|
|
|
|
return scanlineLength / 8;
|
|
}
|
|
|
|
private int CalculateScanlineStep(PngColorTypeInformation colorTypeInformation)
|
|
{
|
|
int scanlineStep = 1;
|
|
|
|
if (_header.BitDepth >= 8)
|
|
{
|
|
scanlineStep = (colorTypeInformation.ChannelsPerColor * _header.BitDepth) / 8;
|
|
}
|
|
|
|
return scanlineStep;
|
|
}
|
|
|
|
private void ReadScanlines(MemoryStream dataStream, byte[] pixels, ColorReader colorReader, PngColorTypeInformation colorTypeInformation)
|
|
{
|
|
dataStream.Position = 0;
|
|
|
|
int scanlineLength = CalculateScanlineLength(colorTypeInformation);
|
|
|
|
int scanlineStep = CalculateScanlineStep(colorTypeInformation);
|
|
|
|
byte[] lastScanline = new byte[scanlineLength];
|
|
byte[] currScanline = new byte[scanlineLength];
|
|
|
|
byte a = 0;
|
|
byte b = 0;
|
|
byte c = 0;
|
|
|
|
int row = 0, filter = 0, column = -1;
|
|
|
|
using (DeflaterInputStream compressedStream = new DeflaterInputStream(dataStream))
|
|
{
|
|
int readByte = 0;
|
|
while ((readByte = compressedStream.ReadByte()) >= 0)
|
|
{
|
|
if (column == -1)
|
|
{
|
|
filter = readByte;
|
|
|
|
column++;
|
|
}
|
|
else
|
|
{
|
|
currScanline[column] = (byte)readByte;
|
|
|
|
if (column >= scanlineStep)
|
|
{
|
|
a = currScanline[column - scanlineStep];
|
|
c = lastScanline[column - scanlineStep];
|
|
}
|
|
else
|
|
{
|
|
a = 0;
|
|
c = 0;
|
|
}
|
|
|
|
b = lastScanline[column];
|
|
|
|
if (filter == 1)
|
|
{
|
|
currScanline[column] = (byte)(currScanline[column] + a);
|
|
}
|
|
else if (filter == 2)
|
|
{
|
|
currScanline[column] = (byte)(currScanline[column] + b);
|
|
}
|
|
else if (filter == 3)
|
|
{
|
|
currScanline[column] = (byte)(currScanline[column] + (byte)Math.Floor((double)((a + b) / 2)));
|
|
}
|
|
else if (filter == 4)
|
|
{
|
|
currScanline[column] = (byte)(currScanline[column] + PaethPredicator(a, b, c));
|
|
}
|
|
|
|
column++;
|
|
|
|
if (column == scanlineLength)
|
|
{
|
|
colorReader.ReadScanline(currScanline, pixels, _header);
|
|
|
|
column = -1;
|
|
row++;
|
|
|
|
Swap(ref currScanline, ref lastScanline);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Swaps two references.
|
|
/// </summary>
|
|
/// <typeparam name="TRef">The type of the references to swap.</typeparam>
|
|
/// <param name="lhs">The first reference.</param>
|
|
/// <param name="rhs">The second reference.</param>
|
|
private static void Swap<TRef>(ref TRef lhs, ref TRef rhs) where TRef : class
|
|
{
|
|
TRef tmp = lhs;
|
|
lhs = rhs;
|
|
rhs = tmp;
|
|
}
|
|
|
|
private static byte PaethPredicator(byte a, byte b, byte c)
|
|
{
|
|
byte predicator = 0;
|
|
|
|
int p = a + b - c;
|
|
int pa = Math.Abs(p - a);
|
|
int pb = Math.Abs(p - b);
|
|
int pc = Math.Abs(p - c);
|
|
|
|
if (pa <= pb && pa <= pc)
|
|
{
|
|
predicator = a;
|
|
}
|
|
else if (pb <= pc)
|
|
{
|
|
predicator = b;
|
|
}
|
|
else
|
|
{
|
|
predicator = c;
|
|
}
|
|
|
|
return predicator;
|
|
}
|
|
|
|
private void ReadTextChunk(byte[] data)
|
|
{
|
|
//int zeroIndex = 0;
|
|
|
|
//for (int i = 0; i < data.Length; i++)
|
|
//{
|
|
// if (data[i] == (byte)0)
|
|
// {
|
|
// zeroIndex = i;
|
|
// break;
|
|
// }
|
|
//}
|
|
|
|
//string name = Encoding.Unicode.GetString(data, 0, zeroIndex);
|
|
//string value = Encoding.Unicode.GetString(data, zeroIndex + 1, data.Length - zeroIndex - 1);
|
|
|
|
//_image.Properties.Add(new ImageProperty(name, value));
|
|
}
|
|
|
|
private void ReadHeaderChunk(byte[] data)
|
|
{
|
|
_header = new PngHeader();
|
|
|
|
Array.Reverse(data, 0, 4);
|
|
Array.Reverse(data, 4, 4);
|
|
|
|
_header.Width = BitConverter.ToInt32(data, 0);
|
|
_header.Height = BitConverter.ToInt32(data, 4);
|
|
|
|
_header.BitDepth = data[8];
|
|
_header.ColorType = data[9];
|
|
_header.FilterMethod = data[11];
|
|
_header.InterlaceMethod = data[12];
|
|
_header.CompressionMethod = data[10];
|
|
}
|
|
|
|
private void ValidateHeader()
|
|
{
|
|
if (!_colorTypes.ContainsKey(_header.ColorType))
|
|
{
|
|
throw new Exception("Color type is not supported or not valid.");
|
|
}
|
|
|
|
bool found = false;
|
|
foreach (int i in _colorTypes[_header.ColorType].SupportedBitDepths)
|
|
{
|
|
if (i == _header.BitDepth)
|
|
{
|
|
found = true;
|
|
continue;
|
|
}
|
|
}
|
|
if (!found)
|
|
{
|
|
throw new Exception("Bit depth is not supported or not valid.");
|
|
}
|
|
|
|
if (_header.FilterMethod != 0)
|
|
{
|
|
throw new Exception("The png specification only defines 0 as filter method.");
|
|
}
|
|
|
|
if (_header.InterlaceMethod != 0)
|
|
{
|
|
throw new Exception("Interlacing is not supported.");
|
|
}
|
|
}
|
|
|
|
private PngChunk ReadChunk()
|
|
{
|
|
PngChunk chunk = new PngChunk();
|
|
|
|
if (ReadChunkLength(chunk) == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
byte[] typeBuffer = ReadChunkType(chunk);
|
|
|
|
ReadChunkData(chunk);
|
|
ReadChunkCrc(chunk, typeBuffer);
|
|
|
|
return chunk;
|
|
}
|
|
|
|
private void ReadChunkCrc(PngChunk chunk, byte[] typeBuffer)
|
|
{
|
|
// byte[] crcBuffer = new byte[4];
|
|
|
|
_stream.Position += 4;
|
|
// if (numBytes >= 1 && numBytes <= 3)
|
|
// {
|
|
// throw new Exception("Image stream is not valid!");
|
|
// }
|
|
|
|
// Array.Reverse(crcBuffer);
|
|
|
|
// chunk.Crc = BitConverter.ToUInt32(crcBuffer, 0);
|
|
|
|
// Crc32 crc = new Crc32();
|
|
// crc.Update(typeBuffer);
|
|
// crc.Update(chunk.Data);
|
|
|
|
// if (crc.Value != chunk.Crc)
|
|
// {
|
|
// throw new Exception("CRC Error. PNG Image chunk is corrupt!");
|
|
// }
|
|
}
|
|
|
|
private void ReadChunkData(PngChunk chunk)
|
|
{
|
|
chunk.Data = new byte[chunk.Length];
|
|
|
|
_stream.Read(chunk.Data, 0, chunk.Length);
|
|
}
|
|
|
|
private byte[] ReadChunkType(PngChunk chunk)
|
|
{
|
|
byte[] typeBuffer = new byte[4];
|
|
|
|
int numBytes = _stream.Read(typeBuffer, 0, 4);
|
|
if (numBytes >= 1 && numBytes <= 3)
|
|
{
|
|
throw new Exception("Image stream is not valid!");
|
|
}
|
|
|
|
char[] chars = new char[4];
|
|
chars[0] = (char)typeBuffer[0];
|
|
chars[1] = (char)typeBuffer[1];
|
|
chars[2] = (char)typeBuffer[2];
|
|
chars[3] = (char)typeBuffer[3];
|
|
|
|
chunk.Type = new string(chars);
|
|
|
|
return typeBuffer;
|
|
}
|
|
|
|
private int ReadChunkLength(PngChunk chunk)
|
|
{
|
|
byte[] lengthBuffer = new byte[4];
|
|
|
|
int numBytes = _stream.Read(lengthBuffer, 0, 4);
|
|
if (numBytes >= 1 && numBytes <= 3)
|
|
{
|
|
throw new Exception("Image stream is not valid!");
|
|
}
|
|
|
|
Array.Reverse(lengthBuffer);
|
|
|
|
chunk.Length = BitConverter.ToInt32(lengthBuffer, 0);
|
|
|
|
return numBytes;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region ColorReaders
|
|
|
|
#region ColorReader
|
|
/// <summary>
|
|
/// Interface for color readers, which are responsible for reading
|
|
/// different color formats from a png file.
|
|
/// </summary>
|
|
private abstract class ColorReader
|
|
{
|
|
protected byte[] ToArrayByBitsLength(byte[] bytes, int bits)
|
|
{
|
|
byte[] result = null;
|
|
if (bits < 8)
|
|
{
|
|
result = new byte[bytes.Length * 8 / bits];
|
|
int factor = (int)Math.Pow(2, bits) - 1;
|
|
int mask = (0xFF >> (8 - bits));
|
|
int resultOffset = 0;
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
{
|
|
for (int shift = 0; shift < 8; shift += bits)
|
|
{
|
|
int colorIndex = (((bytes[i]) >> (8 - bits - shift)) & mask) * (255 / factor);
|
|
result[resultOffset] = (byte)colorIndex;
|
|
resultOffset++;
|
|
}
|
|
}
|
|
}
|
|
else { result = bytes; }
|
|
return result;
|
|
}
|
|
|
|
public abstract void ReadScanline(byte[] scanline, byte[] pixels, PngHeader header);
|
|
}
|
|
#endregion
|
|
|
|
#region GrayscaleReader
|
|
/// <summary>
|
|
/// Color reader for reading grayscale colors from a PNG file.
|
|
/// </summary>
|
|
private sealed class GrayscaleReader : ColorReader
|
|
{
|
|
private int _row;
|
|
private bool _useAlpha;
|
|
public GrayscaleReader(bool useAlpha)
|
|
{
|
|
_useAlpha = useAlpha;
|
|
}
|
|
public override void ReadScanline(byte[] scanline, byte[] pixels, PngHeader header)
|
|
{
|
|
int offset = 0;
|
|
byte[] newScanline = ToArrayByBitsLength(scanline, header.BitDepth);
|
|
if (_useAlpha)
|
|
{
|
|
for (int x = 0; x < header.Width / 2; x++)
|
|
{
|
|
offset = (_row * header.Width + x) * 4;
|
|
pixels[offset + 0] = newScanline[x * 2];
|
|
pixels[offset + 1] = newScanline[x * 2];
|
|
pixels[offset + 2] = newScanline[x * 2];
|
|
pixels[offset + 3] = newScanline[x * 2 + 1];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int x = 0; x < header.Width; x++)
|
|
{
|
|
offset = (_row * header.Width + x) * 4;
|
|
pixels[offset + 0] = newScanline[x];
|
|
pixels[offset + 1] = newScanline[x];
|
|
pixels[offset + 2] = newScanline[x];
|
|
pixels[offset + 3] = (byte)255;
|
|
}
|
|
}
|
|
_row++;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region PaletteIndexReader
|
|
/// <summary>
|
|
/// A color reader for reading palette indices from the PNG file.
|
|
/// </summary>
|
|
private sealed class PaletteIndexReader : ColorReader
|
|
{
|
|
private int _row;
|
|
private byte[] _palette;
|
|
private byte[] _paletteAlpha;
|
|
public PaletteIndexReader(byte[] palette, byte[] paletteAlpha)
|
|
{
|
|
_palette = palette;
|
|
_paletteAlpha = paletteAlpha;
|
|
}
|
|
public override void ReadScanline(byte[] scanline, byte[] pixels, PngHeader header)
|
|
{
|
|
byte[] newScanline = ToArrayByBitsLength(scanline, header.BitDepth);
|
|
|
|
int offset = 0, index = 0;
|
|
|
|
if (_paletteAlpha != null && _paletteAlpha.Length > 0)
|
|
{
|
|
for (int i = 0; i < header.Width; i++)
|
|
{
|
|
index = newScanline[i];
|
|
offset = (_row * header.Width + i) * 4;
|
|
pixels[offset + 0] = _palette[index * 3];
|
|
pixels[offset + 1] = _palette[index * 3 + 1];
|
|
pixels[offset + 2] = _palette[index * 3 + 2];
|
|
pixels[offset + 3] = _paletteAlpha.Length > index ? _paletteAlpha[index] : (byte)255;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < header.Width; i++)
|
|
{
|
|
index = newScanline[i];
|
|
offset = (_row * header.Width + i) * 4;
|
|
pixels[offset + 0] = _palette[index * 3];
|
|
pixels[offset + 1] = _palette[index * 3 + 1];
|
|
pixels[offset + 2] = _palette[index * 3 + 2];
|
|
pixels[offset + 3] = (byte)255;
|
|
}
|
|
}
|
|
_row++;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region TrueColorReader
|
|
/// <summary>
|
|
/// Color reader for reading truecolors from a PNG file. Only colors
|
|
/// with 24 or 32 bit (3 or 4 bytes) per pixel are supported at the moment.
|
|
/// </summary>
|
|
sealed class TrueColorReader : ColorReader
|
|
{
|
|
private int _row;
|
|
private bool _useAlpha;
|
|
public TrueColorReader(bool useAlpha)
|
|
{
|
|
_useAlpha = useAlpha;
|
|
}
|
|
public override void ReadScanline(byte[] scanline, byte[] pixels, PngHeader header)
|
|
{
|
|
int offset = 0;
|
|
byte[] newScanline = ToArrayByBitsLength(scanline, header.BitDepth);
|
|
if (_useAlpha)
|
|
{
|
|
Array.Copy(newScanline, 0, pixels, _row * header.Width * 4, newScanline.Length);
|
|
}
|
|
else
|
|
{
|
|
for (int x = 0; x < newScanline.Length / 3; x++)
|
|
{
|
|
offset = (_row * header.Width + x) * 4;
|
|
pixels[offset + 0] = newScanline[x * 3];
|
|
pixels[offset + 1] = newScanline[x * 3 + 1];
|
|
pixels[offset + 2] = newScanline[x * 3 + 2];
|
|
pixels[offset + 3] = (byte)255;
|
|
}
|
|
}
|
|
_row++;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region PngChunkTypes
|
|
/// <summary>
|
|
/// Contains a list of possible chunk type identifier.
|
|
/// </summary>
|
|
private static class PngChunkTypes
|
|
{
|
|
/// <summary>
|
|
/// The first chunk in a png file. Can only exists once. Contains
|
|
/// common information like the width and the height of the image or
|
|
/// the used compression method.
|
|
/// </summary>
|
|
public const string Header = "IHDR";
|
|
/// <summary>
|
|
/// The PLTE chunk contains from 1 to 256 palette entries, each a three byte
|
|
/// series in the RGB format.
|
|
/// </summary>
|
|
public const string Palette = "PLTE";
|
|
/// <summary>
|
|
/// The IDAT chunk contains the actual image data. The image can contains more
|
|
/// than one chunk of this type. All chunks together are the whole image.
|
|
/// </summary>
|
|
public const string Data = "IDAT";
|
|
/// <summary>
|
|
/// This chunk must appear last. It marks the end of the PNG datastream.
|
|
/// The chunk's data field is empty.
|
|
/// </summary>
|
|
public const string End = "IEND";
|
|
/// <summary>
|
|
/// This chunk specifies that the image uses simple transparency:
|
|
/// either alpha values associated with palette entries (for indexed-color images)
|
|
/// or a single transparent color (for grayscale and truecolor images).
|
|
/// </summary>
|
|
public const string PaletteAlpha = "tRNS";
|
|
/// <summary>
|
|
/// Textual information that the encoder wishes to record with the image can be stored in
|
|
/// tEXt chunks. Each tEXt chunk contains a keyword and a text string.
|
|
/// </summary>
|
|
public const string Text = "tEXt";
|
|
/// <summary>
|
|
/// This chunk specifies the relationship between the image samples and the desired
|
|
/// display output intensity.
|
|
/// </summary>
|
|
public const string Gamma = "gAMA";
|
|
/// <summary>
|
|
/// The pHYs chunk specifies the intended pixel size or aspect ratio for display of the image.
|
|
/// </summary>
|
|
public const string Physical = "pHYs";
|
|
}
|
|
#endregion
|
|
|
|
#region PngChunk
|
|
/// <summary>
|
|
/// Stores header information about a chunk.
|
|
/// </summary>
|
|
private sealed class PngChunk
|
|
{
|
|
/// <summary>
|
|
/// An unsigned integer giving the number of bytes in the chunk's
|
|
/// data field. The length counts only the data field, not itself,
|
|
/// the chunk type code, or the CRC. Zero is a valid length
|
|
/// </summary>
|
|
public int Length;
|
|
/// <summary>
|
|
/// A chunk type as string with 4 chars.
|
|
/// </summary>
|
|
public string Type;
|
|
/// <summary>
|
|
/// The data bytes appropriate to the chunk type, if any.
|
|
/// This field can be of zero length.
|
|
/// </summary>
|
|
public byte[] Data;
|
|
///// <summary>
|
|
///// A CRC (Cyclic Redundancy Check) calculated on the preceding bytes in the chunk,
|
|
///// including the chunk type code and chunk data fields, but not including the length field.
|
|
///// The CRC is always present, even for chunks containing no data
|
|
///// </summary>
|
|
//public uint Crc;
|
|
}
|
|
#endregion
|
|
|
|
#region PngColorTypeInformation
|
|
/// <summary>
|
|
/// Contains information that are required when loading a png with a specific color type.
|
|
/// </summary>
|
|
private sealed class PngColorTypeInformation
|
|
{
|
|
/// <summary>
|
|
/// Gets an array with the bit depths that are supported for the color type
|
|
/// where this object is created for.
|
|
/// </summary>
|
|
/// <value>The supported bit depths that can be used in combination with this color type.</value>
|
|
public int[] SupportedBitDepths { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets a function that is used the create the color reader for the color type where
|
|
/// this object is created for.
|
|
/// </summary>
|
|
/// <value>The factory function to create the color type.</value>
|
|
public Func<byte[], byte[], ColorReader> ScanlineReaderFactory { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets a factor that is used when iterating through the scanlines.
|
|
/// </summary>
|
|
/// <value>The scanline factor.</value>
|
|
public int ChannelsPerColor { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="PngColorTypeInformation"/> class with
|
|
/// the scanline factory, the function to create the color reader and the supported bit depths.
|
|
/// </summary>
|
|
/// <param name="scanlineFactor">The scanline factor.</param>
|
|
/// <param name="supportedBitDepths">The supported bit depths.</param>
|
|
/// <param name="scanlineReaderFactory">The factory to create the color reader.</param>
|
|
public PngColorTypeInformation(int scanlineFactor, int[] supportedBitDepths, Func<byte[], byte[], ColorReader> scanlineReaderFactory)
|
|
{
|
|
ChannelsPerColor = scanlineFactor;
|
|
ScanlineReaderFactory = scanlineReaderFactory;
|
|
|
|
SupportedBitDepths = supportedBitDepths;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates the color reader for the color type where this object is create for.
|
|
/// </summary>
|
|
/// <param name="palette">The palette of the image. Can be null when no palette is used.</param>
|
|
/// <param name="paletteAlpha">The alpha palette of the image. Can be null when
|
|
/// no palette is used for the image or when the image has no alpha.</param>
|
|
/// <returns>The color reader for the image.</returns>
|
|
public ColorReader CreateColorReader(byte[] palette, byte[] paletteAlpha)
|
|
{
|
|
return ScanlineReaderFactory(palette, paletteAlpha);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region PngHeader
|
|
/// <summary>
|
|
/// Represents the png header chunk.
|
|
/// </summary>
|
|
private sealed class PngHeader
|
|
{
|
|
/// <summary>
|
|
/// The dimension in x-direction of the image in pixels.
|
|
/// </summary>
|
|
public int Width;
|
|
/// <summary>
|
|
/// The dimension in y-direction of the image in pixels.
|
|
/// </summary>
|
|
public int Height;
|
|
/// <summary>
|
|
/// Bit depth is a single-byte integer giving the number of bits per sample
|
|
/// or per palette index (not per pixel). Valid values are 1, 2, 4, 8, and 16,
|
|
/// although not all values are allowed for all color types.
|
|
/// </summary>
|
|
public byte BitDepth;
|
|
/// <summary>
|
|
/// Color type is a integer that describes the interpretation of the
|
|
/// image data. Color type codes represent sums of the following values:
|
|
/// 1 (palette used), 2 (color used), and 4 (alpha channel used).
|
|
/// </summary>
|
|
public byte ColorType;
|
|
/// <summary>
|
|
/// Indicates the method used to compress the image data. At present,
|
|
/// only compression method 0 (deflate/inflate compression with a sliding
|
|
/// window of at most 32768 bytes) is defined.
|
|
/// </summary>
|
|
public byte CompressionMethod;
|
|
/// <summary>
|
|
/// Indicates the preprocessing method applied to the image
|
|
/// data before compression. At present, only filter method 0
|
|
/// (adaptive filtering with five basic filter types) is defined.
|
|
/// </summary>
|
|
public byte FilterMethod;
|
|
/// <summary>
|
|
/// Indicates the transmission order of the image data.
|
|
/// Two values are currently defined: 0 (no interlace) or 1 (Adam7 interlace).
|
|
/// </summary>
|
|
public byte InterlaceMethod;
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
}
|