corrade-vassal – Rev 1
?pathlinks?
/*
* CVS identifier:
*
* $Id: ByteToBitInput.java,v 1.14 2002/07/19 12:41:33 grosbois Exp $
*
* Class: ByteToBitInput
*
* Description: Adapter to perform bit based input from a byte
* based one.
*
*
*
* 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.io;
namespace CSJ2K.j2k.entropy.decoder
{
/// <summary> This class provides an adapter to perform bit based input on byte based
/// output obejcts that inherit from a 'ByteInputBuffer' class. This class also
/// performs the bit unstuffing procedure specified for the 'selective
/// arithmetic coding bypass' mode of the JPEG 2000 entropy coder.
///
/// </summary>
public class ByteToBitInput
{
/// <summary>The byte based input </summary>
internal ByteInputBuffer in_Renamed;
/// <summary>The bit buffer </summary>
internal int bbuf;
/// <summary>The position of the next bit to get from the byte buffer. When it is
/// -1 the bit buffer is empty.
/// </summary>
internal int bpos = - 1;
/// <summary> Instantiates a new 'ByteToBitInput' object that uses 'in' as the
/// underlying byte based input.
///
/// </summary>
/// <param name="in">The underlying byte based input.
///
/// </param>
public ByteToBitInput(ByteInputBuffer in_Renamed)
{
this.in_Renamed = in_Renamed;
}
/// <summary> Reads from the bit stream one bit. If 'bpos' is -1 then a byte is read
/// and loaded into the bit buffer, from where the bit is read. If
/// necessary the bit unstuffing will be applied.
///
/// </summary>
/// <returns> The read bit (0 or 1).
///
/// </returns>
public int readBit()
{
if (bpos < 0)
{
if ((bbuf & 0xFF) != 0xFF)
{
// Normal byte to read
bbuf = in_Renamed.read();
bpos = 7;
}
else
{
// Previous byte is 0xFF => there was bit stuffing
bbuf = in_Renamed.read();
bpos = 6;
}
}
return (bbuf >> bpos--) & 0x01;
}
/// <summary> Checks for past errors in the decoding process by verifying the byte
/// padding with an alternating sequence of 0's and 1's. If an error is
/// detected it means that the raw bit stream has been wrongly decoded or
/// that the raw terminated segment length is too long. If no errors are
/// detected it does not necessarily mean that the raw bit stream has been
/// correctly decoded.
///
/// </summary>
/// <returns> True if errors are found, false otherwise.
///
/// </returns>
public virtual bool checkBytePadding()
{
int seq; // Byte padding sequence in last byte
// If there are no spare bits and bbuf is 0xFF (not EOF), then there
// is a next byte with bit stuffing that we must load.
if (bpos < 0 && (bbuf & 0xFF) == 0xFF)
{
bbuf = in_Renamed.read();
bpos = 6;
}
// 1) Not yet read bits in the last byte must be an alternating
// sequence of 0s and 1s, starting with 0.
if (bpos >= 0)
{
seq = bbuf & ((1 << (bpos + 1)) - 1);
if (seq != (0x55 >> (7 - bpos)))
return true;
}
// 2) We must have already reached the last byte in the terminated
// segment, unless last bit read is LSB of FF in which case an encoder
// can output an extra byte which is smaller than 0x80.
if (bbuf != - 1)
{
if (bbuf == 0xFF && bpos == 0)
{
if ((in_Renamed.read() & 0xFF) >= 0x80)
return true;
}
else
{
if (in_Renamed.read() != - 1)
return true;
}
}
// Nothing detected
return false;
}
/// <summary> Flushes (i.e. empties) the bit buffer, without loading any new
/// bytes. This realigns the input at the next byte boundary, if not
/// already at one.
///
/// </summary>
internal void flush()
{
bbuf = 0; // reset any bit stuffing state
bpos = - 1;
}
/// <summary> Resets the underlying byte input to start a new segment. The bit buffer
/// is flushed.
///
/// </summary>
/// <param name="buf">The byte array containing the byte 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>
internal void setByteArray(byte[] buf, int off, int len)
{
in_Renamed.setByteArray(buf, off, len);
bbuf = 0; // reset any bit stuffing state
bpos = - 1;
}
}
}
Generated by GNU Enscript 1.6.5.90.