/*
* CVS identifier:
*
* $Id: MQCoder.java,v 1.36 2002/01/10 10:31:28 grosbois Exp $
*
* Class:                   MQCoder
*
* Description:             Class that encodes a number of bits using the
*                          MQ arithmetic coder
*
*
*                          Diego SANTA CRUZ, Jul-26-1999 (improved speed)
*
* COPYRIGHT:
* 
* This software module was originally developed by Raphaël Grosbois and
* Diego Santa Cruz (Swiss Federal Institute of Technology-EPFL); Joel
* Askelöf (Ericsson Radio Systems AB); and Bertrand Berthelot, David
* Bouchard, Félix Henry, Gerard Mozelle and Patrice Onno (Canon Research
* Centre France S.A) in the course of development of the JPEG2000
* standard as specified by ISO/IEC 15444 (JPEG 2000 Standard). This
* software module is an implementation of a part of the JPEG 2000
* Standard. Swiss Federal Institute of Technology-EPFL, Ericsson Radio
* Systems AB and Canon Research Centre France S.A (collectively JJ2000
* Partners) agree not to assert against ISO/IEC and users of the JPEG
* 2000 Standard (Users) any of their rights under the copyright, not
* including other intellectual property rights, for this software module
* with respect to the usage by ISO/IEC and Users of this software module
* or modifications thereof for use in hardware or software products
* claiming conformance to the JPEG 2000 Standard. Those intending to use
* this software module in hardware or software products are advised that
* their use may infringe existing patents. The original developers of
* this software module, JJ2000 Partners and ISO/IEC assume no liability
* for use of this software module or modifications thereof. No license
* or right to this software module is granted for non JPEG 2000 Standard
* conforming products. JJ2000 Partners have full right to use this
* software module for his/her own purpose, assign or donate this
* software module to any third party and to inhibit third parties from
* using this software module for non JPEG 2000 Standard conforming
* products. This copyright notice must be included in all copies or
* derivative works of this software module.
* 
* Copyright (c) 1999/2000 JJ2000 Partners.
* */
using System;
using CSJ2K.j2k.entropy.encoder;
using CSJ2K.j2k.entropy;
using CSJ2K.j2k.util;
using CSJ2K.j2k;
namespace CSJ2K.j2k.entropy.encoder
{
	
