001: /*
002: * $RCSfile: ByteToBitInput.java,v $
003: * $Revision: 1.1 $
004: * $Date: 2005/02/11 05:02:06 $
005: * $State: Exp $
006: *
007: * Class: ByteToBitInput
008: *
009: * Description: Adapter to perform bit based input from a byte
010: * based one.
011: *
012: *
013: *
014: * COPYRIGHT:
015: *
016: * This software module was originally developed by Raphaël Grosbois and
017: * Diego Santa Cruz (Swiss Federal Institute of Technology-EPFL); Joel
018: * Askelöf (Ericsson Radio Systems AB); and Bertrand Berthelot, David
019: * Bouchard, Félix Henry, Gerard Mozelle and Patrice Onno (Canon Research
020: * Centre France S.A) in the course of development of the JPEG2000
021: * standard as specified by ISO/IEC 15444 (JPEG 2000 Standard). This
022: * software module is an implementation of a part of the JPEG 2000
023: * Standard. Swiss Federal Institute of Technology-EPFL, Ericsson Radio
024: * Systems AB and Canon Research Centre France S.A (collectively JJ2000
025: * Partners) agree not to assert against ISO/IEC and users of the JPEG
026: * 2000 Standard (Users) any of their rights under the copyright, not
027: * including other intellectual property rights, for this software module
028: * with respect to the usage by ISO/IEC and Users of this software module
029: * or modifications thereof for use in hardware or software products
030: * claiming conformance to the JPEG 2000 Standard. Those intending to use
031: * this software module in hardware or software products are advised that
032: * their use may infringe existing patents. The original developers of
033: * this software module, JJ2000 Partners and ISO/IEC assume no liability
034: * for use of this software module or modifications thereof. No license
035: * or right to this software module is granted for non JPEG 2000 Standard
036: * conforming products. JJ2000 Partners have full right to use this
037: * software module for his/her own purpose, assign or donate this
038: * software module to any third party and to inhibit third parties from
039: * using this software module for non JPEG 2000 Standard conforming
040: * products. This copyright notice must be included in all copies or
041: * derivative works of this software module.
042: *
043: * Copyright (c) 1999/2000 JJ2000 Partners.
044: * */
045: package jj2000.j2k.entropy.decoder;
046:
047: import jj2000.j2k.io.*;
048:
049: /**
050: * This class provides an adapter to perform bit based input on byte based
051: * output obejcts that inherit from a 'ByteInputBuffer' class. This class also
052: * performs the bit unstuffing procedure specified for the 'selective
053: * arithmetic coding bypass' mode of the JPEG 2000 entropy coder.
054: * */
055: class ByteToBitInput {
056:
057: /** The byte based input */
058: ByteInputBuffer in;
059:
060: /** The bit buffer */
061: int bbuf;
062:
063: /** The position of the next bit to get from the byte buffer. When it is
064: * -1 the bit buffer is empty. */
065: int bpos = -1;
066:
067: /** Instantiates a new 'ByteToBitInput' object that uses 'in' as the
068: * underlying byte based input.
069: *
070: * @param in The underlying byte based input.
071: * */
072: ByteToBitInput(ByteInputBuffer in) {
073: this .in = in;
074: }
075:
076: /**
077: * Reads from the bit stream one bit. If 'bpos' is -1 then a byte is read
078: * and loaded into the bit buffer, from where the bit is read. If
079: * necessary the bit unstuffing will be applied.
080: *
081: * @return The read bit (0 or 1).
082: * */
083: final int readBit() {
084: if (bpos < 0) {
085: if ((bbuf & 0xFF) != 0xFF) { // Normal byte to read
086: bbuf = in.read();
087: bpos = 7;
088: } else { // Previous byte is 0xFF => there was bit stuffing
089: bbuf = in.read();
090: bpos = 6;
091: }
092: }
093: return (bbuf >> bpos--) & 0x01;
094: }
095:
096: /**
097: * Checks for past errors in the decoding process by verifying the byte
098: * padding with an alternating sequence of 0's and 1's. If an error is
099: * detected it means that the raw bit stream has been wrongly decoded or
100: * that the raw terminated segment length is too long. If no errors are
101: * detected it does not necessarily mean that the raw bit stream has been
102: * correctly decoded.
103: *
104: * @return True if errors are found, false otherwise.
105: * */
106: public boolean checkBytePadding() {
107: int seq; // Byte padding sequence in last byte
108:
109: // If there are no spare bits and bbuf is 0xFF (not EOF), then there
110: // is a next byte with bit stuffing that we must load.
111: if (bpos < 0 && (bbuf & 0xFF) == 0xFF) {
112: bbuf = in.read();
113: bpos = 6;
114: }
115:
116: // 1) Not yet read bits in the last byte must be an alternating
117: // sequence of 0s and 1s, starting with 0.
118: if (bpos >= 0) {
119: seq = bbuf & ((1 << (bpos + 1)) - 1);
120: if (seq != (0x55 >> (7 - bpos)))
121: return true;
122: }
123:
124: // 2) We must have already reached the last byte in the terminated
125: // segment, unless last bit read is LSB of FF in which case an encoder
126: // can output an extra byte which is smaller than 0x80.
127: if (bbuf != -1) {
128: if (bbuf == 0xFF && bpos == 0) {
129: if ((in.read() & 0xFF) >= 0x80)
130: return true;
131: } else {
132: if (in.read() != -1)
133: return true;
134: }
135: }
136:
137: // Nothing detected
138: return false;
139: }
140:
141: /**
142: * Flushes (i.e. empties) the bit buffer, without loading any new
143: * bytes. This realigns the input at the next byte boundary, if not
144: * already at one.
145: * */
146: final void flush() {
147: bbuf = 0; // reset any bit stuffing state
148: bpos = -1;
149: }
150:
151: /**
152: * Resets the underlying byte input to start a new segment. The bit buffer
153: * is flushed.
154: *
155: * @param buf The byte array containing the byte data. If null the
156: * current byte array is assumed.
157: *
158: * @param off The index of the first element in 'buf' to be decoded. If
159: * negative the byte just after the previous segment is assumed, only
160: * valid if 'buf' is null.
161: *
162: * @param len The number of bytes in 'buf' to be decoded. Any subsequent
163: * bytes are taken to be 0xFF.
164: * */
165: final void setByteArray(byte buf[], int off, int len) {
166: in.setByteArray(buf, off, len);
167: bbuf = 0; // reset any bit stuffing state
168: bpos = -1;
169: }
170:
171: }
|