/Utilities/Compression/Deflaters/Deflater.cs

// Based on Mike Krueger's SharpZipLib, Copyright (C) 2001 (GNU license).

// Authors of the original java version: Jochen Hoenicke, John Leuner

// See http://www.ISeeSharpCode.com for more information.



using System;

using Delta.Utilities.Helpers;



namespace Delta.Utilities.Compression.Deflaters

{

	/// <summary>

	/// This is the Deflater class. The deflater class compresses input

	/// with the deflate algorithm described in RFC 1951.  It has several

	/// compression levels and three different strategies described below.

	/// <para />

	/// This class is <i>not</i> thread safe. This is inherent in the API, due

	/// to the split of deflate and setInput.

	/// <para />

	/// author of the original java version : Jochen Hoenicke

	/// </summary>

	public class Deflater

	{

		#region Constants

		/// <summary>

		/// The best and slowest compression level.

		/// This tries to find very long and distant string repetitions.

		/// </summary>

		public const int BestCompression = 9;



		/// <summary>

		/// The worst but fastest compression level.

		/// </summary>

		public const int BestSpeed = 1;



		/// <summary>

		/// The default compression level.

		/// </summary>

		public const int DefaultCompression = MathHelper.InvalidIndex;



		/// <summary>

		/// This level won't compress at all but output uncompressed blocks.

		/// </summary>

		public const int NoCompression = 0;



		/// <summary>

		/// The compression method. This is the only method supported so far.

		/// There is no need to use this constant at all.

		/// </summary>

		public const int Deflated = 8;



		/*

		* The Deflater can do the following state transitions:

		* (1) -> InitializeState   ----> InitializeFinishingState ---.

		*        /  | (2)      (5)                         |

		*       /   v          (5)                         |

		*   (3)| SetDictionaryState ---> SetDictionaryFinishingState |(3)

		*       \   | (3)                 |        ,-------'

		*        |  |                     | (3)   /

		*        v  v          (5)        v      v

		* (1) -> BusyState   ----> FinishingState

		*                                | (6)

		*                                v

		*                           FinishedState

		*    \_____________________________________/

		*          | (7)

		*          v

		*        ClosedState



		* (1) If we should produce a header we start in InitializeState, otherwise

		*     we start in BusyState.

		* (2) A dictionary may be set only when we are in InitializeState, then

		*     we change the state as indicated.

		* (3) Whether a dictionary is set or not, on the first call of deflate

		*     we change to BusyState.

		* (4) -- intentionally left blank -- :)

		* (5) FinishingState is entered, when flush() is called to indicate that

		*     there is no more INPUT.  There are also states indicating, that

		*     the header wasn't written yet.

		* (6) FinishedState is entered, when everything has been flushed to the

		*     internal pending output buffer.

		* (7) At any time (7)

		*/



		/// <summary>

		/// Is set dictionary

		/// </summary>

		/// <returns>0x01</returns>

		private const int IsSetDictionary = 0x01;



		/// <summary>

		/// Is flushing

		/// </summary>

		/// <returns>0x04</returns>

		private const int IsFlushing = 0x04;



		/// <summary>

		/// Is finishing

		/// </summary>

		/// <returns>0x08</returns>

		private const int IsFinishing = 0x08;



		/// <summary>

		/// Initialize state

		/// </summary>

		/// <returns>0x00</returns>

		private const int InitializeState = 0x00;



		/// <summary>

		/// Set dictionary state

		/// </summary>

		/// <returns>0x01</returns>

		private const int SetDictionaryState = 0x01;



		/*unused

		/// <summary>

		/// Initialize finishing state

		/// </summary>

		/// <returns>0x08</returns>

		//private static int InitializeFinishingState    = 0x08;

		/// <summary>

		/// Set dictionary finishing state

		/// </summary>

		/// <returns>0x09</returns>

		//private static int SetDictionaryFinishingState = 0x09;

		*/



		/// <summary>

		/// Busy state

		/// </summary>

		/// <returns>0x10</returns>

		private const int BusyState = 0x10;



		/// <summary>

		/// Flushing state

		/// </summary>

		/// <returns>0x14</returns>

		private const int FlushingState = 0x14;



		/// <summary>

		/// Finishing state

		/// </summary>

		/// <returns>0x1c</returns>

		private const int FinishingState = 0x1c;



		/// <summary>

		/// Finished state

		/// </summary>

		/// <returns>0x 1e</returns>

