/*
* CVS identifier:
*
* $Id: MQDecoder.java,v 1.32 2001/10/17 16:58:00 grosbois Exp $
*
* Class:                   MQDecoder
*
* Description:             Class that encodes a number of bits using the
*                          MQ arithmetic decoder
*
*
*
* 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.decoder;
using CSJ2K.j2k.entropy;
using CSJ2K.j2k.io;
using CSJ2K.j2k.util;
namespace CSJ2K.j2k.entropy.decoder
{
	
	/// <summary> This class implements the MQ arithmetic decoder. It is implemented using
	/// the software conventions decoder for better performance (i.e. execution
	/// time performance). The initial states for each context of the MQ-coder are
	/// specified in the constructor.
	/// 
	/// </summary>
	
	// A trick to test for increased speed: merge the Qe and mPS into 1 thing by
	// using the sign bit of Qe to signal mPS (positive-or-0 is 0, negative is 1),
	// and doubling the Qe, nMPS and nLPS tables. This gets rid of the swicthLM
	// table since it can be integrated as special cases in the doubled nMPS and
	// nLPS tables. See the JPEG book, chapter 13. The decoded decision can be
	// calculated as (q>>>31).
	
	public class MQDecoder
	{
		/// <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 underlying 'ByteInputBuffer' from where the MQ coded input
		/// bytes are read.
		/// 
		/// </summary>
		/// <returns> The underlying ByteInputBuffer.
		/// 
		/// </returns>
		virtual public ByteInputBuffer ByteInputBuffer
		{
			get
			{
				return in_Renamed;
			}
			
		}
		
		/// <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 uint[] qe = new uint[]{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};
		
		/// <summary>The ByteInputBuffer used to read the compressed bit stream. </summary>
		internal ByteInputBuffer in_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 uint c;
		
		/// <summary>The bit code counter </summary>
		internal uint cT;
		
		/// <summary>The current interval </summary>
		internal uint a;
		
		/// <summary>The last byte read </summary>
		internal uint b;
		
		/// <summary>Flag indicating if a marker has been found </summary>
		internal bool markerFound;
		
		/// <summary>The initial state of each context </summary>
		//UPGRADE_NOTE: Final was removed from the declaration of 'initStates '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
		internal int[] initStates;
		
		/// <summary> Instantiates a new MQ-decoder, with the specified number of contexts
		/// and initial states. The compressed bytestream is read from the
		/// 'iStream' object.
		/// 
		/// </summary>
		/// <param name="iStream">the stream that contains the coded bits 
		/// 
		/// </param>
		/// <param name="nrOfContexts">The number of contexts used
		/// 
		/// </param>
		/// <param name="initStates">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 MQDecoder(ByteInputBuffer iStream, int nrOfContexts, int[] initStates)
		{
			in_Renamed = iStream;
			
			// Default initialization of the statistics bins is MPS=0 and
			// I=0
			I = new int[nrOfContexts];
			mPS = new int[nrOfContexts];
			// Save the initial states
			this.initStates = initStates;
			
			// Initialize
			init();
			
			// Set the contexts
			resetCtxts();
		}
		
		/// <summary> Decodes 'n' symbols from the bit stream using the same context
		/// 'ctxt'. If possible the MQ-coder speedup mode will be used to speed up
		/// decoding. The speedup mode is used if Q (the LPS probability for 'ctxt'
		/// is low enough) and the A and C registers permit decoding several MPS
		/// symbols without renormalization.
		/// 
		/// <P>Speedup mode should be used when decoding long runs of MPS with high
		/// probability with the same context.
		/// 
		/// <P>This methiod will return the decoded symbols differently if speedup 
		/// mode was used or not. If true is returned, then speedup mode was used
		/// and the 'n' decoded symbols are all the same and it is returned ain
		/// bits[0] only. If false is returned then speedup mode was not used, the
		/// decoded symbols are probably not all the same and they are returned in
		/// bits[0], bits[1], ... bits[n-1].
		/// 
		/// </summary>
		/// <param name="bits">The array where to put the decoded symbols. Must be of
		/// length 'n' or more.
		/// 
		/// </param>
		/// <param name="ctxt">The context to use in decoding the symbols.
		/// 
		/// </param>
		/// <param name="n">The number of symbols to decode.
		/// 
		/// </param>
		/// <returns> True if speedup mode was used, false if not. If speedup mode
		/// was used then all the decoded symbols are the same and its value is
		/// returned in 'bits[0]' only (not in bits[1], bits[2], etc.).
		/// 
		/// </returns>
		internal bool fastDecodeSymbols(int[] bits, int ctxt, uint n)
		{
			uint q; // LPS probability for context
			int idx; // Index of current state
			uint la; // cache for A register
			int i; // counter
			
			idx = I[ctxt];
			q = qe[idx];
			
			// This is a first attempt to implement speedup mode, it is probably
			// not the most efficient way of doing it.
			
			if ((q < 0x4000) && (n <= (a - (c >> 16) - 1) / q) && (n <= (a - 0x8000) / q + 1))
			{
				// Q is small enough. There will be no modification of C that
				// affects decoding, and Q can be substracted from A several
				// times. We will decode all MPS.
				a -= n * q;
				if (a >= 0x8000)
				{
					// No renormalization needed
					bits[0] = mPS[ctxt];
					return true; // Done, used speedup mode
				}
				else
				{
					// renormalization needed
					I[ctxt] = nMPS[idx];
					// Renormalize (MPS: no need for while loop)
					if (cT == 0)
						byteIn();
					a <<= 1;
					c <<= 1;
					cT--;
					// End renormalization
					bits[0] = mPS[ctxt];
					return true; // Done, used speedup mode
				}
			}
			else
			{
				// Normal mode
				la = a; // cache A register
				for (i = 0; i < n; i++)
				{
					la -= q;
					if ((c >> 16) < la)
					{
						if (la >= 0x8000)
						{
							bits[i] = mPS[ctxt];
						}
						else
						{
							// -- MPS Exchange
							if (la >= q)
							{
								bits[i] = mPS[ctxt];
								idx = nMPS[idx];
								q = qe[idx];
								// I[ctxt] set at end of loop
								// -- Renormalize (MPS: no need for while loop)
								if (cT == 0)
									byteIn();
								la <<= 1;
								c <<= 1;
								cT--;
								// -- End renormalization
							}
							else
							{
								bits[i] = 1 - mPS[ctxt];
								if (switchLM[idx] == 1)
									mPS[ctxt] = 1 - mPS[ctxt];
								idx = nLPS[idx];
								q = qe[idx];
								// I[ctxt] set at end of loop
								// -- Renormalize
								do 
								{
									if (cT == 0)
										byteIn();
									la <<= 1;
									c <<= 1;
									cT--;
								}
								while (la < 0x8000);
								// -- End renormalization
							}
							// -- End MPS Exchange
						}
					}
					else
					{
						c -= (la << 16);
						// -- LPS Exchange
						if (la < q)
						{
							la = q;
							bits[i] = mPS[ctxt];
							idx = nMPS[idx];
							q = qe[idx];
							// I[ctxt] set at end of loop
							// -- Renormalize (MPS: no need for while loop)
							if (cT == 0)
								byteIn();
							la <<= 1;
							c <<= 1;
							cT--;
							// -- End renormalization
						}
						else
						{
							la = q;
							bits[i] = 1 - mPS[ctxt];
							if (switchLM[idx] == 1)
								mPS[ctxt] = 1 - mPS[ctxt];
							idx = nLPS[idx];
							q = qe[idx];
							// I[ctxt] set at end of loop
							// -- Renormalize
							do 
							{
								if (cT == 0)
									byteIn();
								la <<= 1;
								c <<= 1;
								cT--;
							}
							while (la < 0x8000);
							// -- End renormalization
						}
						// -- End LPS Exchange
					}
				}
				a = la; // save cached A register
				I[ctxt] = idx; // save current index for context
				return false; // done, did not use speedup mode
			} // End normal mode
		}
		
		/// <summary> This function performs the arithmetic decoding. The function receives 
		/// an array in which to put the decoded symbols and an array of contexts 
		/// with which to decode them. 
		/// 
		/// <P>Each context has a current MPS and an index describing what the
		/// current probability is for the LPS. Each bit is decoded and if the
		/// probability of the LPS exceeds .5, the MPS and LPS are switched.
		/// 
		/// </summary>
		/// <param name="bits">The array where to place the decoded symbols. It should be
		/// long enough to contain 'n' elements.
		/// 
		/// </param>
		/// <param name="cX">The context to use in decoding each symbol.
		/// 
		/// </param>
		/// <param name="n">The number of symbols to decode
		/// 
		/// </param>
		public void  decodeSymbols(int[] bits, int[] cX, int n)
		{
			uint q;
			int ctxt;
			uint la; // cache for A register value
			int index;
			int 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
			
			for (i = 0; i < n; i++)
			{
				ctxt = cX[i];
				
				index = I[ctxt];
				q = qe[index];
				
				a -= q;
				if ((c >> 16) < a)
				{
					if (a >= 0x8000)
					{
						bits[i] = mPS[ctxt];
					}
					else
					{
						la = a;
						// -- MPS Exchange
						if (la >= q)
						{
							bits[i] = mPS[ctxt];
							I[ctxt] = nMPS[index];
							// -- Renormalize (MPS: no need for while loop)
							if (cT == 0)
								byteIn();
							la <<= 1;
							c <<= 1;
							cT--;
							// -- End renormalization
						}
						else
						{
							bits[i] = 1 - mPS[ctxt];
							if (switchLM[index] == 1)
								mPS[ctxt] = 1 - mPS[ctxt];
							I[ctxt] = nLPS[index];
							// -- Renormalize
							do 
							{
								if (cT == 0)
									byteIn();
								la <<= 1;
								c <<= 1;
								cT--;
							}
							while (la < 0x8000);
							// -- End renormalization
						}
						// -- End MPS Exchange
						a = la;
					}
				}
				else
				{
					la = a;
					c -= (la << 16);
					// -- LPS Exchange
					if (la < q)
					{
						la = q;
						bits[i] = mPS[ctxt];
						I[ctxt] = nMPS[index];
						// -- Renormalize (MPS: no need for while loop)
						if (cT == 0)
							byteIn();
						la <<= 1;
						c <<= 1;
						cT--;
						// -- End renormalization
					}
					else
					{
						la = q;
						bits[i] = 1 - mPS[ctxt];
						if (switchLM[index] == 1)
							mPS[ctxt] = 1 - mPS[ctxt];
						I[ctxt] = nLPS[index];
						// -- Renormalize
						do 
						{
							if (cT == 0)
								byteIn();
							la <<= 1;
							c <<= 1;
							cT--;
						}
						while (la < 0x8000);
						// -- End renormalization
					}
					// -- End LPS Exchange
					
					a = la;
				}
			}
		}
		
		
		/// <summary> Arithmetically decodes one symbol from the bit stream with the given
		/// context and returns its decoded value.
		/// 
		/// <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.
		/// 
		/// </summary>
		/// <param name="context">The context to use in decoding the symbol
		/// 
		/// </param>
		/// <returns> The decoded symbol, 0 or 1.
		/// 
		/// </returns>
		public int decodeSymbol(int context)
		{
			uint q;
			uint la;
			int index;
			int decision;
			
			index = I[context];
			q = qe[index];
			
			// 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
			
			a -= q;
            if ((c >> 16) < a)
			{
				if (a >= 0x8000)
				{
					decision = mPS[context];
				}
				else
				{
					la = a;
					// -- MPS Exchange
					if (la >= q)
					{
						decision = mPS[context];
						I[context] = nMPS[index];
						// -- Renormalize (MPS: no need for while loop)
						if (cT == 0)
							byteIn();
						la <<= 1;
						c <<= 1;
						cT--;
						// -- End renormalization
					}
					else
					{
						decision = 1 - mPS[context];
						if (switchLM[index] == 1)
							mPS[context] = 1 - mPS[context];
						I[context] = nLPS[index];
						// -- Renormalize
						do 
						{
							if (cT == 0)
								byteIn();
							la <<= 1;
							c <<= 1;
							cT--;
						}
						while (la < 0x8000);
						// -- End renormalization
					}
					// -- End MPS Exchange
					a = la;
				}
			}
			else
			{
				la = a;
				c -= (la << 16);
				// -- LPS Exchange
				if (la < q)
				{
					la = q;
					decision = mPS[context];
					I[context] = nMPS[index];
					// -- Renormalize (MPS: no need for while loop)
					if (cT == 0)
						byteIn();
					la <<= 1;
					c <<= 1;
					cT--;
					// -- End renormalization
				}
				else
				{
					la = q;
					decision = 1 - mPS[context];
					if (switchLM[index] == 1)
						mPS[context] = 1 - mPS[context];
					I[context] = nLPS[index];
					// -- Renormalize
					do 
					{
						if (cT == 0)
							byteIn();
						la <<= 1;
						c <<= 1;
						cT--;
					}
					while (la < 0x8000);
					// -- End renormalization
				}
				// -- End LPS Exchange
				
				a = la;
			}
			return decision;
		}
		
		/// <summary> Checks for past errors in the decoding process using the predictable
		/// error resilient termination. This works only if the encoder used the
		/// predictable error resilient MQ termination, otherwise it reports wrong
		/// results. If an error is detected it means that the MQ bit stream has
		/// been wrongly decoded or that the MQ terminated segment length is too
		/// long. If no errors are detected it does not necessarily mean that the
		/// MQ bit stream has been correctly decoded.
		/// 
		/// </summary>
		/// <returns> True if errors are found, false otherwise.
		/// 
		/// </returns>
		public virtual bool checkPredTerm()
		{
			int k; // Number of bits that where added in the termination process
			uint q;
			
			// 1) if everything has been OK, 'b' must be 0xFF if a terminating
			// marker has not yet been found
			if (b != 0xFF && !markerFound)
				return true;
			
			// 2) if cT is not 0, we must have already reached the terminating
			// marker
			if (cT != 0 && !markerFound)
				return true;
			
			// 3) If cT is 1 there where no spare bits at the encoder, this is all
			// that we can check
			if (cT == 1)
				return false;
			
			// 4) if cT is 0, then next byte must be the second byte of a
			// terminating marker (i.e. larger than 0x8F) if the terminating
			// marker has not been reached yet
			if (cT == 0)
			{
				if (!markerFound)
				{
					// Get next byte and check
					b = (uint)in_Renamed.read() & 0xFF;
					if (b <= 0x8F)
						return true;
				}
				// Adjust cT for last byte
				cT = 8;
			}
			
			// 5) Now we can calculate the number 'k' of bits having error
			// resilience information, which is the number of bits left to
			// normalization in the C register, minus 1.
			k = (int)(cT - 1);
			
			// 6) The predictable termination policy is as if an LPS interval was
			// coded that caused a renormalization of 'k' bits, before the
			// termination marker started
			
			// We first check if an LPS is decoded, that causes a renormalization
			// of 'k' bits. Worst case is smallest LPS probability 'q' that causes
			// a renormalization of 'k' bits.
			q = ((uint)0x8000) >> k;
			
			// Check that we can decode an LPS interval of probability 'q'
			a -= q;
			if ((c >> 16) < a)
			{
				// Error: MPS interval decoded
				return true;
			}
			// OK: LPS interval decoded
			c -= (a << 16);
			// -- LPS Exchange
			// Here 'a' can not be smaller than 'q' because the minimum value
			// for 'a' is 0x8000-0x4000=0x4000 and 'q' is set to a value equal
			// to or smaller than that.
			a = q;
			// -- Renormalize
			do 
			{
				if (cT == 0)
					byteIn();
				a <<= 1;
				c <<= 1;
				cT--;
			}
			while (a < 0x8000);
			// -- End renormalization
			// -- End LPS Exchange
			
			// 7) Everything seems OK, we have checked the C register for the LPS
			// symbols and ensured that it is followed by bits synthetized by the
			// termination marker.
			return false;
		}
		
		/// <summary> This function gets one byte of compressed bits from the in-stream.  the
		/// byte is added to c. If the byte is 0xFF and the next byte is greater
		/// than 0x8F, the byte after 0xFF is a marker.
		/// 
		/// </summary>
		private void  byteIn()
		{
			if (!markerFound)
			{
				if (b == 0xFF)
				{
					b = ((uint)in_Renamed.read()) & 0xFF; // Convert EOFs (-1) to 0xFF
					
					if (b > 0x8F)
					{
						markerFound = true;
						// software-convention decoder: c unchanged
						cT = 8;
					}
					else
					{
						c += 0xFE00 - (b << 9);
						cT = 7;
					}
				}
				else
				{
					b = ((uint)in_Renamed.read()) & 0xFF; // Convert EOFs (-1) to 0xFF
					c += 0xFF00 - (b << 8);
					cT = 8;
				}
			}
			else
			{
				// software-convention decoder: c unchanged
				cT = 8;
			}
		}
		
		/// <summary> Resets a context to the original probability distribution.
		/// 
		/// </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 a context to the original probability distribution. The original
		/// probability distribution depends on the actual implementation of the
		/// arithmetic coder or decoder.
		/// 
		/// </summary>
		/// <param name="c">The index of the context (it starts at 0).
		/// 
		/// </param>
		public void  resetCtxts()
		{
			Array.Copy(initStates, 0, I, 0, I.Length);
			ArrayUtil.intArraySet(mPS, 0);
		}
		
		/// <summary> Resets the MQ decoder to start a new segment. This is like recreating a
		/// new MQDecoder object with new input data.
		/// 
		/// </summary>
		/// <param name="buf">The byte array containing the MQ encoded data. If null the
		/// current byte array is assumed.
		/// 
		/// </param>
		/// <param name="off">The index of the first element in 'buf' to be decoded. If
		/// negative the byte just after the previous segment is assumed, only
		/// valid if 'buf' is null.
		/// 
		/// </param>
		/// <param name="len">The number of bytes in 'buf' to be decoded. Any subsequent
		/// bytes are taken to be 0xFF.
		/// 
		/// </param>
		public void  nextSegment(byte[] buf, int off, int len)
		{
			// Set the new input
			in_Renamed.setByteArray(buf, off, len);
			// Reinitialize MQ
			init();
		}
		
		/// <summary> Initializes the state of the MQ coder, without modifying the current
		/// context states. It sets the registers (A,C,B) and the "marker found"
		/// state to the initial state, to start the decoding of a new segment.
		/// 
		/// <P>To have a complete reset of the MQ (as if a new MQDecoder object was
		/// created) 'resetCtxts()' should be called after this method.
		/// 
		/// </summary>
		private void  init()
		{
			// --- INITDEC
			markerFound = false;
			
			// Read first byte
			b = ((uint)in_Renamed.read()) & 0xFF;
			
			// Software conventions decoder
			c = (b ^ 0xFF) << 16;
			byteIn();
			c = c << 7;
			cT = cT - 7;
			a = 0x8000;
			
			// End of INITDEC ---
		}
	}
}