	/// <summary> This class implements the MQ arithmetic coder. When initialized a specific
	/// state can be specified for each context, which may be adapted to the
	/// probability distribution that is expected for that context.
	/// 
	/// <p>The type of length calculation and termination can be chosen at
	/// construction time.
	/// 
	/// ---- Tricks that have been tried to improve speed ----
	/// 
	/// <p>1) Merging Qe and mPS and doubling the lookup tables<br>
	/// 
	/// Merge the mPS into Qe, as the sign bit (if Qe>=0 the sense of MPS is 0, if
	/// Qe<0 the sense is 1), and double the lookup tables. The first half of the
	/// lookup tables correspond to Qe>=0 (i.e. the sense of MPS is 0) and the
	/// second half to Qe<0 (i.e. the sense of MPS is 1). The nLPS lookup table is
	/// modified to incorporate the changes in the sense of MPS, by making it jump
	/// from the first to the second half and vice-versa, when a change is
	/// specified by the swicthLM lookup table. See JPEG book, section 13.2, page
	/// 225. <br>
	/// 
	/// There is NO speed improvement in doing this, actually there is a slight
	/// decrease, probably due to the fact that often Q has to be negated. Also the
	/// fact that a brach of the type "if (bit==mPS[li])" is replaced by two
	/// simpler braches of the type "if (bit==0)" and "if (q<0)" may contribute to
	/// that.</p>
	/// 
	/// <p>2) Removing cT<br>
	/// 
	/// It is possible to remove the cT counter by setting a flag bit in the high
	/// bits of the C register. This bit will be automatically shifted left
	/// whenever a renormalization shift occurs, which is equivalent to decreasing
	/// cT. When the flag bit reaches the sign bit (leftmost bit), which is
	/// equivalenet to cT==0, the byteOut() procedure is called. This test can be
	/// done efficiently with "c<0" since C is a signed quantity. Care must be
	/// taken in byteOut() to reset the bit in order to not interfere with other
	/// bits in the C register. See JPEG book, page 228.<br>
	/// 
	/// There is NO speed improvement in doing this. I don't really know why since
	/// the number of operations whenever a renormalization occurs is
	/// decreased. Maybe it is due to the number of extra operations in the
	/// byteOut(), terminate() and getNumCodedBytes() procedures.</p>
	/// 
	/// <p>3) Change the convention of MPS and LPS.<br>
	/// 
	/// Making the LPS interval be above the MPS interval (MQ coder convention is
	/// the opposite) can reduce the number of operations along the MPS path. In
	/// order to generate the same bit stream as with the MQ convention the output
	/// bytes need to be modified accordingly. The basic rule for this is that C =
	/// (C'^0xFF...FF)-A, where C is the codestream for the MQ convention and C' is
	/// the codestream generated by this other convention. Note that this affects
	/// bit-stuffing as well.<br>
	/// 
	/// This has not been tested yet.<br>
	/// 
	/// <p>4) Removing normalization while loop on MPS path<br>
	/// 
	/// Since in the MPS path Q is guaranteed to be always greater than 0x4000
	/// (decimal 0.375) it is never necessary to do more than 1 renormalization
	/// shift. Therefore the test of the while loop, and the loop itself, can be
	/// removed.</p>
	/// 
	/// <p>5) Simplifying test on A register<br>
	/// 
	/// Since A is always less than or equal to 0xFFFF, the test "(a & 0x8000)==0"
	/// can be replaced by the simplete test "a < 0x8000". This test is simpler in
	/// Java since it involves only 1 operation (although the original test can be
	/// converted to only one operation by  smart Just-In-Time compilers)<br>
	/// 
	/// This change has been integrated in the decoding procedures.</p>
	/// 
	/// <p>6) Speedup mode<br>
	/// 
	/// Implemented a method that uses the speedup mode of the MQ-coder if
	/// possible. This should greately improve performance when coding long runs of 
	/// MPS symbols that have high probability. However, to take advantage of this, 
	/// the entropy coder implementation has to explicetely use it. The generated
	/// bit stream is the same as if no speedup mode would have been used.<br>
	/// 
	/// Implemented but performance not tested yet.</p>
	/// 
	/// <p>7) Multiple-symbol coding<br>
	/// 
	/// Since the time spent in a method call is non-negligable, coding several
	/// symbols with one method call reduces the overhead per coded symbol. The
	/// decodeSymbols() method implements this. However, to take advantage of it,
	/// the implementation of the entropy coder has to explicitely use it.<br>
	/// 
	/// Implemented but performance not tested yet.</p>
	/// 
	/// </summary>
	public class MQCoder
	{
		/// <summary> Set the length calculation type to the specified type.
		/// 
		/// </summary>
		/// <param name="ltype">The type of length calculation to use. One of
		/// 'LENGTH_LAZY', 'LENGTH_LAZY_GOOD' or 'LENGTH_NEAR_OPT'.
		/// 
		/// </param>
		virtual public int LenCalcType
		{
			set
			{
				// Verify the ttype and ltype
				if (value != LENGTH_LAZY && value != LENGTH_LAZY_GOOD && value != LENGTH_NEAR_OPT)
				{
					throw new System.ArgumentException("Unrecognized length " + "calculation type code: " + value);
				}
				
				if (value == LENGTH_NEAR_OPT)
				{
					if (savedC == null)
						savedC = new int[SAVED_LEN];
					if (savedCT == null)
						savedCT = new int[SAVED_LEN];
					if (savedA == null)
						savedA = new int[SAVED_LEN];
					if (savedB == null)
						savedB = new int[SAVED_LEN];
					if (savedDelFF == null)
						savedDelFF = new bool[SAVED_LEN];
				}
				this.ltype = value;
			}
			
		}
		/// <summary> Set termination type to the specified type.
		/// 
		/// </summary>
		/// <param name="ttype">The type of termination to use. One of 'TERM_FULL',
		/// 'TERM_NEAR_OPT', 'TERM_EASY' or 'TERM_PRED_ER'.
		/// 
		/// </param>
		virtual public int TermType
		{
			set
			{
				if (value != TERM_FULL && value != TERM_NEAR_OPT && value != TERM_EASY && value != TERM_PRED_ER)
				{
					throw new System.ArgumentException("Unrecognized termination " + "type code: " + value);
				}
				this.ttype = value;
			}
			
		}
		/// <summary> Returns the number of contexts in the arithmetic coder.
		/// 
		/// </summary>
		/// <returns> The number of contexts
		/// 
		/// </returns>
		virtual public int NumCtxts
		{
			get
			{
				return I.Length;
			}
			
		}
		/// <summary> Returns the number of bytes that are necessary from the compressed
		/// output stream to decode all the symbols that have been coded this
		/// far. The number of returned bytes does not include anything coded
		/// previous to the last time the 'terminate()' or 'reset()' methods where
		/// called.
		/// 
		/// <p>The values returned by this method are then to be used in finishing
		/// the length calculation with the 'finishLengthCalculation()' method,
		/// after compensation of the offset in the number of bytes due to previous
		/// terminated segments.</p>
		/// 
		/// <p>This method should not be called if the current coding pass is to be
		/// terminated. The 'terminate()' method should be called instead.</p>
		/// 
		/// <p>The calculation is done based on the type of length calculation
		/// specified at the constructor.</p>
		/// 
		/// </summary>
		/// <returns> The number of bytes in the compressed output stream necessary
		/// to decode all the information coded this far.
		/// 
		/// </returns>
		virtual public int NumCodedBytes
		{
			get
			{
				// NOTE: testing these algorithms for correctness is quite
				// difficult. One way is to modify the rate allocator so that not all
				// bit-planes are output if the distortion estimate for last passes is
				// the same as for the previous ones.
				
				switch (ltype)
				{
					
					case LENGTH_LAZY_GOOD: 
						// This one is a bit better than LENGTH_LAZY.
						int bitsInN3Bytes; // The minimum amount of bits that can be
						// stored in the 3 bytes following the current byte buffer 'b'.
						
						if (b >= 0xFE)
						{
							// The byte after b can have a bit stuffed so ther could be
							// one less bit available
							bitsInN3Bytes = 22; // 7 + 8 + 7
						}
						else
						{
							// We are sure that next byte after current byte buffer has no
							// bit stuffing
							bitsInN3Bytes = 23; // 8 + 7 + 8
						}
						if ((11 - cT + 16) <= bitsInN3Bytes)
						{
							return nrOfWrittenBytes + (delFF?1:0) + 1 + 3;
						}
						else
						{
							return nrOfWrittenBytes + (delFF?1:0) + 1 + 4;
						}
						//goto case LENGTH_LAZY;
					
					case LENGTH_LAZY: 
						// This is the very basic one that appears in the VM text
						if ((27 - cT) <= 22)
						{
							return nrOfWrittenBytes + (delFF?1:0) + 1 + 3;
						}
						else
						{
							return nrOfWrittenBytes + (delFF?1:0) + 1 + 4;
						}
						//goto case LENGTH_NEAR_OPT;
					
					case LENGTH_NEAR_OPT: 
						// This is the best length calculation implemented in this class.
						// It is almost always optimal. In order to calculate the length
						// it is necessary to know which bytes will follow in the MQ
						// bit stream, so we need to wait until termination to perform it.
						// Save the state to perform the calculation later, in
						// finishLengthCalculation()
						saveState();
						// Return current number of output bytes to use it later in
						// finishLengthCalculation()
						return nrOfWrittenBytes;
					
					default: 
						throw new System.ApplicationException("Illegal length calculation type code");
					
				}
			}
			
		}
		
		/// <summary>Identifier for the lazy length calculation. The lazy length
		/// calculation is not optimal but is extremely simple. 
		/// </summary>
		public const int LENGTH_LAZY = 0;
		
		/// <summary>Identifier for a very simple length calculation. This provides better
		/// results than the 'LENGTH_LAZY' computation. This is the old length
		/// calculation that was implemented in this class. 
		/// </summary>
		public const int LENGTH_LAZY_GOOD = 1;
		