		private const int FinishedState = 0x1e;



		/// <summary>

		/// Closed state

		/// </summary>

		/// <returns>0x7f</returns>

		private const int ClosedState = 0x7f;

		#endregion



		#region Adler (Public)

		/// <summary>

		/// Gets the current adler checksum of the data that was processed so far.

		/// </summary>

		public int Adler

		{

			get

			{

				return engine.Adler;

			}

		}

		#endregion



		#region TotalIn (Public)

		/// <summary>

		/// Gets the number of input bytes processed so far.

		/// </summary>

		public int TotalIn

		{

			get

			{

				return engine.TotalIn;

			}

		}

		#endregion



		#region TotalOut (Public)

		/// <summary>

		/// Gets the number of output bytes so far.

		/// </summary>

		public long TotalOut

		{

			get

			{

				return totalOut;

			}

		}

		#endregion



		#region IsFinished (Public)

		/// <summary>

		/// Returns true if the stream was finished and no more output bytes

		/// are available.

		/// </summary>

		public bool IsFinished

		{

			get

			{

				return state == FinishedState && pending.IsFlushed;

			}

		}

		#endregion



		#region IsNeedingInput (Public)

		/// <summary>

		/// Returns true, if the input buffer is empty.

		/// You should then call setInput(). 

		/// NOTE: This method can also return true when the stream

		/// was finished.

		/// </summary>

		public bool IsNeedingInput

		{

			get

			{

				return engine.NeedsInput();

			}

		}

		#endregion



		#region Private



		#region level (Private)

		/// <summary>

		/// Compression level.

		/// </summary>

		private int level;

		#endregion



		#region noZlibHeaderOrFooter (Private)

		/// <summary>

		/// If true no Zlib/RFC1950 headers or footers are generated

		/// </summary>

		private readonly bool noZlibHeaderOrFooter;

		#endregion



		#region state (Private)

		/// <summary>

		/// The current state.

		/// </summary>

		private int state;

		#endregion



		#region totalOut (Private)

		/// <summary>

		/// The total bytes of output written.

		/// </summary>

		private long totalOut;

		#endregion



		#region pending (Private)

		/// <summary>

		/// The pending output.

		/// </summary>

		private readonly DeflaterPending pending;

		#endregion



		#region engine (Private)

		/// <summary>

		/// The deflater engine.

		/// </summary>

		private readonly DeflaterEngine engine;

		#endregion



		#endregion



		#region Constructors

		/// <summary>

		/// Creates a new deflater with default compression level.

		/// </summary>

		public Deflater()

			: this(DefaultCompression, false)

		{

		}



		/// <summary>

		/// Creates a new deflater with given compression level.

		/// </summary>

		/// <param name="level">The compression level, a value between

		/// NoCompression and BestCompression, or DefaultCompression.

		/// </param>

		/// <exception cref="System.ArgumentOutOfRangeException">

		/// If level is out of range.</exception>

		public Deflater(int level)

			: this(level, false)

		{

		}



		/// <summary>

		/// Creates a new deflater with given compression level.

		/// </summary>

		/// <param name="level">

		/// the compression level, a value between NoCompression

		/// and BestCompression.

		/// </param>

		/// <param name="noZlibHeaderOrFooter">

		/// true, if we should suppress the Zlib/RFC1950 header at the

		/// beginning and the adler checksum at the end of the output.

		/// This is useful for the GZIP/PKZIP formats.

		/// </param>

		/// <exception cref="System.ArgumentOutOfRangeException">

		/// If level is out of range.</exception>

		public Deflater(int level, bool noZlibHeaderOrFooter)

		{

			if (level == DefaultCompression)

			{

				level = 6;

			}

			else if (level < NoCompression ||

			         level > BestCompression)

			{

				throw new ArgumentOutOfRangeException("level");

			}



			pending = new DeflaterPending();

			engine = new DeflaterEngine(pending);

			this.noZlibHeaderOrFooter = noZlibHeaderOrFooter;

			SetStrategy(DeflateStrategy.Default);

			SetLevel(level);

			Reset();

		}

		#endregion



		#region Reset (Public)

		/// <summary>

		/// Resets the deflater.  The deflater acts afterwards as if it was

		/// just created with the same compression level and strategy as it

		/// had before.

		/// </summary>

		public void Reset()

		{

			state = (noZlibHeaderOrFooter

			         	? BusyState

			         	: InitializeState);

			totalOut = 0;

			pending.Reset();

			engine.Reset();

		}

