/*
* CVS identifier:
*
* $Id: ByteInputBuffer.java,v 1.13 2001/10/17 17:01:57 grosbois Exp $
*
* Class:                   ByteInputBuffer
*
* Description:             Provides buffering for byte based input, similar
*                          to the standard class ByteArrayInputStream
*
*                          the old jj2000.j2k.io.ByteArrayInput class by
*                          Diego SANTA CRUZ, Apr-26-1999
*
*
* 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;
namespace CSJ2K.j2k.entropy.decoder
{
	
	/// <summary> This class provides a byte input facility from byte buffers. It is similar
	/// to the ByteArrayInputStream class, but adds the possibility to add data to
	/// the stream after the creation of the object.
	/// 
	/// <p>Unlike the ByteArrayInputStream this class is not thread safe (i.e. no
	/// two threads can use the same object at the same time, but different objects
	/// may be used in different threads).</p>
	/// 
	/// <p>This class can modify the contents of the buffer given to the
	/// constructor, when the addByteArray() method is called.</p>
	/// 
	/// </summary>
	/// <seealso cref="InputStream">
	/// 
	/// </seealso>
	public class ByteInputBuffer
	{
		
		/// <summary>The byte array containing the data </summary>
		private byte[] buf;
		
		/// <summary>The index one greater than the last valid character in the input
		/// stream buffer 
		/// </summary>
		private int count;
		
		/// <summary>The index of the next character to read from the input stream buffer
		/// 
		/// </summary>
		private int pos;
		
		/// <summary> Creates a new byte array input stream that reads data from the
		/// specified byte array. The byte array is not copied.
		/// 
		/// </summary>
		/// <param name="buf">the input buffer.
		/// 
		/// </param>
		public ByteInputBuffer(byte[] buf)
		{
			this.buf = buf;
			count = buf.Length;
		}
		
		/// <summary> Creates a new byte array input stream that reads data from the
		/// specified byte array. Up to length characters are to be read from the
		/// byte array, starting at the indicated offset.
		/// 
		/// <p>The byte array is not copied.</p>
		/// 
		/// </summary>
		/// <param name="buf">the input buffer.
		/// 
		/// </param>
		/// <param name="offset">the offset in the buffer of the first byte to read.
		/// 
		/// </param>
		/// <param name="length">the maximum number of bytes to read from the buffer.
		/// 
		/// </param>
		public ByteInputBuffer(byte[] buf, int offset, int length)
		{
			this.buf = buf;
			pos = offset;
			count = offset + length;
		}
		
		/// <summary> Sets the underlying buffer byte array to the given one, with the given
		/// offset and length. If 'buf' is null then the current byte buffer is
		/// assumed. If 'offset' is negative, then it will be assumed to be
		/// 'off+len', where 'off' and 'len' are the offset and length of the
		/// current byte buffer.
		/// 
		/// <p>The byte array is not copied.</p>
		/// 
		/// </summary>
		/// <param name="buf">the input buffer. If null it is the current input buffer.
		/// 
		/// </param>
		/// <param name="offset">the offset in the buffer of the first byte to read. If
		/// negative it is assumed to be the byte just after the end of the current
		/// input buffer, only permitted if 'buf' is null.
		/// 
		/// </param>
		/// <param name="length">the maximum number of bytes to read frmo the buffer.
		/// 
		/// </param>
		public virtual void  setByteArray(byte[] buf, int offset, int length)
		{
			// In same buffer?
			if (buf == null)
			{
				if (length < 0 || count + length > this.buf.Length)
				{
					throw new System.ArgumentException();
				}
				if (offset < 0)
				{
					pos = count;
					count += length;
				}
				else
				{
					count = offset + length;
					pos = offset;
				}
			}
			else
			{
				// New input buffer
				if (offset < 0 || length < 0 || offset + length > buf.Length)
				{
					throw new System.ArgumentException();
				}
				this.buf = buf;
				count = offset + length;
				pos = offset;
			}
		}
		
		/// <summary> Adds the specified data to the end of the byte array stream. This
		/// method modifies the byte array buffer. It can also discard the already
		/// read input.
		/// 
		/// </summary>
		/// <param name="data">The data to add. The data is copied.
		/// 
		/// </param>
		/// <param name="off">The index, in data, of the first element to add to the
		/// stream.
		/// 
		/// </param>
		/// <param name="len">The number of elements to add to the array.
		/// 
		/// </param>
		//UPGRADE_NOTE: Synchronized keyword was removed from method 'addByteArray'. Lock expression was added. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1027'"
		public virtual void  addByteArray(byte[] data, int off, int len)
		{
			lock (this)
			{
				// Check integrity
				if (len < 0 || off < 0 || len + off > buf.Length)
				{
					throw new System.ArgumentException();
				}
				// Copy new data
				if (count + len <= buf.Length)
				{
					// Enough place in 'buf'
					Array.Copy(data, off, buf, count, len);
					count += len;
				}
				else
				{
					if (count - pos + len <= buf.Length)
					{
						// Enough place in 'buf' if we move input data
						// Move buffer
						Array.Copy(buf, pos, buf, 0, count - pos);
					}
					else
					{
						// Not enough place in 'buf', use new buffer
						byte[] oldbuf = buf;
						buf = new byte[count - pos + len];
						// Copy buffer
						Array.Copy(oldbuf, count, buf, 0, count - pos);
					}
					count -= pos;
					pos = 0;
					// Copy new data
					Array.Copy(data, off, buf, count, len);
					count += len;
				}
			}
		}
		
		/// <summary> Reads the next byte of data from this input stream. The value byte is
		/// returned as an int in the range 0 to 255. If no byte is available
		/// because the end of the stream has been reached, the EOFException
		/// exception is thrown.
		/// 
		/// <p>This method is not synchronized, so it is not thread safe.</p>
		/// 
		/// </summary>
		/// <returns> The byte read in the range 0-255.
		/// 
		/// </returns>
		/// <exception cref="EOFException">If the end of the stream is reached.
		/// 
		/// </exception>
		public virtual int readChecked()
		{
			if (pos < count)
			{
				return (int) buf[pos++] & 0xFF;
			}
			else
			{
				throw new System.IO.EndOfStreamException();
			}
		}
		
		/// <summary> Reads the next byte of data from this input stream. The value byte is
		/// returned as an int in the range 0 to 255. If no byte is available
		/// because the end of the stream has been reached, -1 is returned.
		/// 
		/// <p>This method is not synchronized, so it is not thread safe.</p>
		/// 
		/// </summary>
		/// <returns> The byte read in the range 0-255, or -1 if the end of stream
		/// has been reached.
		/// 
		/// </returns>
		public virtual int read()
		{
			if (pos < count)
			{
				return (int) buf[pos++] & 0xFF;
			}
			else
			{
				return - 1;
			}
		}
	}
}