		/// <summary>Identifier for the near optimal length calculation. This calculation
		/// is more complex than the lazy one but provides an almost optimal length 
		/// calculation. 
		/// </summary>
		public const int LENGTH_NEAR_OPT = 2;
		
		/// <summary>The identifier fort the termination that uses a full flush. This is
		/// the less efficient termination. 
		/// </summary>
		public const int TERM_FULL = 0;
		
		/// <summary>The identifier for the termination that uses the near optimal length
		/// calculation to terminate the arithmetic codewrod 
		/// </summary>
		public const int TERM_NEAR_OPT = 1;
		
		/// <summary>The identifier for the easy termination that is simpler than the
		/// 'TERM_NEAR_OPT' one but slightly less efficient. 
		/// </summary>
		public const int TERM_EASY = 2;
		
		/// <summary>The identifier for the predictable termination policy for error
		/// resilience. This is the same as the 'TERM_EASY' one but an special
		/// sequence of bits is embodied in the spare bits for error resilience
		/// purposes. 
		/// </summary>
		public const int TERM_PRED_ER = 3;
		
		/// <summary>The data structures containing the probabilities for the LPS </summary>
		//UPGRADE_NOTE: Final was removed from the declaration of 'qe'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
		internal static readonly int[] qe = new int[]{0x5601, 0x3401, 0x1801, 0x0ac1, 0x0521, 0x0221, 0x5601, 0x5401, 0x4801, 0x3801, 0x3001, 0x2401, 0x1c01, 0x1601, 0x5601, 0x5401, 0x5101, 0x4801, 0x3801, 0x3401, 0x3001, 0x2801, 0x2401, 0x2201, 0x1c01, 0x1801, 0x1601, 0x1401, 0x1201, 0x1101, 0x0ac1, 0x09c1, 0x08a1, 0x0521, 0x0441, 0x02a1, 0x0221, 0x0141, 0x0111, 0x0085, 0x0049, 0x0025, 0x0015, 0x0009, 0x0005, 0x0001, 0x5601};
		
		/// <summary>The indexes of the next MPS </summary>
		//UPGRADE_NOTE: Final was removed from the declaration of 'nMPS'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
		internal static readonly int[] nMPS = new int[]{1, 2, 3, 4, 5, 38, 7, 8, 9, 10, 11, 12, 13, 29, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 45, 46};
		
		/// <summary>The indexes of the next LPS </summary>
		//UPGRADE_NOTE: Final was removed from the declaration of 'nLPS'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
		internal static readonly int[] nLPS = new int[]{1, 6, 9, 12, 29, 33, 6, 14, 14, 14, 17, 18, 20, 21, 14, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46};
		