		#endregion



		#region Flush (Public)

		/// <summary>

		/// Flushes the current input block.  Further calls to deflate() will

		/// produce enough output to inflate everything in the current input

		/// block.  This is not part of Sun's JDK so I have made it package

		/// private.  It is used by DeflaterOutputStream to implement

		/// flush().

		/// </summary>

		public void Flush()

		{

			state |= IsFlushing;

		}

		#endregion



		#region Finish (Public)

		/// <summary>

		/// Finishes the deflater with the current input block.  It is an error

		/// to give more input after this method was called. This method must

		/// be called to force all bytes to be flushed.

		/// </summary>

		public void Finish()

		{

			state |= IsFlushing | IsFinishing;

		}

		#endregion



		#region SetInput (Public)

		/// <summary>

		/// Sets the data which should be compressed next.  This should be only

		/// called when needsInput indicates that more input is needed.

		/// If you call setInput when needsInput() returns false, the

		/// previous input that is still pending will be thrown away.

		/// The given byte array should not be changed, before needsInput()

		/// returns true again.

		/// This call is equivalent to <code>setInput(input, 0, input.length)

		/// </code>.

		/// </summary>

		/// <param name="input">

		/// the buffer containing the input data.

		/// </param>

		/// <exception cref="System.InvalidOperationException">

		/// if the buffer was finished() or ended().

		/// </exception>

		public void SetInput(byte[] input)

		{

			SetInput(input, 0, input.Length);

		}



		/// <summary>

		/// Sets the data which should be compressed next.  This should be

		/// only called when needsInput indicates that more input is needed.

		/// The given byte array should not be changed, before needsInput() returns

		/// true again.

		/// </summary>

		/// <param name="input">The buffer containing the input data.</param>

		/// <param name="off">The start of the data.</param>

		/// <param name="len">The length of the data.</param>

		/// <exception cref="System.InvalidOperationException">

		/// if the buffer was finished() or ended() or if previous input is still

		/// pending.

		/// </exception>

		public void SetInput(byte[] input, int off, int len)

		{

			if ((state & IsFinishing) != 0)

			{

				throw new InvalidOperationException("finish()/end() already called");

			}

			engine.SetInput(input, off, len);

		}

		#endregion



		#region SetLevel (Public)

		/// <summary>

		/// Sets the compression level.  There is no guarantee of the exact

		/// position of the change, but if you call this when needsInput is

		/// true the change of compression level will occur somewhere near

		/// before the end of the so far given input.

		/// </summary>

		/// <param name="lvl">

		/// the new compression level.

		/// </param>

		public void SetLevel(int lvl)

		{

			if (lvl == DefaultCompression)

			{

				lvl = 6;

			}

			else if (lvl < NoCompression || lvl > BestCompression)

			{

				throw new ArgumentOutOfRangeException("lvl");

			}



			if (level != lvl)

			{

				level = lvl;

				engine.SetLevel(lvl);

			}

		}

		#endregion



		#region GetLevel (Public)

		/// <summary>

		/// Get current compression level

		/// </summary>

		/// <returns>Returns the current compression level</returns>

		public int GetLevel()

		{

			return level;

		}

		#endregion



		#region SetStrategy (Public)

		/// <summary>

		/// Sets the compression strategy. Strategy is one of

		/// DEFAULT_STRATEGY, HUFFMAN_ONLY and FILTERED.  For the exact

		/// position where the strategy is changed, the same as for

		/// setLevel() applies.

		/// </summary>

		/// <param name="strategy">

		/// The new compression strategy.

		/// </param>

		public void SetStrategy(DeflateStrategy strategy)

		{

			engine.Strategy = strategy;

		}

		#endregion



		#region Deflate (Public)

		/// <summary>

		/// Deflates the current input block with to the given array.

		/// </summary>

		/// <param name="output">

		/// The buffer where compressed data is stored

		/// </param>

		/// <returns>

		/// The number of compressed bytes added to the output, or 0 if either

		/// needsInput() or finished() returns true or length is zero.

		/// </returns>

		public int Deflate(byte[] output)

		{

			return Deflate(output, 0, output.Length);

		}



		/// <summary>

		/// Deflates the current input block to the given array.

		/// </summary>

		/// <param name="output">Buffer to store the compressed data.</param>

		/// <param name="offset">Offset into the output array.</param>

