289 lines
9.7 KiB
C#
Executable File
289 lines
9.7 KiB
C#
Executable File
//
|
|
// © Copyright Henrik Ravn 2004
|
|
//
|
|
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
|
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
|
|
|
|
namespace DotZLib
|
|
{
|
|
|
|
#region Internal types
|
|
|
|
/// <summary>
|
|
/// Defines constants for the various flush types used with zlib
|
|
/// </summary>
|
|
internal enum FlushTypes
|
|
{
|
|
None, Partial, Sync, Full, Finish, Block
|
|
}
|
|
|
|
#region ZStream structure
|
|
// internal mapping of the zlib zstream structure for marshalling
|
|
[StructLayoutAttribute(LayoutKind.Sequential, Pack=4, Size=0, CharSet=CharSet.Ansi)]
|
|
internal struct ZStream
|
|
{
|
|
public IntPtr next_in;
|
|
public uint avail_in;
|
|
public uint total_in;
|
|
|
|
public IntPtr next_out;
|
|
public uint avail_out;
|
|
public uint total_out;
|
|
|
|
[MarshalAs(UnmanagedType.LPStr)]
|
|
string msg;
|
|
uint state;
|
|
|
|
uint zalloc;
|
|
uint zfree;
|
|
uint opaque;
|
|
|
|
int data_type;
|
|
public uint adler;
|
|
uint reserved;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Public enums
|
|
/// <summary>
|
|
/// Defines constants for the available compression levels in zlib
|
|
/// </summary>
|
|
public enum CompressLevel : int
|
|
{
|
|
/// <summary>
|
|
/// The default compression level with a reasonable compromise between compression and speed
|
|
/// </summary>
|
|
Default = -1,
|
|
/// <summary>
|
|
/// No compression at all. The data are passed straight through.
|
|
/// </summary>
|
|
None = 0,
|
|
/// <summary>
|
|
/// The maximum compression rate available.
|
|
/// </summary>
|
|
Best = 9,
|
|
/// <summary>
|
|
/// The fastest available compression level.
|
|
/// </summary>
|
|
Fastest = 1
|
|
}
|
|
#endregion
|
|
|
|
#region Exception classes
|
|
/// <summary>
|
|
/// The exception that is thrown when an error occurs on the zlib dll
|
|
/// </summary>
|
|
public class ZLibException : ApplicationException
|
|
{
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
|
|
/// error message and error code
|
|
/// </summary>
|
|
/// <param name="errorCode">The zlib error code that caused the exception</param>
|
|
/// <param name="msg">A message that (hopefully) describes the error</param>
|
|
public ZLibException(int errorCode, string msg) : base(String.Format("ZLib error {0} {1}", errorCode, msg))
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
|
|
/// error code
|
|
/// </summary>
|
|
/// <param name="errorCode">The zlib error code that caused the exception</param>
|
|
public ZLibException(int errorCode) : base(String.Format("ZLib error {0}", errorCode))
|
|
{
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Interfaces
|
|
|
|
/// <summary>
|
|
/// Declares methods and properties that enables a running checksum to be calculated
|
|
/// </summary>
|
|
public interface ChecksumGenerator
|
|
{
|
|
/// <summary>
|
|
/// Gets the current value of the checksum
|
|
/// </summary>
|
|
uint Value { get; }
|
|
|
|
/// <summary>
|
|
/// Clears the current checksum to 0
|
|
/// </summary>
|
|
void Reset();
|
|
|
|
/// <summary>
|
|
/// Updates the current checksum with an array of bytes
|
|
/// </summary>
|
|
/// <param name="data">The data to update the checksum with</param>
|
|
void Update(byte[] data);
|
|
|
|
/// <summary>
|
|
/// Updates the current checksum with part of an array of bytes
|
|
/// </summary>
|
|
/// <param name="data">The data to update the checksum with</param>
|
|
/// <param name="offset">Where in <c>data</c> to start updating</param>
|
|
/// <param name="count">The number of bytes from <c>data</c> to use</param>
|
|
/// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
|
|
/// <exception cref="ArgumentNullException"><c>data</c> is a null reference</exception>
|
|
/// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
|
|
void Update(byte[] data, int offset, int count);
|
|
|
|
/// <summary>
|
|
/// Updates the current checksum with the data from a string
|
|
/// </summary>
|
|
/// <param name="data">The string to update the checksum with</param>
|
|
/// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks>
|
|
void Update(string data);
|
|
|
|
/// <summary>
|
|
/// Updates the current checksum with the data from a string, using a specific encoding
|
|
/// </summary>
|
|
/// <param name="data">The string to update the checksum with</param>
|
|
/// <param name="encoding">The encoding to use</param>
|
|
void Update(string data, Encoding encoding);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Represents the method that will be called from a codec when new data
|
|
/// are available.
|
|
/// </summary>
|
|
/// <paramref name="data">The byte array containing the processed data</paramref>
|
|
/// <paramref name="startIndex">The index of the first processed byte in <c>data</c></paramref>
|
|
/// <paramref name="count">The number of processed bytes available</paramref>
|
|
/// <remarks>On return from this method, the data may be overwritten, so grab it while you can.
|
|
/// You cannot assume that startIndex will be zero.
|
|
/// </remarks>
|
|
public delegate void DataAvailableHandler(byte[] data, int startIndex, int count);
|
|
|
|
/// <summary>
|
|
/// Declares methods and events for implementing compressors/decompressors
|
|
/// </summary>
|
|
public interface Codec
|
|
{
|
|
/// <summary>
|
|
/// Occurs when more processed data are available.
|
|
/// </summary>
|
|
event DataAvailableHandler DataAvailable;
|
|
|
|
/// <summary>
|
|
/// Adds more data to the codec to be processed.
|
|
/// </summary>
|
|
/// <param name="data">Byte array containing the data to be added to the codec</param>
|
|
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
|
|
void Add(byte[] data);
|
|
|
|
/// <summary>
|
|
/// Adds more data to the codec to be processed.
|
|
/// </summary>
|
|
/// <param name="data">Byte array containing the data to be added to the codec</param>
|
|
/// <param name="offset">The index of the first byte to add from <c>data</c></param>
|
|
/// <param name="count">The number of bytes to add</param>
|
|
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
|
|
void Add(byte[] data, int offset, int count);
|
|
|
|
/// <summary>
|
|
/// Finishes up any pending data that needs to be processed and handled.
|
|
/// </summary>
|
|
void Finish();
|
|
|
|
/// <summary>
|
|
/// Gets the checksum of the data that has been added so far
|
|
/// </summary>
|
|
uint Checksum { get; }
|
|
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Classes
|
|
/// <summary>
|
|
/// Encapsulates general information about the ZLib library
|
|
/// </summary>
|
|
public class Info
|
|
{
|
|
#region DLL imports
|
|
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
|
private static extern uint zlibCompileFlags();
|
|
|
|
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
|
private static extern string zlibVersion();
|
|
#endregion
|
|
|
|
#region Private stuff
|
|
private uint _flags;
|
|
|
|
// helper function that unpacks a bitsize mask
|
|
private static int bitSize(uint bits)
|
|
{
|
|
switch (bits)
|
|
{
|
|
case 0: return 16;
|
|
case 1: return 32;
|
|
case 2: return 64;
|
|
}
|
|
return -1;
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Constructs an instance of the <c>Info</c> class.
|
|
/// </summary>
|
|
public Info()
|
|
{
|
|
_flags = zlibCompileFlags();
|
|
}
|
|
|
|
/// <summary>
|
|
/// True if the library is compiled with debug info
|
|
/// </summary>
|
|
public bool HasDebugInfo { get { return 0 != (_flags & 0x100); } }
|
|
|
|
/// <summary>
|
|
/// True if the library is compiled with assembly optimizations
|
|
/// </summary>
|
|
public bool UsesAssemblyCode { get { return 0 != (_flags & 0x200); } }
|
|
|
|
/// <summary>
|
|
/// Gets the size of the unsigned int that was compiled into Zlib
|
|
/// </summary>
|
|
public int SizeOfUInt { get { return bitSize(_flags & 3); } }
|
|
|
|
/// <summary>
|
|
/// Gets the size of the unsigned long that was compiled into Zlib
|
|
/// </summary>
|
|
public int SizeOfULong { get { return bitSize((_flags >> 2) & 3); } }
|
|
|
|
/// <summary>
|
|
/// Gets the size of the pointers that were compiled into Zlib
|
|
/// </summary>
|
|
public int SizeOfPointer { get { return bitSize((_flags >> 4) & 3); } }
|
|
|
|
/// <summary>
|
|
/// Gets the size of the z_off_t type that was compiled into Zlib
|
|
/// </summary>
|
|
public int SizeOfOffset { get { return bitSize((_flags >> 6) & 3); } }
|
|
|
|
/// <summary>
|
|
/// Gets the version of ZLib as a string, e.g. "1.2.1"
|
|
/// </summary>
|
|
public static string Version { get { return zlibVersion(); } }
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|