		/// <summary>Whether LPS and MPS should be switched </summary>
		//UPGRADE_NOTE: Final was removed from the declaration of 'switchLM'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
		internal static readonly int[] switchLM = new int[]{1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
		// Having ints proved to be more efficient than booleans
		
		/// <summary>The ByteOutputBuffer used to write the compressed bit stream. </summary>
		internal ByteOutputBuffer out_Renamed;
		
		/// <summary>The current most probable signal for each context </summary>
		internal int[] mPS;
		
		/// <summary>The current index of each context </summary>
		internal int[] I;
		
		/// <summary>The current bit code </summary>
		internal int c;
		
		/// <summary>The bit code counter </summary>
		internal int cT;
		
		/// <summary>The current interval </summary>
		internal int a;
		
		/// <summary>The last encoded byte of data </summary>
		internal int b;
		
		/// <summary>If a 0xFF byte has been delayed and not yet been written to the output 
		/// (in the MQ we can never have more than 1 0xFF byte in a row). 
		/// </summary>
		internal bool delFF;
		
		/// <summary>The number of written bytes so far, excluding any delayed 0xFF
		/// bytes. Upon initialization it is -1 to indicated that the byte buffer
		/// 'b' is empty as well. 
		/// </summary>
		internal int nrOfWrittenBytes = - 1;
		
		/// <summary>The initial state of each context </summary>
		internal int[] initStates;
		
		/// <summary>The termination type to use. One of 'TERM_FULL', 'TERM_NEAR_OPT',
		/// 'TERM_EASY' or 'TERM_PRED_ER'. 
		/// </summary>
		internal int ttype;
		
		/// <summary>The length calculation type to use. One of 'LENGTH_LAZY',
		/// 'LENGTH_LAZY_GOOD', 'LENGTH_NEAR_OPT'. 
		/// </summary>
		internal int ltype;
		
		/// <summary>Saved values of the C register. Used for the LENGTH_NEAR_OPT length
		/// calculation. 
		/// </summary>
		internal int[] savedC;
		
		/// <summary>Saved values of CT counter. Used for the LENGTH_NEAR_OPT length
		/// calculation. 
		/// </summary>
		internal int[] savedCT;
		
		/// <summary>Saved values of the A register. Used for the LENGTH_NEAR_OPT length
		/// calculation. 
		/// </summary>
		internal int[] savedA;
		
		/// <summary>Saved values of the B byte buffer. Used for the LENGTH_NEAR_OPT length
		/// calculation. 
		/// </summary>
		internal int[] savedB;
		
		/// <summary>Saved values of the delFF (i.e. delayed 0xFF) state. Used for the
		/// LENGTH_NEAR_OPT length calculation. 
		/// </summary>
		internal bool[] savedDelFF;
		
		/// <summary>Number of saved states. Used for the LENGTH_NEAR_OPT length
		/// calculation. 
		/// </summary>
		internal int nSaved;
		
		/// <summary>The initial length of the arrays to save sates </summary>
		//UPGRADE_NOTE: Final was removed from the declaration of 'SAVED_LEN '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
		internal static readonly int SAVED_LEN = 32 * CSJ2K.j2k.entropy.StdEntropyCoderOptions.NUM_PASSES;
		
		/// <summary>The increase in length for the arrays to save states </summary>
		//UPGRADE_NOTE: Final was removed from the declaration of 'SAVED_INC '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
		internal static readonly int SAVED_INC = 4 * CSJ2K.j2k.entropy.StdEntropyCoderOptions.NUM_PASSES;
		
		/// <summary> Instantiates a new MQ-coder, with the specified number of contexts and
		/// initial states. The compressed bytestream is written to the 'oStream'
		/// object.
		/// 
		/// </summary>
		/// <param name="oStream">where to output the compressed data.
		/// 
		/// </param>
		/// <param name="nrOfContexts">The number of contexts used by the MQ coder.
		/// 
		/// </param>
		/// <param name="init">The initial state for each context. A reference is kept to
		/// this array to reinitialize the contexts whenever 'reset()' or
		/// 'resetCtxts()' is called.
		/// 
		/// </param>
		public MQCoder(ByteOutputBuffer oStream, int nrOfContexts, int[] init)
		{
			out_Renamed = oStream;
			
			// --- INITENC
			
			// Default initialization of the statistics bins is MPS=0 and
			// I=0
			I = new int[nrOfContexts];
			mPS = new int[nrOfContexts];
			initStates = init;
			
			a = 0x8000;
			c = 0;
			if (b == 0xFF)
			{
				cT = 13;
			}
			else
			{
				cT = 12;
			}
			
			resetCtxts();
			
			// End of INITENC ---
			b = 0;
		}
		
		/// <summary> This method performs the coding of the symbol 'bit', using context
		/// 'ctxt', 'n' times, using the MQ-coder speedup mode if possible.
		/// 
		/// <p>If the symbol 'bit' is the current more probable symbol (MPS) and
		/// qe[ctxt]<=0x4000, and (A-0x8000)>=qe[ctxt], speedup mode will be
		/// used. Otherwise the normal mode will be used. The speedup mode can
		/// significantly improve the speed of arithmetic coding when several MPS
		/// symbols, with a high probability distribution, must be coded with the
		/// same context. The generated bit stream is the same as if the normal mode
		/// was used.</p>
		/// 
		/// <p>This method is also faster than the 'codeSymbols()' and
		/// 'codeSymbol()' ones, for coding the same symbols with the same context
		/// several times, when speedup mode can not be used, although not
		/// significantly.</p>
		/// 
		/// </summary>
		/// <param name="bit">The symbol do code, 0 or 1.
		/// 
		/// </param>
		/// <param name="ctxt">The context to us in coding the symbol.
		/// 
		/// </param>
		/// <param name="n">The number of times that the symbol must be coded.
		/// 
		/// </param>
		public void  fastCodeSymbols(int bit, int ctxt, int n)
		{
			int q; // cache for context's Qe
			int la; // cache for A register
			int nc; // counter for renormalization shifts
			int ns; // the maximum length of a speedup mode run
			int li; // cache for I[ctxt]
			
			li = I[ctxt]; // cache current index
			q = qe[li]; // retrieve current LPS prob.
			
			if ((q <= 0x4000) && (bit == mPS[ctxt]) && ((ns = (a - 0x8000) / q + 1) > 1))
			{
				// Do speed up mode
				// coding MPS, no conditional exchange can occur and
				// speedup mode is possible for more than 1 symbol
				do 
				{
					// do as many speedup runs as necessary
					if (n <= ns)
					{
						// All symbols in this run
						// code 'n' symbols
						la = n * q; // accumulated Q
						a -= la;
						c += la;
						if (a >= 0x8000)
						{
							// no renormalization
							I[ctxt] = li; // save the current state
							return ; // done
						}
						I[ctxt] = nMPS[li]; // goto next state and save it
						// -- Renormalization (MPS: no need for while loop)
						a <<= 1; // a is doubled
						c <<= 1; // c is doubled
						cT--;
						if (cT == 0)
						{
							byteOut();
						}
						// -- End of renormalization
						return ; // done
					}
					else
					{
						// Not all symbols in this run
						// code 'ns' symbols
						la = ns * q; // accumulated Q
						c += la;
						a -= la;
						// cache li and q for next iteration
						li = nMPS[li];
						q = qe[li]; // New q is always less than current one
						// new I[ctxt] is stored in last run
						// Renormalization always occurs since we exceed 'ns'
						// -- Renormalization (MPS: no need for while loop)
						a <<= 1; // a is doubled
						c <<= 1; // c is doubled
						cT--;
						if (cT == 0)
						{
							byteOut();
						}
						// -- End of renormalization
						n -= ns; // symbols left to code
						ns = (a - 0x8000) / q + 1; // max length of next speedup run
						continue; // goto next iteration
					}
				}
				while (n > 0);
			}
			// end speed up mode
			else
			{
				// No speedup mode
				// Either speedup mode is not possible or not worth doing it
				// because of probable conditional exchange
				// Code everything as in normal mode
				la = a; // cache A register in local variable
				do 
				{
					if (bit == mPS[ctxt])
					{
						// -- code MPS
						la -= q; // Interval division associated with MPS coding
						if (la >= 0x8000)
						{
							// Interval big enough
							c += q;
						}
						else
						{
							// Interval too short
							if (la < q)
							{
								// Probabilities are inverted
								la = q;
							}
							else
							{
								c += q;
							}
							// cache new li and q for next iteration
							li = nMPS[li];
							q = qe[li];
							// new I[ctxt] is stored after end of loop
							// -- Renormalization (MPS: no need for while loop)
							la <<= 1; // a is doubled
							c <<= 1; // c is doubled
							cT--;
							if (cT == 0)
							{
								byteOut();
							}
							// -- End of renormalization
						}
					}
					else
					{
						// -- code LPS
						la -= q; // Interval division according to LPS coding
						if (la < q)
						{
							c += q;
						}
						else
						{
							la = q;
						}
						if (switchLM[li] != 0)
						{
							mPS[ctxt] = 1 - mPS[ctxt];
						}
						// cache new li and q for next iteration
						li = nLPS[li];
						q = qe[li];
						// new I[ctxt] is stored after end of loop
						// -- Renormalization
						// sligthly better than normal loop
						nc = 0;
						do 
						{
							la <<= 1;
							nc++; // count number of necessary shifts
						}
						while (la < 0x8000);
						if (cT > nc)
						{
							c <<= nc;
							cT -= nc;
						}
						else
						{
							do 
							{
								c <<= cT;
								nc -= cT;
								// cT = 0; // not necessary
								byteOut();
							}
							while (cT <= nc);
							c <<= nc;
							cT -= nc;
						}
						// -- End of renormalization
					}
					n--;
				}
				while (n > 0);
				I[ctxt] = li; // store new I[ctxt]
				a = la; // save cached A register
			}
		}
		
		/// <summary> This function performs the arithmetic encoding of several symbols
		/// together. The function receives an array of symbols that are to be
		/// encoded and an array containing the contexts with which to encode them.
		/// 
		/// <p>The advantage of using this function is that the cost of the method
		/// call is amortized by the number of coded symbols per method call.</p>
		/// 
		/// <p>Each context has a current MPS and an index describing what the 
		/// current probability is for the LPS. Each bit is encoded and if the
		/// probability of the LPS exceeds .5, the MPS and LPS are switched.</p>
		/// 
		/// </summary>
		/// <param name="bits">An array containing the symbols to be encoded. Valid
		/// symbols are 0 and 1.
		/// 
		/// </param>
		/// <param name="cX">The context for each of the symbols to be encoded.
		/// 
		/// </param>
		/// <param name="n">The number of symbols to encode.
		/// 
		/// </param>
		public void  codeSymbols(int[] bits, int[] cX, int n)
		{
			int q;
			int li; // local cache of I[context]
			int la;
			int nc;
			int ctxt; // context of current symbol
			int i; // counter
			
			// NOTE: here we could use symbol aggregation to speed things up.
			// It remains to be studied.
			
			la = a; // cache A register in local variable
			for (i = 0; i < n; i++)
			{
				// NOTE: (a<0x8000) is equivalent to ((a&0x8000)==0)
				// since 'a' is always less than or equal to 0xFFFF
				
				// NOTE: conditional exchange guarantees that A for MPS is
				// always greater than 0x4000 (i.e. 0.375)
				// => one renormalization shift is enough for MPS
				// => no need to do a renormalization while loop for MPS
				
				ctxt = cX[i];
				li = I[ctxt];
				q = qe[li]; // Retrieve current LPS prob.
				
				if (bits[i] == mPS[ctxt])
				{
					// -- Code MPS
					
					la -= q; // Interval division associated with MPS coding
					
					if (la >= 0x8000)
					{
						// Interval big enough
						c += q;
					}
					else
					{
						// Interval too short
						if (la < q)
						{
							// Probabilities are inverted
							la = q;
						}
						else
						{
							c += q;
						}
						
						I[ctxt] = nMPS[li];
						
						// -- Renormalization (MPS: no need for while loop)
						la <<= 1; // a is doubled
						c <<= 1; // c is doubled
						cT--;
						if (cT == 0)
						{
							byteOut();
						}
						// -- End of renormalization
					}
				}
				else
				{
					// -- Code LPS
					la -= q; // Interval division according to LPS coding
					
					if (la < q)
					{
						c += q;
					}
					else
					{
						la = q;
					}
					if (switchLM[li] != 0)
					{
						mPS[ctxt] = 1 - mPS[ctxt];
					}
					I[ctxt] = nLPS[li];
					
					// -- Renormalization
					
					// sligthly better than normal loop
					nc = 0;
					do 
					{
						la <<= 1;
						nc++; // count number of necessary shifts
					}
					while (la < 0x8000);
					if (cT > nc)
					{
						c <<= nc;
						cT -= nc;
					}
					else
					{
						do 
						{
							c <<= cT;
							nc -= cT;
							// cT = 0; // not necessary
							byteOut();
						}
						while (cT <= nc);
						c <<= nc;
						cT -= nc;
					}
					
					// -- End of renormalization
				}
			}
			a = la; // save cached A register
		}
		
		
		/// <summary> This function performs the arithmetic encoding of one symbol. The 
		/// function receives a bit that is to be encoded and a context with which
		/// to encode it.
		/// 
		/// <p>Each context has a current MPS and an index describing what the 
		/// current probability is for the LPS. Each bit is encoded and if the
		/// probability of the LPS exceeds .5, the MPS and LPS are switched.</p>
		/// 
		/// </summary>
		/// <param name="bit">The symbol to be encoded, must be 0 or 1.
		/// 
		/// </param>
		/// <param name="context">the context with which to encode the symbol.
		/// 
		/// </param>
		public void  codeSymbol(int bit, int context)
		{
			int q;
			int li; // local cache of I[context]
			int la;
			int n;
			
			// NOTE: (a < 0x8000) is equivalent to ((a & 0x8000)==0)
			// since 'a' is always less than or equal to 0xFFFF
			
			// NOTE: conditional exchange guarantees that A for MPS is
			// always greater than 0x4000 (i.e. 0.375)
			// => one renormalization shift is enough for MPS
			// => no need to do a renormalization while loop for MPS
			
			li = I[context];
			q = qe[li]; // Retrieve current LPS prob.
			
			if (bit == mPS[context])
			{
				// -- Code MPS
				
				a -= q; // Interval division associated with MPS coding
				
				if (a >= 0x8000)
				{
					// Interval big enough
					c += q;
				}
				else
				{
					// Interval too short
					if (a < q)
					{
						// Probabilities are inverted
						a = q;
					}
					else
					{
						c += q;
					}
					
					I[context] = nMPS[li];
					
					// -- Renormalization (MPS: no need for while loop)
					a <<= 1; // a is doubled
					c <<= 1; // c is doubled
					cT--;
					if (cT == 0)
					{
						byteOut();
					}
					// -- End of renormalization
				}
			}
			else
			{
				// -- Code LPS
				
				la = a; // cache A register in local variable
				la -= q; // Interval division according to LPS coding
				
				if (la < q)
				{
					c += q;
				}
				else
				{
					la = q;
				}
				if (switchLM[li] != 0)
				{
					mPS[context] = 1 - mPS[context];
				}
				I[context] = nLPS[li];
				
				// -- Renormalization
				
				// sligthly better than normal loop
				n = 0;
				do 
				{
					la <<= 1;
					n++; // count number of necessary shifts
				}
				while (la < 0x8000);
				if (cT > n)
				{
					c <<= n;
					cT -= n;
				}
				else
				{
					do 
					{
						c <<= cT;
						n -= cT;
						// cT = 0; // not necessary
						byteOut();
					}
					while (cT <= n);
					c <<= n;
					cT -= n;
				}
				
				// -- End of renormalization
				a = la; // save cached A register
			}
		}
		
		/// <summary> This function puts one byte of compressed bits in the output stream.
		/// The highest 8 bits of c are then put in b to be the next byte to
		/// write. This method delays the output of any 0xFF bytes until a non 0xFF
		/// byte has to be written to the output bit stream (the 'delFF' variable
		/// signals if there is a delayed 0xff byte).
		/// 
		/// </summary>
		private void  byteOut()
		{
			if (nrOfWrittenBytes >= 0)
			{
				if (b == 0xFF)
				{
					// Delay 0xFF byte
					delFF = true;
					b = SupportClass.URShift(c, 20);
					c &= 0xFFFFF;
					cT = 7;
				}
				else if (c < 0x8000000)
				{
					// Write delayed 0xFF bytes
					if (delFF)
					{
						out_Renamed.write(0xFF);
						delFF = false;
						nrOfWrittenBytes++;
					}
					out_Renamed.write(b);
					nrOfWrittenBytes++;
					b = SupportClass.URShift(c, 19);
					c &= 0x7FFFF;
					cT = 8;
				}
				else
				{
					b++;
					if (b == 0xFF)
					{
						// Delay 0xFF byte
						delFF = true;
						c &= 0x7FFFFFF;
						b = SupportClass.URShift(c, 20);
						c &= 0xFFFFF;
						cT = 7;
					}
					else
					{
						// Write delayed 0xFF bytes
						if (delFF)
						{
							out_Renamed.write(0xFF);
							delFF = false;
							nrOfWrittenBytes++;
						}
						out_Renamed.write(b);
						nrOfWrittenBytes++;
						b = ((SupportClass.URShift(c, 19)) & 0xFF);
						c &= 0x7FFFF;
						cT = 8;
					}
				}
			}
			else
			{
				// NOTE: carry bit can never be set if the byte buffer was empty
				b = (SupportClass.URShift(c, 19));
				c &= 0x7FFFF;
				cT = 8;
				nrOfWrittenBytes++;
			}
		}
		
		/// <summary> This function flushes the remaining encoded bits and makes sure that
		/// enough information is written to the bit stream to be able to finish
		/// decoding, and then it reinitializes the internal state of the MQ coder
		/// but without modifying the context states.
		/// 
		/// <p>After calling this method the 'finishLengthCalculation()' method
		/// should be called, after compensating the returned length for the length
		/// of previous coded segments, so that the length calculation is
		/// finalized.</p>
		/// 
		/// <p>The type of termination used depends on the one specified at the
		/// constructor.</p>
		/// 
		/// </summary>
		/// <returns> The length of the arithmetic codeword after termination, in
		/// bytes.
		/// 
		/// </returns>
		public virtual int terminate()
		{
			switch (ttype)
			{
				
				case TERM_FULL: 
					//sets the remaining bits of the last byte of the coded bits.
					int tempc = c + a;
					c = c | 0xFFFF;
					if (c >= tempc)
					{
						c = c - 0x8000;
					}
					
					int remainingBits = 27 - cT;
					
					// Flushes remainingBits
					do 
					{
						c <<= cT;
						if (b != 0xFF)
						{
							remainingBits -= 8;
						}
						else
						{
							remainingBits -= 7;
						}
						byteOut();
					}
					while (remainingBits > 0);
					
					b |= (1 << (- remainingBits)) - 1;
					if (b == 0xFF)
					{
						// Delay 0xFF bytes
						delFF = true;
					}
					else
					{
						// Write delayed 0xFF bytes
						if (delFF)
						{
							out_Renamed.write(0xFF);
							delFF = false;
							nrOfWrittenBytes++;
						}
						out_Renamed.write(b);
						nrOfWrittenBytes++;
					}
					break;
				
				case TERM_PRED_ER: 
				case TERM_EASY: 
					// The predictable error resilient and easy termination are the
					// same, except for the fact that the easy one can modify the
					// spare bits in the last byte to maximize the likelihood of
					// having a 0xFF, while the error resilient one can not touch
					// these bits.
					
					// In the predictable error resilient case the spare bits will be
					// recalculated by the decoder and it will check if they are the
					// same as as in the codestream and then deduce an error
					// probability from there.
					
					int k; // number of bits to push out
					
					k = (11 - cT) + 1;
					
					c <<= cT;
					for (; k > 0; k -= cT, c <<= cT)
					{
						byteOut();
					}
					
					// Make any spare bits 1s if in easy termination
					if (k < 0 && ttype == TERM_EASY)
					{
						// At this stage there is never a carry bit in C, so we can
						// freely modify the (-k) least significant bits.
						b |= (1 << (- k)) - 1;
					}
					
					byteOut(); // Push contents of byte buffer
					break;
				
				case TERM_NEAR_OPT: 
					
					// This algorithm terminates in the shortest possible way, besides 
					// the fact any previous 0xFF 0x7F sequences are not
					// eliminated. The probabalility of having those sequences is
					// extremely low.
					
					// The calculation of the length is based on the fact that the
					// decoder will pad the codestream with an endless string of
					// (binary) 1s. If the codestream, padded with 1s, is within the
					// bounds of the current interval then correct decoding is
					// guaranteed. The lower inclusive bound of the current interval
					// is the value of C (i.e. if only lower intervals would be coded
					// in the future). The upper exclusive bound of the current
					// interval is C+A (i.e. if only upper intervals would be coded in
					// the future). We therefore calculate the minimum length that
					// would be needed so that padding with 1s gives a codestream
					// within the interval.
					
					// In general, such a calculation needs the value of the next byte
					// that appears in the codestream. Here, since we are terminating,
					// the next value can be anything we want that lies within the
					// interval, we use the lower bound since this minimizes the
					// length. To calculate the necessary length at any other place
					// than the termination it is necessary to know the next bytes
					// that will appear in the codestream, which involves storing the
					// codestream and the sate of the MQCoder at various points (a
					// worst case approach can be used, but it is much more
					// complicated and the calculated length would be only marginally
					// better than much simple calculations, if not the same).
					
					int cLow;
					int cUp;
					int bLow;
					int bUp;
					
					// Initialize the upper (exclusive) and lower bound (inclusive) of 
					// the valid interval (the actual interval is the concatenation of 
					// bUp and cUp, and bLow and cLow).
					cLow = c;
					cUp = c + a;
					bLow = bUp = b;
					
					// We start by normalizing the C register to the sate cT = 0
					// (i.e., just before byteOut() is called)
					cLow <<= cT;
					cUp <<= cT;
					// Progate eventual carry bits and reset them in Clow, Cup NOTE:
					// carry bit can never be set if the byte buffer was empty so no
					// problem with propagating a carry into an empty byte buffer.
					if ((cLow & (1 << 27)) != 0)
					{
						// Carry bit in cLow
						if (bLow == 0xFF)
						{
							// We can not propagate carry bit, do bit stuffing
							delFF = true; // delay 0xFF
							// Get next byte buffer
							bLow = SupportClass.URShift(cLow, 20);
							bUp = SupportClass.URShift(cUp, 20);
							cLow &= 0xFFFFF;
							cUp &= 0xFFFFF;
							// Normalize to cT = 0
							cLow <<= 7;
							cUp <<= 7;
						}
						else
						{
							// we can propagate carry bit
							bLow++; // propagate
							cLow &= ~ (1 << 27); // reset carry in cLow
						}
					}
					if ((cUp & (1 << 27)) != 0)
					{
						bUp++; // propagate
						cUp &= ~ (1 << 27); // reset carry
					}
					
					// From now on there can never be a carry bit on cLow, since we
					// always output bLow.
					
					// Loop testing for the condition and doing byte output if they 
					// are not met.
					while (true)
					{
						// If decoder's codestream is within interval stop
						// If preceding byte is 0xFF only values [0,127] are valid
						if (delFF)
						{
							// If delayed 0xFF
							if (bLow <= 127 && bUp > 127)
								break;
							// We will write more bytes so output delayed 0xFF now
							out_Renamed.write(0xFF);
							nrOfWrittenBytes++;
							delFF = false;
						}
						else
						{
							// No delayed 0xFF
							if (bLow <= 255 && bUp > 255)
								break;
						}
						
						// Output next byte
						// We could output anything within the interval, but using
						// bLow simplifies things a lot.
						
						// We should not have any carry bit here
						
						// Output bLow
						if (bLow < 255)
						{
							// Transfer byte bits from C to B
							// (if the byte buffer was empty output nothing)
							if (nrOfWrittenBytes >= 0)
								out_Renamed.write(bLow);
							nrOfWrittenBytes++;
							bUp -= bLow;
							bUp <<= 8;
							// Here bLow would be 0
							bUp |= (SupportClass.URShift(cUp, 19)) & 0xFF;
							bLow = (SupportClass.URShift(cLow, 19)) & 0xFF;
							// Clear upper bits (just pushed out) from cUp Clow.
							cLow &= 0x7FFFF;
							cUp &= 0x7FFFF;
							// Goto next state where CT is 0
							cLow <<= 8;
							cUp <<= 8;
							// Here there can be no carry on Cup, Clow
						}
						else
						{
							// bLow = 0xFF
							// Transfer byte bits from C to B
							// Since the byte to output is 0xFF we can delay it
							delFF = true;
							bUp -= bLow;
							bUp <<= 7;
							// Here bLow would be 0
							bUp |= (cUp >> 20) & 0x7F;
							bLow = (cLow >> 20) & 0x7F;
							// Clear upper bits (just pushed out) from cUp Clow.
							cLow &= 0xFFFFF;
							cUp &= 0xFFFFF;
							// Goto next state where CT is 0
							cLow <<= 7;
							cUp <<= 7;
							// Here there can be no carry on Cup, Clow
						}
					}
					break;
				
				default: 
					throw new System.ApplicationException("Illegal termination type code");
				
			}
			
			// Reinitialize the state (without modifying the contexts)
			int len;
			
			len = nrOfWrittenBytes;
			a = 0x8000;
			c = 0;
			b = 0;
			cT = 12;
			delFF = false;
			nrOfWrittenBytes = - 1;
			
			// Return the terminated length
			return len;
		}
		
		/// <summary> Resets a context to the original probability distribution, and sets its
		/// more probable symbol to 0.
		/// 
		/// </summary>
		/// <param name="c">The number of the context (it starts at 0).
		/// 
		/// </param>
		public void  resetCtxt(int c)
		{
			I[c] = initStates[c];
			mPS[c] = 0;
		}
		
		/// <summary> Resets all contexts to their original probability distribution and sets
		/// all more probable symbols to 0.
		/// 
		/// </summary>
		public void  resetCtxts()
		{
			Array.Copy(initStates, 0, I, 0, I.Length);
			ArrayUtil.intArraySet(mPS, 0);
		}
		
		/// <summary> Reinitializes the MQ coder and the underlying 'ByteOutputBuffer' buffer
		/// as if a new object was instantaited. All the data in the
		/// 'ByteOutputBuffer' buffer is erased and the state and contexts of the
		/// MQ coder are reinitialized). Additionally any saved MQ states are
		/// discarded.
		/// 
		/// </summary>
		public void  reset()
		{
			
			// Reset the output buffer
			out_Renamed.reset();
			
			a = 0x8000;
			c = 0;
			b = 0;
			if (b == 0xFF)
				cT = 13;
			else
				cT = 12;
			resetCtxts();
			nrOfWrittenBytes = - 1;
			delFF = false;
			
			nSaved = 0;
		}
		
		/// <summary> Saves the current state of the MQ coder (just the registers, not the
		/// contexts) so that a near optimal length calculation can be performed
		/// later.
		/// 
		/// </summary>
		private void  saveState()
		{
			// Increase capacity if necessary
			if (nSaved == savedC.Length)
			{
				System.Object tmp;
				tmp = savedC;
				savedC = new int[nSaved + SAVED_INC];
                // CONVERSION PROBLEM?
				Array.Copy((System.Array)tmp, 0, savedC, 0, nSaved);
				tmp = savedCT;
				savedCT = new int[nSaved + SAVED_INC];
                Array.Copy((System.Array)tmp, 0, savedCT, 0, nSaved);
				tmp = savedA;
				savedA = new int[nSaved + SAVED_INC];
                Array.Copy((System.Array)tmp, 0, savedA, 0, nSaved);
				tmp = savedB;
				savedB = new int[nSaved + SAVED_INC];
                Array.Copy((System.Array)tmp, 0, savedB, 0, nSaved);
				tmp = savedDelFF;
				savedDelFF = new bool[nSaved + SAVED_INC];
                Array.Copy((System.Array)tmp, 0, savedDelFF, 0, nSaved);
			}
			// Save the current sate
			savedC[nSaved] = c;
			savedCT[nSaved] = cT;
			savedA[nSaved] = a;
			savedB[nSaved] = b;
			savedDelFF[nSaved] = delFF;
			nSaved++;
		}
		
		/// <summary> Terminates the calculation of the required length for each coding
		/// pass. This method must be called just after the 'terminate()' one has
		/// been called for each terminated MQ segment.
		/// 
		/// <p>The values in 'rates' must have been compensated for any offset due
		/// to previous terminated segments, so that the correct index to the
		/// stored coded data is used.</p>
		/// 
		/// </summary>
		/// <param name="rates">The array containing the values returned by
		/// 'getNumCodedBytes()' for each coding pass.
		/// 
		/// </param>
		/// <param name="n">The index in the 'rates' array of the last terminated length.
		/// 
		/// </param>
		public virtual void  finishLengthCalculation(int[] rates, int n)
		{
			if (ltype != LENGTH_NEAR_OPT)
			{
				// For the simple calculations the only thing we need to do is to
				// ensure that the calculated lengths are no greater than the
				// terminated one
				if (n > 0 && rates[n - 1] > rates[n])
				{
					// We need correction
					int tl = rates[n]; // The terminated length
					n--;
					do 
					{
						rates[n--] = tl;
					}
					while (n >= 0 && rates[n] > tl);
				}
			}
			else
			{
				// We need to perform the more sophisticated near optimal
				// calculation.
				
				// The calculation of the length is based on the fact that the
				// decoder will pad the codestream with an endless string of
				// (binary) 1s after termination. If the codestream, padded with
				// 1s, is within the bounds of the current interval then correct
				// decoding is guaranteed. The lower inclusive bound of the
				// current interval is the value of C (i.e. if only lower
				// intervals would be coded in the future). The upper exclusive
				// bound of the current interval is C+A (i.e. if only upper
				// intervals would be coded in the future). We therefore calculate
				// the minimum length that would be needed so that padding with 1s
				// gives a codestream within the interval.
				
				// In order to know what will be appended to the current base of
				// the interval we need to know what is in the MQ bit stream after
				// the current last output byte until the termination. This is why 
				// this calculation has to be performed after the MQ segment has
				// been entirely coded and terminated.
				
				int cLow; // lower bound on the C register for correct decoding
				int cUp; // upper bound on the C register for correct decoding
				int bLow; // lower bound on the byte buffer for correct decoding
				int bUp; // upper bound on the byte buffer for correct decoding
				int ridx; // index in the rates array of the pass we are
				// calculating
				int sidx; // index in the saved state array
				int clen; // current calculated length
				bool cdFF; // the current delayed FF state
				int nb; // the next byte of output
				int minlen; // minimum possible length
				int maxlen; // maximum possible length
				
				// Start on the first pass of this segment
				ridx = n - nSaved;
				// Minimum allowable length is length of previous termination
				minlen = (ridx - 1 >= 0)?rates[ridx - 1]:0;
				// Maximum possible length is the terminated length
				maxlen = rates[n];
				for (sidx = 0; ridx < n; ridx++, sidx++)
				{
					// Load the initial values of the bounds
					cLow = savedC[sidx];
					cUp = savedC[sidx] + savedA[sidx];
					bLow = savedB[sidx];
					bUp = savedB[sidx];
					// Normalize to cT=0 and propagate and reset any carry bits
					cLow <<= savedCT[sidx];
					if ((cLow & 0x8000000) != 0)
					{
						bLow++;
						cLow &= 0x7FFFFFF;
					}
					cUp <<= savedCT[sidx];
					if ((cUp & 0x8000000) != 0)
					{
						bUp++;
						cUp &= 0x7FFFFFF;
					}
					// Initialize current calculated length
					cdFF = savedDelFF[sidx];
					// rates[ridx] contains the number of bytes already output
					// when the state was saved, compensated for the offset in the 
					// output stream.
					clen = rates[ridx] + (cdFF?1:0);
					while (true)
					{
						// If we are at end of coded data then this is the length
						if (clen >= maxlen)
						{
							clen = maxlen;
							break;
						}
						// Check for sufficiency of coded data
						if (cdFF)
						{
							if (bLow < 128 && bUp >= 128)
							{
								// We are done for this pass
								clen--; // Don't need delayed FF
								break;
							}
						}
						else
						{
							if (bLow < 256 && bUp >= 256)
							{
								// We are done for this pass
								break;
							}
						}
						// Update bounds with next byte of coded data and
						// normalize to cT = 0 again.
						nb = (clen >= minlen)?out_Renamed.getByte(clen):0;
						bLow -= nb;
						bUp -= nb;
						clen++;
						if (nb == 0xFF)
						{
							bLow <<= 7;
							bLow |= (cLow >> 20) & 0x7F;
							cLow &= 0xFFFFF;
							cLow <<= 7;
							bUp <<= 7;
							bUp |= (cUp >> 20) & 0x7F;
							cUp &= 0xFFFFF;
							cUp <<= 7;
							cdFF = true;
						}
						else
						{
							bLow <<= 8;
							bLow |= (cLow >> 19) & 0xFF;
							cLow &= 0x7FFFF;
							cLow <<= 8;
							bUp <<= 8;
							bUp |= (cUp >> 19) & 0xFF;
							cUp &= 0x7FFFF;
							cUp <<= 8;
							cdFF = false;
						}
						// Test again
					}
					// Store the rate found
					rates[ridx] = (clen >= minlen)?clen:minlen;
				}
				// Reset the saved states
				nSaved = 0;
			}
		}
	}
}