		/// <param name="length">The maximum number of bytes that may be stored.

		/// </param>

		/// <returns>

		/// The number of compressed bytes added to the output, or 0 if either

		/// needsInput() or finished() returns true or length is zero.

		/// </returns>

		/// <exception cref="System.InvalidOperationException">

		/// If end() was previously called.

		/// </exception>

		/// <exception cref="System.ArgumentOutOfRangeException">

		/// If offset and/or length don't match the array length.

		/// </exception>

		public int Deflate(byte[] output, int offset, int length)

		{

			int origLength = length;



			if (state == ClosedState)

			{

				throw new InvalidOperationException("Deflater closed");

			}



			if (state < BusyState)

			{

				/* output header */

				int header = (Deflated +

				              ((DeflaterConstants.MaxWBits - 8) << 4)) << 8;

				int level_flags = (level - 1) >> 1;

				if (level_flags < 0 || level_flags > 3)

				{

					level_flags = 3;

				}

				header |= level_flags << 6;

				if ((state & IsSetDictionary) != 0)

				{

					// Dictionary was set

					header |= DeflaterConstants.PresetDictionary;

				}

				header += 31 - (header % 31);



				pending.WriteShortMsb(header);

				if ((state & IsSetDictionary) != 0)

				{

					int chksum = engine.Adler;

					engine.ResetAdler();

					pending.WriteShortMsb(chksum >> 16);

					pending.WriteShortMsb(chksum & 0xffff);

				}



				state = BusyState | (state & (IsFlushing | IsFinishing));

			}



			for (;;)

			{

				int count = pending.Flush(output, offset, length);

				offset += count;

				totalOut += count;

				length -= count;



				if (length == 0 || state == FinishedState)

				{

					break;

				}



				if (!engine.Deflate((state & IsFlushing) != 0,

					(state & IsFinishing) != 0))

				{

					if (state == BusyState)

					{

						/* We need more input now */

						return origLength - length;

					}

					else if (state == FlushingState)

					{

						if (level != NoCompression)

						{

							// We have to supply some lookahead.  8 bit lookahead

							// is needed by the zlib inflater, and we must fill

							// the next byte, so that all bits are flushed.

							int neededbits = 8 + ((-pending.BitCount) & 7);

							while (neededbits > 0)

							{

								/* write a static tree block consisting solely of

								 * an EOF:

								 */

								pending.WriteBits(2, 10);

								neededbits -= 10;

							}

						}

						state = BusyState;

					}

					else if (state == FinishingState)

					{

						pending.AlignToByte();



						// Compressed data is complete.

						// Write footer information if required.

						if (!noZlibHeaderOrFooter)

						{

							int adler = engine.Adler;

							pending.WriteShortMsb(adler >> 16);

							pending.WriteShortMsb(adler & 0xffff);

						}

						state = FinishedState;

					}

				}

			}

			return origLength - length;

		}

		#endregion



		#region SetDictionary (Public)

		/// <summary>

		/// Sets the dictionary which should be used in the deflate process.

		/// This call is equivalent to <code>setDictionary(dict, 0, dict.Length)

		/// </code>.

		/// </summary>

		/// <param name="dict">

		/// the dictionary.

		/// </param>

		/// <exception cref="System.InvalidOperationException">

		/// if setInput () or deflate () were already called or another dictionary

		/// was already set.

		/// </exception>

		public void SetDictionary(byte[] dict)

		{

			SetDictionary(dict, 0, dict.Length);

		}



		/// <summary>

		/// Sets the dictionary which should be used in the deflate process.

		/// The dictionary is a byte array containing strings that are

		/// likely to occur in the data which should be compressed. The

		/// dictionary is not stored in the compressed output, only a

		/// checksum. To decompress the output you need to supply the same

		/// dictionary again.

		/// </summary>

		/// <param name="dict">

		/// The dictionary data

		/// </param>

		/// <param name="offset">

		/// An offset into the dictionary.

		/// </param>

		/// <param name="length">

		/// The length of the dictionary data to use

		/// </param>

		/// <exception cref="System.InvalidOperationException">

		/// If setInput () or deflate () were already called or another

		/// dictionary was already set.

		/// </exception>

		public void SetDictionary(byte[] dict, int offset, int length)

		{

			if (state != InitializeState)

			{

				throw new InvalidOperationException();

			}



			state = SetDictionaryState;

			engine.SetDictionary(dict, offset, length);

		}

		#endregion

	}

}