mirror of https://github.com/SixLabors/ImageSharp
Browse Source
Fix #359 Former-commit-id: e140a2e3bb28ec1332e0d4caf0de1eaeed154376 Former-commit-id: db6a61bfbe42c744ef7ad47444019a77a9d439dc Former-commit-id: 88b7684fa215b5e7641a8f012fef6b97313a6935af/merge-core
James South
10 years ago
5 changed files with 415 additions and 697 deletions
@ -1,432 +0,0 @@ |
|||
namespace ImageProcessorCore.Formats |
|||
{ |
|||
using System; |
|||
using System.IO; |
|||
|
|||
/// <summary>
|
|||
/// An implementation of the Lempel-Ziv-Welch lossless compression algorithm.
|
|||
/// See http://en.wikipedia.org/wiki/Lzw
|
|||
/// </summary>
|
|||
public class LzwEncoder2 |
|||
{ |
|||
#region declarations
|
|||
private const int _EOF = -1; |
|||
private const int _BITS = 12; |
|||
private const int _HSIZE = 5003; // 80% occupancy
|
|||
|
|||
/// <summary>
|
|||
/// A collection of indices within the active colour table of the
|
|||
/// colours of the pixels within the image.
|
|||
/// </summary>
|
|||
private byte[] _pixels; |
|||
private int _initCodeSize; |
|||
|
|||
/// <summary>
|
|||
/// Number of pixels still to process.
|
|||
/// </summary>
|
|||
private int _pixelsRemaining; |
|||
|
|||
/// <summary>
|
|||
/// Index of the current position within the IndexedPixels collection.
|
|||
/// </summary>
|
|||
private int _pixelIndex; |
|||
|
|||
/// <summary>
|
|||
/// Number of bits per encoded code.
|
|||
/// </summary>
|
|||
int _codeSize; // number of bits/code
|
|||
|
|||
/// <summary>
|
|||
/// Maximum number of bits per encoded code.
|
|||
/// </summary>
|
|||
int _maxCodeSize = _BITS; // user settable max # bits/code
|
|||
|
|||
/// <summary>
|
|||
/// The largest possible code given the current value of _codeSize.
|
|||
/// </summary>
|
|||
int _maxCode; // maximum code, given n_bits
|
|||
|
|||
/// <summary>
|
|||
/// The largest possible code given the largest possible value of
|
|||
/// _codeSize, plus 1. We should never output this code.
|
|||
/// </summary>
|
|||
int _maxMaxCode = 1 << _BITS; // should NEVER generate this code
|
|||
|
|||
int[] _htab = new int[_HSIZE]; |
|||
int[] _codetab = new int[_HSIZE]; |
|||
|
|||
int _hsize = _HSIZE; // for dynamic table sizing
|
|||
|
|||
/// <summary>
|
|||
/// The next unused code. Initially set to the clear code plus 2.
|
|||
/// </summary>
|
|||
int _nextAvailableCode; // first unused entry
|
|||
|
|||
// block compression parameters -- after all codes are used up,
|
|||
// and compression rate changes, start over.
|
|||
bool _clear_flg; |
|||
|
|||
int _g_init_bits; |
|||
|
|||
/// <summary>
|
|||
/// Clear code. This is written out by the encoder when the dictionary
|
|||
/// is full, and is an instruction to the decoder to empty its dictionary
|
|||
/// </summary>
|
|||
int _clearCode; |
|||
|
|||
/// <summary>
|
|||
/// End of information code. This is set to the clear code plus 1 and
|
|||
/// marks the end of the encoded data.
|
|||
/// </summary>
|
|||
int _endOfInformationCode; |
|||
|
|||
int _cur_accum; |
|||
int _cur_bits; |
|||
|
|||
int[] _masks = |
|||
{ |
|||
0x0000, |
|||
0x0001, |
|||
0x0003, |
|||
0x0007, |
|||
0x000F, |
|||
0x001F, |
|||
0x003F, |
|||
0x007F, |
|||
0x00FF, |
|||
0x01FF, |
|||
0x03FF, |
|||
0x07FF, |
|||
0x0FFF, |
|||
0x1FFF, |
|||
0x3FFF, |
|||
0x7FFF, |
|||
0xFFFF }; |
|||
|
|||
// Number of characters so far in this 'packet'
|
|||
/// <summary>
|
|||
/// Number of bytes that have been added to the packet so far.
|
|||
/// </summary>
|
|||
int _byteCountInPacket; |
|||
|
|||
// Define the storage for the packet accumulator
|
|||
/// <summary>
|
|||
/// An array of encoded bytes which are waiting to be written to the
|
|||
/// output stream. The bytes are written out once 254 of them have
|
|||
/// been populated.
|
|||
/// </summary>
|
|||
byte[] _packet = new byte[256]; |
|||
#endregion
|
|||
|
|||
#region constructor
|
|||
/// <summary>
|
|||
/// Constructor.
|
|||
/// </summary>
|
|||
/// <param name="pixels">
|
|||
/// Indices in the active colour table of the colours of the pixel
|
|||
/// making up the image.
|
|||
/// </param>
|
|||
/// <exception cref="ArgumentNullException">
|
|||
/// The supplied pixel collection is null.
|
|||
/// </exception>
|
|||
public LzwEncoder2(byte[] pixels) |
|||
{ |
|||
if (pixels == null) |
|||
{ |
|||
throw new ArgumentNullException("pixels"); |
|||
} |
|||
|
|||
_pixels = pixels; |
|||
// _initCodeSize = Math.Max(2, colourDepth);
|
|||
_initCodeSize = 8; // only seems to work reliably when 8, even if this is sometimes larger than needed
|
|||
} |
|||
#endregion
|
|||
|
|||
#region Encode method
|
|||
/// <summary>
|
|||
/// Encodes the data and writes it to the supplied output stream.
|
|||
/// </summary>
|
|||
/// <param name="outputStream">Output stream</param>
|
|||
/// <exception cref="ArgumentNullException">
|
|||
/// The supplied output stream is null.
|
|||
/// </exception>
|
|||
public void Encode(Stream outputStream) |
|||
{ |
|||
if (outputStream == null) |
|||
{ |
|||
throw new ArgumentNullException("outputStream"); |
|||
} |
|||
|
|||
outputStream.WriteByte(Convert.ToByte(_initCodeSize)); // write "initial code size" byte
|
|||
|
|||
_pixelsRemaining = _pixels.Length; |
|||
_pixelIndex = 0; |
|||
|
|||
Compress(_initCodeSize + 1, outputStream); // compress and write the pixel data
|
|||
|
|||
outputStream.WriteByte(0); // write block terminator
|
|||
} |
|||
#endregion
|
|||
|
|||
#region private methods
|
|||
|
|||
#region private Add method
|
|||
/// <summary>
|
|||
/// Add a character to the end of the current packet, and if the packet
|
|||
/// is 254 characters long, flush the packet to disk.
|
|||
/// </summary>
|
|||
/// <param name="c">The character to add</param>
|
|||
/// <param name="outputStream">Output stream</param>
|
|||
private void Add(byte c, Stream outputStream) |
|||
{ |
|||
_packet[_byteCountInPacket++] = c; |
|||
if (_byteCountInPacket >= 254) |
|||
{ |
|||
Flush(outputStream); |
|||
} |
|||
} |
|||
#endregion
|
|||
|
|||
#region private ClearTable method
|
|||
/// <summary>
|
|||
/// Clears out the hash table.
|
|||
/// </summary>
|
|||
/// <param name="outs">Output stream</param>
|
|||
private void ClearTable(Stream outs) |
|||
{ |
|||
ResetCodeTable(_hsize); |
|||
_nextAvailableCode = _clearCode + 2; |
|||
_clear_flg = true; |
|||
|
|||
Output(_clearCode, outs); |
|||
} |
|||
#endregion
|
|||
|
|||
#region private ResetCodeTable method
|
|||
/// <summary>
|
|||
/// Resets the code table
|
|||
/// </summary>
|
|||
/// <param name="hsize"></param>
|
|||
private void ResetCodeTable(int hsize) |
|||
{ |
|||
for (int i = 0; i < hsize; ++i) |
|||
{ |
|||
_htab[i] = -1; |
|||
} |
|||
} |
|||
#endregion
|
|||
|
|||
#region private Compress method
|
|||
/// <summary>
|
|||
/// Compress method
|
|||
/// </summary>
|
|||
/// <param name="init_bits"></param>
|
|||
/// <param name="outs"></param>
|
|||
private void Compress(int init_bits, Stream outs) |
|||
{ |
|||
int fcode; |
|||
int i /* = 0 */; |
|||
int c; |
|||
int ent; |
|||
int disp; |
|||
int hsize_reg; |
|||
int hshift; |
|||
|
|||
// Set up the globals: g_init_bits - initial number of bits
|
|||
_g_init_bits = init_bits; |
|||
|
|||
// Set up the necessary values
|
|||
_clear_flg = false; |
|||
_codeSize = _g_init_bits; |
|||
_maxCode = MaxCode(_codeSize); |
|||
|
|||
_clearCode = 1 << (init_bits - 1); |
|||
_endOfInformationCode = _clearCode + 1; |
|||
_nextAvailableCode = _clearCode + 2; |
|||
|
|||
_byteCountInPacket = 0; // clear packet
|
|||
|
|||
ent = NextPixel(); |
|||
|
|||
hshift = 0; |
|||
for (fcode = _hsize; fcode < 65536; fcode *= 2) |
|||
++hshift; |
|||
hshift = 8 - hshift; // set hash code range bound
|
|||
|
|||
hsize_reg = _hsize; |
|||
ResetCodeTable(hsize_reg); // clear hash table
|
|||
|
|||
Output(_clearCode, outs); |
|||
|
|||
outer_loop: while ((c = NextPixel()) != _EOF) |
|||
{ |
|||
fcode = (c << _maxCodeSize) + ent; |
|||
i = (c << hshift) ^ ent; // xor hashing
|
|||
|
|||
if (_htab[i] == fcode) |
|||
{ |
|||
ent = _codetab[i]; |
|||
continue; |
|||
} |
|||
else if (_htab[i] >= 0) // non-empty slot
|
|||
{ |
|||
disp = hsize_reg - i; // secondary hash (after G. Knott)
|
|||
if (i == 0) |
|||
disp = 1; |
|||
do |
|||
{ |
|||
if ((i -= disp) < 0) |
|||
i += hsize_reg; |
|||
|
|||
if (_htab[i] == fcode) |
|||
{ |
|||
ent = _codetab[i]; |
|||
goto outer_loop; |
|||
} |
|||
} while (_htab[i] >= 0); |
|||
} |
|||
Output(ent, outs); |
|||
ent = c; |
|||
if (_nextAvailableCode < _maxMaxCode) |
|||
{ |
|||
_codetab[i] = _nextAvailableCode++; // code -> hashtable
|
|||
_htab[i] = fcode; |
|||
} |
|||
else |
|||
ClearTable(outs); |
|||
} |
|||
// Put out the final code.
|
|||
Output(ent, outs); |
|||
Output(_endOfInformationCode, outs); |
|||
} |
|||
#endregion
|
|||
|
|||
#region private Flush method
|
|||
/// <summary>
|
|||
/// Flush the packet to disk, and reset the accumulator
|
|||
/// </summary>
|
|||
/// <param name="outs"></param>
|
|||
private void Flush(Stream outs) |
|||
{ |
|||
if (_byteCountInPacket > 0) |
|||
{ |
|||
outs.WriteByte(Convert.ToByte(_byteCountInPacket)); |
|||
outs.Write(_packet, 0, _byteCountInPacket); |
|||
_byteCountInPacket = 0; |
|||
} |
|||
} |
|||
#endregion
|
|||
|
|||
#region private static MaxCode method
|
|||
/// <summary>
|
|||
/// Calculates and returns the maximum possible code given the supplied
|
|||
/// code size.
|
|||
/// This is calculated as 2 to the power of the code size, minus one.
|
|||
/// </summary>
|
|||
/// <param name="codeSize">
|
|||
/// Code size in bits.
|
|||
/// </param>
|
|||
/// <returns></returns>
|
|||
private static int MaxCode(int codeSize) |
|||
{ |
|||
return (1 << codeSize) - 1; |
|||
} |
|||
#endregion
|
|||
|
|||
#region private NextPixel method
|
|||
/// <summary>
|
|||
/// Gets the next pixel from the supplied IndexedPixels collection,
|
|||
/// increments the index of the current position within the collection,
|
|||
/// and decrements the number of pixels remaining.
|
|||
/// </summary>
|
|||
/// <returns></returns>
|
|||
private int NextPixel() |
|||
{ |
|||
if (_pixelsRemaining == 0) |
|||
{ |
|||
// We've processed all the supplied pixel indices so return an
|
|||
// end of file indicator.
|
|||
return _EOF; |
|||
} |
|||
|
|||
--_pixelsRemaining; |
|||
|
|||
byte pix = _pixels[_pixelIndex++]; |
|||
|
|||
return pix; |
|||
} |
|||
#endregion
|
|||
|
|||
#region private Output method
|
|||
/// <summary>
|
|||
/// Adds an encoded LZW code to a buffer ready to be written to the
|
|||
/// output stream. Any full bytes contained in the buffer are then
|
|||
/// written to the output stream and removed from the buffer.
|
|||
/// </summary>
|
|||
/// <param name="code"></param>
|
|||
/// <param name="outputStream">
|
|||
/// The output stream to write to.
|
|||
/// </param>
|
|||
private void Output(int code, Stream outputStream) |
|||
{ |
|||
_cur_accum &= _masks[_cur_bits]; |
|||
|
|||
if (_cur_bits > 0) |
|||
{ |
|||
_cur_accum |= (code << _cur_bits); |
|||
} |
|||
else |
|||
{ |
|||
_cur_accum = code; |
|||
} |
|||
|
|||
_cur_bits += _codeSize; |
|||
|
|||
while (_cur_bits >= 8) |
|||
{ |
|||
Add((byte)(_cur_accum & 0xff), outputStream); |
|||
_cur_accum >>= 8; |
|||
_cur_bits -= 8; |
|||
} |
|||
|
|||
// If the next entry is going to be too big for the code size,
|
|||
// then increase it, if possible.
|
|||
if (_nextAvailableCode > _maxCode || _clear_flg) |
|||
{ |
|||
if (_clear_flg) |
|||
{ |
|||
_maxCode = MaxCode(_codeSize = _g_init_bits); |
|||
_clear_flg = false; |
|||
} |
|||
else |
|||
{ |
|||
++_codeSize; |
|||
if (_codeSize == _maxCodeSize) |
|||
{ |
|||
_maxCode = _maxMaxCode; |
|||
} |
|||
else |
|||
{ |
|||
_maxCode = MaxCode(_codeSize); |
|||
} |
|||
} |
|||
} |
|||
|
|||
if (code == _endOfInformationCode) |
|||
{ |
|||
// At EOF, write the rest of the buffer.
|
|||
while (_cur_bits > 0) |
|||
{ |
|||
Add((byte)(_cur_accum & 0xff), outputStream); |
|||
_cur_accum >>= 8; |
|||
_cur_bits -= 8; |
|||
} |
|||
|
|||
Flush(outputStream); |
|||
} |
|||
} |
|||
#endregion
|
|||
|
|||
#endregion
|
|||
} |
|||
} |
|||
Loading…
Reference in new issue