//http://en.wikipedia.org/wiki/APNG
//From https://www.codeproject.com/Articles/36179/APNG-Viewer
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Drawing;
using System.IO;
namespace Toolbox.Library
{
internal class APNGUtility
{
/// <summary>
/// Attempts to read count bytes of data from the supplied stream.
/// </summary>
/// <param name="stream">The stream to read from</param>
/// <param name="count">The number of bytes to read</param>
/// <returns>A byte[] containing the data or null if an error occurred</returns>
public static byte[] ReadStream(Stream stream, uint count)
{
byte[] bytes = new byte[count];
try
{
stream.Read(bytes, 0, (int)count);
}
catch (IOException)
{
throw;
}
return bytes;
}
/// <summary>
/// Attempts to parse an unsigned integer value from the array of bytes
/// provided. The most significant byte of the unsigned integer is
/// parsed from the first element in the array.
/// </summary>
/// <param name="buffer">An array of bytes from which the value is to be extracted</param>
/// <param name="uintLengthInBytes">The number of bytes to parse (must be <= sizeof(uint))</param>
/// <returns>The extracted unsigned integer returned in a uint</returns>
public static uint ParseUint(byte[] buffer, int uintLengthInBytes)
{
int offset = 0;
return ParseUint(buffer, uintLengthInBytes, ref offset);
}
/// <summary>
/// Attempts to parse an unsigned integer value from the array of bytes
/// provided. The most significant byte of the unsigned integer is
/// parsed from the specified offset in the array.
/// </summary>
/// <param name="buffer">An array of bytes from which the value is to be extracted</param>
/// <param name="uintLengthInBytes">The number of bytes to parse (must be <= sizeof(uint))</param>
/// <param name="offset">The offset in the array of bytes where parsing shall begin</param>
/// <returns>The extracted unsigned integer returned in a uint</returns>
public static uint ParseUint(byte[] buffer, int uintLengthInBytes, ref int offset)
{
uint value = 0;
if (uintLengthInBytes > sizeof(uint))
throw new ArgumentException(
String.Format("Function can only be used to parse up to {0} bytes from the buffer",
sizeof(uint)));
if (buffer.Length - offset < uintLengthInBytes)
throw new ArgumentException(
String.Format("buffer is not long enough to extract {0} bytes at offset {1}",
sizeof(uint), offset));
int i, j;
for (i = offset + uintLengthInBytes - 1, j = 0; i >= offset; i--, j++)
value |= (uint)(buffer[i] << (8 * j));
offset += uintLengthInBytes;
return value;
}
}
internal class APNGHeader
{
/// <summary>
/// The first 8 bytes of an APNG encoding
/// </summary>
static byte[] expectedSignature = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
/// <summary>
/// The signature parsed from the input stream
/// </summary>
private byte[] signature;
/// <summary>
/// Default constructor
/// </summary>
public APNGHeader()
{
signature = null;
}
/// <summary>
/// Attempts to read an APNG Header chunk from the supplied stream.
/// </summary>
/// <param name="stream">The stream containing the APNG Header</param>
public void Read(Stream stream)
{
// Stream must be readable
if (!stream.CanRead)
throw new ArgumentException("Stream is not readable");
// Read the signature
try
{
signature = APNGUtility.ReadStream(stream, 8);
}
catch (Exception)
{
// Re-throw any exceptions
throw;
}
// Test signature for validity
if (signature.Length == expectedSignature.Length)
{
for (int i = 0; i < expectedSignature.Length; i++)
{
// Invalid signature
if (expectedSignature[i] != signature[i])
throw new ApplicationException("APNG signature not found.");
}
}
else
// Invalid signature
throw new ApplicationException("APNG signature not found.");
}
}
internal class MENDChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "MEND";
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public MENDChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
}
internal class TERMChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "TERM";
private uint terminationAction;
private uint actionAfterTermination;
private uint delay;
private uint iterationMax;
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public TERMChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
/// <summary>
/// Extracts various fields specific to this chunk from the APNG's
/// data field
/// </summary>
/// <param name="chunkData">An array of bytes representing the APNG's data field</param>
protected override void ParseData(byte[] chunkData)
{
int offset = 0;
terminationAction = APNGUtility.ParseUint(chunkData, 1, ref offset);
// If the data length is > 1 then read 9 more bytes
if (chunkData.Length > 1)
{
actionAfterTermination = APNGUtility.ParseUint(chunkData, 1, ref offset);
delay = APNGUtility.ParseUint(chunkData, 4, ref offset);
iterationMax = APNGUtility.ParseUint(chunkData, 4, ref offset);
}
}
}
internal class BKGDChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "bKGD";
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public BKGDChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
}
internal class BACKChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "BACK";
private uint redBackground;
private uint greenBackground;
private uint blueBackground;
private uint mandatoryBackground;
private uint backgroundImageId;
private uint backgroundTiling;
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public BACKChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
/// <summary>
/// Extracts various fields specific to this chunk from the APNG's
/// data field
/// </summary>
/// <param name="chunkData">An array of bytes representing the APNG's data field</param>
protected override void ParseData(byte[] chunkData)
{
int offset = 0;
redBackground = APNGUtility.ParseUint(chunkData, 2, ref offset);
greenBackground = APNGUtility.ParseUint(chunkData, 2, ref offset);
blueBackground = APNGUtility.ParseUint(chunkData, 2, ref offset);
// If the data length is > 6 then read 1 more byte
if (chunkData.Length > 6)
{
mandatoryBackground = APNGUtility.ParseUint(chunkData, 1, ref offset);
}
// If the data length is > 7 then read 2 more bytes
if (chunkData.Length > 7)
{
backgroundImageId = APNGUtility.ParseUint(chunkData, 2, ref offset);
}
// If the data length is > 9 then read 1 more byte
if (chunkData.Length > 9)
{
backgroundTiling = APNGUtility.ParseUint(chunkData, 1, ref offset);
}
}
}
internal class IHDRChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "IHDR";
private uint width;
private uint height;
private uint bitDepth;
private uint colorType;
private uint compressionMethod;
private uint filterMethod;
private uint interlaceMethod;
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public IHDRChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
/// <summary>
/// Extracts various fields specific to this chunk from the APNG's
/// data field
/// </summary>
/// <param name="chunkData">An array of bytes representing the APNG's data field</param>
protected override void ParseData(byte[] chunkData)
{
int offset = 0;
width = APNGUtility.ParseUint(chunkData, 4, ref offset);
height = APNGUtility.ParseUint(chunkData, 4, ref offset);
bitDepth = APNGUtility.ParseUint(chunkData, 1, ref offset);
colorType = APNGUtility.ParseUint(chunkData, 1, ref offset);
compressionMethod = APNGUtility.ParseUint(chunkData, 1, ref offset);
filterMethod = APNGUtility.ParseUint(chunkData, 1, ref offset);
interlaceMethod = APNGUtility.ParseUint(chunkData, 1, ref offset);
}
}
internal class fcTLChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "fcTL";
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public fcTLChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
public bool IsEmpty()
{
return ChunkLength == 0;
}
}
internal class IENDChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "IEND";
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public IENDChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
}
internal class IDATChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "IDAT";
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public IDATChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
}
internal class fdATChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "fdAT";
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public fdATChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
}
internal class acTLChunk : APNGChunk
{
/// <summary>
/// The ASCII name of the APNG chunk
/// </summary>
public const String NAME = "acTL";
/// <summary>
/// The APNG frame width in pixels
/// </summary>
private uint frameWidth;
/// <summary>
/// The APNG frame height in pixels
/// </summary>
private uint frameHeight;
///// <summary>
///// The APNG frame rate
///// </summary>
//private uint ticksPerSecond;
///// <summary>
///// The APNG layer count
///// </summary>
//private uint nominalLayerCount;
///// <summary>
///// The APNG frame count
///// </summary>
//private uint nominalFrameCount;
///// <summary>
///// The APNG play time
///// </summary>
//private uint nominalPlayTime;
///// <summary>
///// The APNG simplicity profile
///// </summary>
//private uint simplicityProfile;
/// <summary>
/// Constructor
/// </summary>
/// <param name="chunk">The APNG chunk containing the data for this specific chunk</param>
public acTLChunk(APNGChunk chunk)
: base(chunk, NAME)
{
}
/// <summary>
/// The APNG width in pixels
/// </summary>
public uint FrameWidth
{
get { return frameWidth; }
}
/// <summary>
/// The APNG height in pixels
/// </summary>
public uint FrameHeight
{
get { return frameHeight; }
}
/// <summary>
/// Extracts various fields specific to this chunk from the APNG's
/// data field
/// </summary>
/// <param name="chunkData">An array of bytes representing the APNG's data field</param>
protected override void ParseData(byte[] chunkData)
{
int offset = 0;
frameWidth = APNGUtility.ParseUint(chunkData, 4, ref offset);
frameHeight = APNGUtility.ParseUint(chunkData, 4, ref offset);
//ticksPerSecond = APNGUtility.ParseUint(chunkData, 4, ref offset);
//nominalLayerCount = APNGUtility.ParseUint(chunkData, 4, ref offset);
//nominalFrameCount = APNGUtility.ParseUint(chunkData, 4, ref offset);
//nominalPlayTime = APNGUtility.ParseUint(chunkData, 4, ref offset);
//simplicityProfile = APNGUtility.ParseUint(chunkData, 4, ref offset);
}
}
internal class APNGChunk
{
protected String error;
protected byte[] chunkLength;
protected byte[] chunkType;
protected byte[] chunkData;
protected byte[] chunkCRC;
protected uint calculatedCRC;
/// <summary>
/// Default constructor
/// </summary>
public APNGChunk()
{
chunkLength = chunkType = chunkData = chunkCRC = null;
error = "No Error";
}
/// <summary>
/// Constructor which takes an existing APNGChunk object and
/// verifies that its type matches that which is expected
/// </summary>
/// <param name="chunk">The APNGChunk to copy</param>
/// <param name="expectedType">The input APNGChunk expected type</param>
public APNGChunk(APNGChunk chunk, String expectedType)
{
// Copy the existing chunks members
chunkLength = chunk.chunkLength;
chunkType = chunk.chunkType;
chunkData = chunk.chunkData;
chunkCRC = chunk.chunkCRC;
// Verify the chunk type is as expected
if (ChunkType != expectedType)
throw new ArgumentException(
String.Format("Specified chunk type is not {0} as expected", expectedType));
// Parse the chunk's data
ParseData(chunkData);
}
/// <summary>
/// Extracts various fields specific to this chunk from the APNG's
/// data field
/// </summary>
/// <param name="chunkData">An array of bytes representing the APNG's data field</param>
protected virtual void ParseData(byte[] chunkData)
{
// Nothing specific to do here. Derived classes can override this
// to do specific field parsing.
}
/// <summary>
/// Gets the array of bytes which make up the APNG chunk. This includes:
/// o 4 bytes of the chunk's length
/// o 4 bytes of the chunk's type
/// o N bytes of the chunk's data
/// o 4 bytes of the chunk's CRC
/// </summary>
public byte[] Chunk
{
get
{
byte[] ba = new byte[chunkLength.Length +
chunkType.Length + chunkData.Length +
chunkCRC.Length];
chunkLength.CopyTo(ba, 0);
chunkType.CopyTo(ba, chunkLength.Length);
chunkData.CopyTo(ba, chunkLength.Length + chunkType.Length);
chunkCRC.CopyTo(ba, chunkLength.Length + chunkType.Length + chunkData.Length);
return ba;
}
}
/// <summary>
/// Gets the array of bytes which make up the chunk's data field
/// </summary>
public byte[] ChunkData
{
get
{
return chunkData;
}
}
/// <summary>
/// Gets chunk's type field as an string
/// </summary>
public String ChunkType
{
get
{
return new String(new char[] { (char)chunkType[0], (char)chunkType[1], (char)chunkType[2], (char)chunkType[3] });
}
set
{
chunkType = Encoding.ASCII.GetBytes(value);
byte[] newChunkData = new byte[chunkData.Length - 4];
Array.Copy(chunkData, 4, newChunkData, 0, newChunkData.Length);
chunkData = newChunkData;
chunkLength = BitConverter.GetBytes(chunkData.Length);
Array.Reverse(chunkLength);
uint crc = CRC.INITIAL_CRC;
crc = CRC.UpdateCRC(crc, chunkType);
crc = CRC.UpdateCRC(crc, chunkData);
// CRC is inverted
crc = ~crc;
byte[] array = BitConverter.GetBytes(crc);
Array.Reverse(array);
chunkCRC = array;
}
}
/// <summary>
/// Gets the length field of the chunk
/// </summary>
public uint ChunkLength
{
get
{
return APNGUtility.ParseUint(chunkLength, chunkLength.Length);
}
}
/// <summary>
/// Gets the CRC field of the chunk
/// </summary>
public uint ChunkCRC
{
get
{
return APNGUtility.ParseUint(chunkCRC, chunkCRC.Length);
}
}
/// <summary>
/// Attempts to parse an APNGChunk for the specified stream
/// </summary>
/// <param name="stream">The stream containing the APNG Chunk</param>
public void Read(Stream stream)
{
if (!stream.CanRead)
throw new ArgumentException("Stream is not readable");
calculatedCRC = CRC.INITIAL_CRC;
long chunkStart = stream.Position;
// Read the data Length
chunkLength = APNGUtility.ReadStream(stream, 4);
// Read the chunk type
chunkType = APNGUtility.ReadStream(stream, 4);
calculatedCRC = CRC.UpdateCRC(calculatedCRC, chunkType);
// Read the data
chunkData = APNGUtility.ReadStream(stream, ChunkLength);
calculatedCRC = CRC.UpdateCRC(calculatedCRC, chunkData);
// Read the CRC
chunkCRC = APNGUtility.ReadStream(stream, 4);
// CRC is inverted
calculatedCRC = ~calculatedCRC;
// Verify the CRC
if (ChunkCRC != calculatedCRC)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(String.Format("APNG Chunk CRC Mismatch. Chunk CRC = {0}, Calculated CRC = {1}.",
ChunkCRC, calculatedCRC));
sb.AppendLine(String.Format("This occurred while parsing the chunk at position {0} (0x{1:X8}) in the stream.",
chunkStart, chunkStart));
throw new ApplicationException(sb.ToString());
}
}
}
internal class PNG
{
/// <summary>
/// The PNG file signature
/// </summary>
private static byte[] header = new byte[] { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
/// <summary>
/// The PNG file's IHDR chunk
/// </summary>
private IHDRChunk ihdr;
/// <summary>
/// The PNG file's PLTE chunk (optional)
/// </summary>
private fcTLChunk plte;
/// <summary>
/// The PNG file's IDAT chunks
/// </summary>
private List<IDATChunk> idats;
/// <summary>
/// The PNG file's IEND chunk
/// </summary>
private IENDChunk iend;
/// <summary>
/// Default constructor
/// </summary>
public PNG()
{
idats = new List<IDATChunk>();
}
/// <summary>
/// Converts the chunks making up the PNG into a single MemoryStream which
/// is suitable for writing to a PNG file or creating a Image object using
/// Bitmap.FromStream
/// </summary>
/// <returns>MemoryStream</returns>
public MemoryStream ToStream()
{
MemoryStream ms = new MemoryStream();
ms.Write(header, 0, header.Length);
ms.Write(ihdr.Chunk, 0, ihdr.Chunk.Length);
foreach (IDATChunk chunk in idats)
ms.Write(chunk.Chunk, 0, chunk.Chunk.Length);
ms.Write(iend.Chunk, 0, iend.Chunk.Length);
return ms;
}
public void SaveFile(string FileName)
{
using (FileStream writer = new FileStream(FileName, FileMode.Create))
{
MemoryStream mem = ToStream();
mem.Position = 0;
byte[] content = new byte[mem.Length];
mem.Read(content, 0, content.Length);
writer.Write(content, 0, content.Length);
writer.Close();
}
}
/// <summary>
/// Gets or Sets the PNG's IHDR chunk
/// </summary>
public IHDRChunk IHDR
{
get { return ihdr; }
set { ihdr = value; }
}
/// <summary>
/// Gets or Sets the PNG's PLTE chunk
/// </summary>
public fcTLChunk FCTL
{
get { return plte; }
set { plte = value; }
}
/// <summary>
/// Gets or Sets the PNG's IEND chunk
/// </summary>
public IENDChunk IEND
{
get { return iend; }
set { iend = value; }
}
/// <summary>
/// Gets the list of IDAT chunk's making up the PNG
/// </summary>
public List<IDATChunk> IDATS
{
get { return idats; }
}
/// <summary>
/// Adds the assigned IDAT chunk to the end of the PNG's list of IDAT chunks
/// </summary>
public IDATChunk IDAT
{
set { idats.Add(value); }
}
}
public class APNG
{
/// <summary>
/// List of chunks in the APNG
/// </summary>
List<APNGChunk> chunks;
/// <summary>
/// List of PNGs embedded in the APNG
/// </summary>
List<PNG> pngs;
/// <summary>
/// The APNG's MHDRChunk
/// </summary>
acTLChunk headerChunk;
IHDRChunk ihdrChunk;
/// <summary>
/// Gets the number of embedded PNGs within the APNG
/// </summary>
public int NumEmbeddedPNG
{
get { return pngs.Count; }
}
public Bitmap this[int Index]
{
get
{
return ToBitmap(Index);
}
}
/// <summary>
/// Creates a Bitmap object containing the embedded PNG at the specified
/// index in the APNG's list of embedded PNGs
/// </summary>
/// <param name="index">The embedded PNG index</param>
/// <returns>Bitmap</returns>
public Bitmap ToBitmap(int index)
{
// Verify the index
if (index > NumEmbeddedPNG)
throw new ArgumentException(String.Format(
"Embedded PNG index must be between 0 and {0}", NumEmbeddedPNG - 1));
// Create the bitmap
Bitmap b = (Bitmap)Bitmap.FromStream(pngs[index].ToStream());
return b;
}
#if (DEBUG)
public void SaveFile(int index, string FileName)
{
// Verify the index
if (index > NumEmbeddedPNG)
throw new ArgumentException(String.Format(
"Embedded PNG index must be between 0 and {0}", NumEmbeddedPNG - 1));
pngs[index].SaveFile(FileName);
}
#endif
/// <summary>
/// Creates a string containing the names of all the chunks in the APNG
/// </summary>
/// <returns>String</returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder();
foreach (APNGChunk chunk in chunks)
sb.AppendLine(chunk.ChunkType);
return sb.ToString();
}
/// <summary>
/// Attempts to load an APNG from the specified file name
/// </summary>
/// <param name="filename">Name of the APNG file to load</param>
public void Load(string filename)
{
chunks = new List<APNGChunk>();
pngs = new List<PNG>();
// Open the file for reading
Stream stream = File.OpenRead(filename);
// Create a new header (should be 1 per file) and
// read it from the stream
APNGHeader header = new APNGHeader();
try
{
header.Read(stream);
}
catch (Exception)
{
stream.Close();
throw;
}
APNGChunk chunk;
PNG png = null;
// Read chunks from the stream until we reach the MEND chunk
do
{
// Read a generic Chunk
chunk = new APNGChunk();
try
{
chunk.Read(stream);
}
catch (Exception)
{
stream.Close();
throw;
}
// Take a look at the chunk type and decide what derived class to
// use to create a specific chunk
switch (chunk.ChunkType)
{
case acTLChunk.NAME:
if (headerChunk != null)
throw new ApplicationException(String.Format(
"Only one chunk of type {0} is allowed", chunk.ChunkType));
chunk = headerChunk = new acTLChunk(chunk);
break;
case MENDChunk.NAME:
chunk = new MENDChunk(chunk);
break;
case TERMChunk.NAME:
chunk = new TERMChunk(chunk);
break;
case BACKChunk.NAME:
chunk = new BACKChunk(chunk);
break;
case BKGDChunk.NAME:
chunk = new BKGDChunk(chunk);
break;
case fcTLChunk.NAME:
// This is the beginning of a new embedded PNG
chunk = new fcTLChunk(chunk);
png = new PNG();
png.FCTL = chunk as fcTLChunk;
png.IHDR = ihdrChunk;
pngs.Add(png);
break;
case IHDRChunk.NAME:
chunk = new IHDRChunk(chunk);
ihdrChunk = chunk as IHDRChunk;
break;
case IDATChunk.NAME:
chunk = new IDATChunk(chunk);
if (png != null)
{
png.IDAT = chunk as IDATChunk;
}
break;
case fdATChunk.NAME:
chunk = new fdATChunk(chunk);
if (png != null)
{
chunk.ChunkType = IDATChunk.NAME;
png.IDAT = new IDATChunk(chunk);
}
break;
case IENDChunk.NAME:
chunk = new IENDChunk(chunk);
for (int i = 0; i < pngs.Count; i++)
{
pngs[i].IEND = chunk as IENDChunk;
}
break;
default:
break;
}
// Add the chunk to our list of chunks
chunks.Add(chunk);
}
while (chunk.ChunkType != IENDChunk.NAME);
}
}
}