/// <summary> Performs the magnitude refinement pass on the specified data and
/// bit-plane. It decodes the samples which are significant and which do
/// not have the "visited" state bit turned on, using the MR primitive. The
/// "visited" state bit is not mofified for any samples.
///
/// <P>This method bypasses the arithmetic coder and reads "raw" symbols
/// from the bit stream.
///
/// <P>This method also checks for segmentation markers if those are
/// present and returns true if an error is detected, or false
/// otherwise. If an error is detected it measn that the bit stream
/// contains some erroneous bit that have led to the decoding of incorrect
/// data. This data affects the whole last decoded bit-plane
/// (i.e. 'bp'). If 'true' is returned the 'conceal' method should be
/// called and no more passes should be decoded for this code-block's bit
/// stream.
///
/// </summary>
/// <param name="cblk">The code-block data to decode
///
/// </param>
/// <param name="bin">The raw bit based input
///
/// </param>
/// <param name="bp">The bit-plane to decode
///
/// </param>
/// <param name="state">The state information for the code-block
///
/// </param>
/// <param name="isterm">If this pass has been terminated. If the pass has been
/// terminated it can be used to check error resilience.
///
/// </param>
/// <returns> True if an error was detected in the bit stream, false
/// otherwise.
///
/// </returns>
private bool rawMagRefPass(DataBlk cblk, ByteToBitInput bin, int bp, int[] state, bool isterm)
{
int j, sj; // The state index for line and stripe
int k, sk; // The data index for line and stripe
int dscanw; // The data scan-width
int sscanw; // The state scan-width
int jstep; // Stripe to stripe step for 'sj'
int kstep; // Stripe to stripe step for 'sk'
int stopsk; // The loop limit on the variable sk
int csj; // Local copy (i.e. cached) of 'state[j]'
int setmask; // The mask to set lower bit-planes to 1/2 approximation
int resetmask; // The mask to reset approximation bit-planes
int sym; // The symbol to decode
int[] data; // The data buffer
int s; // The stripe index
int nstripes; // The number of stripes in the code-block
int sheight; // Height of the current stripe
bool error; // The error condition
// Initialize local variables
dscanw = cblk.scanw;
sscanw = cblk.w + 2;
jstep = sscanw * CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT / 2 - cblk.w;
kstep = dscanw * CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT - cblk.w;
setmask = (1 << bp) >> 1;
resetmask = (- 1) << (bp + 1);
data = (int[]) cblk.Data;
nstripes = (cblk.h + CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT - 1) / CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT;
// Decode stripe by stripe
sk = cblk.offset;
sj = sscanw + 1;
for (s = nstripes - 1; s >= 0; s--, sk += kstep, sj += jstep)
{
sheight = (s != 0)?CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT:cblk.h - (nstripes - 1) * CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT;
stopsk = sk + cblk.w;
// Scan by set of 1 stripe column at a time
for (; sk < stopsk; sk++, sj++)
{
// Do half top of column
j = sj;
csj = state[j];
// If any of the two samples is significant and not yet
// visited in the current bit-plane we can not skip them
if ((((SupportClass.URShift(csj, 1)) & (~ csj)) & VSTD_MASK_R1R2) != 0)
{
k = sk;
// Scan first row
if ((csj & (STATE_SIG_R1 | STATE_VISITED_R1)) == STATE_SIG_R1)
{
// Read raw bit (no MR primative)
sym = bin.readBit();
// Update the data
data[k] &= resetmask;
data[k] |= (sym << bp) | setmask;
// No need to set STATE_PREV_MR_R1 since all magnitude
// refinement passes to follow are "raw"
}
if (sheight < 2)
continue;
// Scan second row
if ((csj & (STATE_SIG_R2 | STATE_VISITED_R2)) == STATE_SIG_R2)
{
k += dscanw;
// Read raw bit (no MR primative)
sym = bin.readBit();
// Update the data
data[k] &= resetmask;
data[k] |= (sym << bp) | setmask;
// No need to set STATE_PREV_MR_R1 since all magnitude
// refinement passes to follow are "raw"
}
}
// Do half bottom of column
if (sheight < 3)
continue;
j += sscanw;
csj = state[j];
// If any of the two samples is significant and not yet
// visited in the current bit-plane we can not skip them
if ((((SupportClass.URShift(csj, 1)) & (~ csj)) & VSTD_MASK_R1R2) != 0)
{
k = sk + (dscanw << 1);
// Scan first row
if ((csj & (STATE_SIG_R1 | STATE_VISITED_R1)) == STATE_SIG_R1)
{
// Read raw bit (no MR primative)
sym = bin.readBit();
// Update the data
data[k] &= resetmask;
data[k] |= (sym << bp) | setmask;
// No need to set STATE_PREV_MR_R1 since all magnitude
// refinement passes to follow are "raw"
}
if (sheight < 4)
continue;
// Scan second row
if ((state[j] & (STATE_SIG_R2 | STATE_VISITED_R2)) == STATE_SIG_R2)
{
k += dscanw;
// Read raw bit (no MR primative)
sym = bin.readBit();
// Update the data
data[k] &= resetmask;
data[k] |= (sym << bp) | setmask;
// No need to set STATE_PREV_MR_R1 since all magnitude
// refinement passes to follow are "raw"
}
}
}
}
error = false;
// Check the byte padding if the pass is terminated and the
// predictable termination is signaled in COx marker.
if (isterm && (options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_PRED_TERM) != 0)
{
error = bin.checkBytePadding();
}
// Return error condition
return error;
}
/// <summary> Returns the specified code-block in the current tile for the specified
/// component, as a copy (see below).
///
/// <P>The returned code-block may be progressive, which is indicated by
/// the 'progressive' variable of the returned 'DataBlk' object. If a
/// code-block is progressive it means that in a later request to this
/// method for the same code-block it is possible to retrieve data which is
/// a better approximation, since meanwhile more data to decode for the
/// code-block could have been received. If the code-block is not
/// progressive then later calls to this method for the same code-block
/// will return the exact same data values.
///
/// <P>The data returned by this method is always a copy of the internal
/// data of this object, if any, and it can be modified "in place" without
/// any problems after being returned. The 'offset' of the returned data is
/// 0, and the 'scanw' is the same as the code-block width. See the
/// 'DataBlk' class.
///
/// <P>The 'ulx' and 'uly' members of the returned 'DataBlk' object
/// contain the coordinates of the top-left corner of the block, with
/// respect to the tile, not the subband.
///
/// </summary>
/// <param name="c">The component for which to return the next code-block.
///
/// </param>
/// <param name="m">The vertical index of the code-block to return, in the
/// specified subband.
///
/// </param>
/// <param name="n">The horizontal index of the code-block to return, in the
/// specified subband.
///
/// </param>
/// <param name="sb">The subband in which the code-block to return is.
///
/// </param>
/// <param name="cblk">If non-null this object will be used to return the new
/// code-block. If null a new one will be allocated and returned. If the
/// "data" array of the object is non-null it will be reused, if possible,
/// to return the data.
///
/// </param>
/// <returns> The next code-block in the current tile for component 'n', or
/// null if all code-blocks for the current tile have been returned.
///
/// </returns>
/// <seealso cref="DataBlk">
///
/// </seealso>
public override DataBlk getCodeBlock(int c, int m, int n, SubbandSyn sb, DataBlk cblk)
{
//long stime = 0L; // Start time for timed sections
int[] zc_lut; // The ZC lookup table to use
int[] out_data; // The outupt data buffer
int npasses; // The number of coding passes to perform
int curbp; // The current magnitude bit-plane (starts at 30)
bool error; // Error indicator
int tslen; // Length of first terminated segment
int tsidx; // Index of current terminated segment
ByteInputBuffer in_Renamed = null;
bool isterm;
// Get the code-block to decode
srcblk = src.getCodeBlock(c, m, n, sb, 1, - 1, srcblk);
#if DO_TIMING
stime = (System.DateTime.Now.Ticks - 621355968000000000) / 10000;
#endif
// Retrieve options from decSpec
options = ((System.Int32) decSpec.ecopts.getTileCompVal(tIdx, c));
// Reset state
ArrayUtil.intArraySet(state, 0);
// Initialize output code-block
if (cblk == null)
cblk = new DataBlkInt();
cblk.progressive = srcblk.prog;
cblk.ulx = srcblk.ulx;
cblk.uly = srcblk.uly;
cblk.w = srcblk.w;
cblk.h = srcblk.h;
cblk.offset = 0;
cblk.scanw = cblk.w;
out_data = (int[]) cblk.Data;
if (out_data == null || out_data.Length < srcblk.w * srcblk.h)
{
out_data = new int[srcblk.w * srcblk.h];
cblk.Data = out_data;
}
else
{
// Set data values to 0
ArrayUtil.intArraySet(out_data, 0);
}
if (srcblk.nl <= 0 || srcblk.nTrunc <= 0)
{
// 0 layers => no data to decode => return all 0s
return cblk;
}
// Get the length of the first terminated segment
tslen = (srcblk.tsLengths == null)?srcblk.dl:srcblk.tsLengths[0];
tsidx = 0;
// Initialize for decoding
npasses = srcblk.nTrunc;
if (mq == null)
{
in_Renamed = new ByteInputBuffer(srcblk.data, 0, tslen);
mq = new MQDecoder(in_Renamed, NUM_CTXTS, MQ_INIT);
}
else
{
// We always start by an MQ segment
mq.nextSegment(srcblk.data, 0, tslen);
mq.resetCtxts();
}
error = false;
if ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_BYPASS) != 0)
{
if (bin == null)
{
if (in_Renamed == null)
in_Renamed = mq.ByteInputBuffer;
bin = new ByteToBitInput(in_Renamed);
}
}
// Choose correct ZC lookup table for global orientation
switch (sb.orientation)
{
case Subband.WT_ORIENT_HL:
zc_lut = ZC_LUT_HL;
break;
case Subband.WT_ORIENT_LH:
case Subband.WT_ORIENT_LL:
zc_lut = ZC_LUT_LH;
break;
case Subband.WT_ORIENT_HH:
zc_lut = ZC_LUT_HH;
break;
default:
throw new System.ApplicationException("JJ2000 internal error");
}
// NOTE: we don't currently detect which is the last magnitude
// bit-plane so that 'isterm' is true for the last pass of it. Doing
// so would aid marginally in error detection with the predictable
// error resilient MQ termination. However, determining which is the
// last magnitude bit-plane is quite hard (due to ROI, quantization,
// etc.) and in any case the predictable error resilient termination
// used without the arithmetic coding bypass and/or regular
// termination modes is almost useless.
// Loop on bit-planes and passes
curbp = 30 - srcblk.skipMSBP;
// Check for maximum number of bitplanes quit condition
if (mQuit != - 1 && (mQuit * 3 - 2) < npasses)
{
npasses = mQuit * 3 - 2;
}
// First bit-plane has only the cleanup pass
if (curbp >= 0 && npasses > 0)
{
isterm = (options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0 || ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_BYPASS) != 0 && (31 - CSJ2K.j2k.entropy.StdEntropyCoderOptions.NUM_NON_BYPASS_MS_BP - srcblk.skipMSBP) >= curbp);
error = cleanuppass(cblk, mq, curbp, state, zc_lut, isterm);
npasses--;
if (!error || !doer)
curbp--;
}
// Other bit-planes have the three coding passes
if (!error || !doer)
{
while (curbp >= 0 && npasses > 0)
{
if ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_BYPASS) != 0 && (curbp < 31 - CSJ2K.j2k.entropy.StdEntropyCoderOptions.NUM_NON_BYPASS_MS_BP - srcblk.skipMSBP))
{
// Use bypass decoding mode (only all bit-planes
// after the first 4 bit-planes).
// Here starts a new raw segment
bin.setByteArray(null, - 1, srcblk.tsLengths[++tsidx]);
isterm = (options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0;
error = rawSigProgPass(cblk, bin, curbp, state, isterm);
npasses--;
if (npasses <= 0 || (error && doer))
break;
if ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0)
{
// Start a new raw segment
bin.setByteArray(null, - 1, srcblk.tsLengths[++tsidx]);
}
isterm = (options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0 || ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_BYPASS) != 0 && (31 - CSJ2K.j2k.entropy.StdEntropyCoderOptions.NUM_NON_BYPASS_MS_BP - srcblk.skipMSBP > curbp));
error = rawMagRefPass(cblk, bin, curbp, state, isterm);
}
else
{
// Do not use bypass decoding mode
if ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0)
{
// Here starts a new MQ segment
mq.nextSegment(null, - 1, srcblk.tsLengths[++tsidx]);
}
isterm = (options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0;
error = sigProgPass(cblk, mq, curbp, state, zc_lut, isterm);
npasses--;
if (npasses <= 0 || (error && doer))
break;
if ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0)
{
// Here starts a new MQ segment
mq.nextSegment(null, - 1, srcblk.tsLengths[++tsidx]);
}
isterm = (options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0 || ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_BYPASS) != 0 && (31 - CSJ2K.j2k.entropy.StdEntropyCoderOptions.NUM_NON_BYPASS_MS_BP - srcblk.skipMSBP > curbp));
error = magRefPass(cblk, mq, curbp, state, isterm);
}
npasses--;
if (npasses <= 0 || (error && doer))
break;
if ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0 || ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_BYPASS) != 0 && (curbp < 31 - CSJ2K.j2k.entropy.StdEntropyCoderOptions.NUM_NON_BYPASS_MS_BP - srcblk.skipMSBP)))
{
// Here starts a new MQ segment
mq.nextSegment(null, - 1, srcblk.tsLengths[++tsidx]);
}
isterm = (options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_TERM_PASS) != 0 || ((options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_BYPASS) != 0 && (31 - CSJ2K.j2k.entropy.StdEntropyCoderOptions.NUM_NON_BYPASS_MS_BP - srcblk.skipMSBP) >= curbp);
error = cleanuppass(cblk, mq, curbp, state, zc_lut, isterm);
npasses--;
if (error && doer)
break;
// Goto next bit-plane
curbp--;
}
}
// If an error ocurred conceal it
if (error && doer)
{
if (verber)
{
FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Error detected at bit-plane " + curbp + " in code-block (" + m + "," + n + "), sb_idx " + sb.sbandIdx + ", res. level " + sb.resLvl + ". Concealing...");
}
conceal(cblk, curbp);
}
#if DO_TIMING
time[c] += (System.DateTime.Now.Ticks - 621355968000000000) / 10000 - stime;
#endif
// Return decoded block
return cblk;
}
/// <summary> Performs the significance propagation pass on the specified data and
/// bit-plane. It decodes all insignificant samples which have, at least,
/// one of its immediate eight neighbors already significant, using the ZC
/// and SC primitives as needed. It toggles the "visited" state bit to 1
/// for all those samples.
///
/// <p>This method bypasses the arithmetic coder and reads "raw" symbols
/// from the bit stream.</p>
///
/// <p>This method also checks for segmentation markers if those are
/// present and returns true if an error is detected, or false
/// otherwise. If an error is detected it measn that the bit stream contains
/// some erroneous bit that have led to the decoding of incorrect
/// data. This data affects the whole last decoded bit-plane (i.e. 'bp'). If
/// 'true' is returned the 'conceal' method should be called and no more
/// passes should be decoded for this code-block's bit stream.</p>
///
/// </summary>
/// <param name="cblk">The code-block data to decode
///
/// </param>
/// <param name="bin">The raw bit based input
///
/// </param>
/// <param name="bp">The bit-plane to decode
///
/// </param>
/// <param name="state">The state information for the code-block
///
/// </param>
/// <param name="isterm">If this pass has been terminated. If the pass has been
/// terminated it can be used to check error resilience.
///
/// </param>
/// <returns> True if an error was detected in the bit stream, false
/// otherwise.
///
/// </returns>
private bool rawSigProgPass(DataBlk cblk, ByteToBitInput bin, int bp, int[] state, bool isterm)
{
int j, sj; // The state index for line and stripe
int k, sk; // The data index for line and stripe
int dscanw; // The data scan-width
int sscanw; // The state scan-width
int jstep; // Stripe to stripe step for 'sj'
int kstep; // Stripe to stripe step for 'sk'
int stopsk; // The loop limit on the variable sk
int csj; // Local copy (i.e. cached) of 'state[j]'
int setmask; // The mask to set current and lower bit-planes to 1/2
// approximation
int sym; // The symbol to code
int[] data; // The data buffer
int s; // The stripe index
bool causal; // Flag to indicate if stripe-causal context
// formation is to be used
int nstripes; // The number of stripes in the code-block
int sheight; // Height of the current stripe
int off_ul, off_ur, off_dr, off_dl; // offsets
bool error; // The error condition
// Initialize local variables
dscanw = cblk.scanw;
sscanw = cblk.w + 2;
jstep = sscanw * CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT / 2 - cblk.w;
kstep = dscanw * CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT - cblk.w;
setmask = (3 << bp) >> 1;
data = (int[]) cblk.Data;
nstripes = (cblk.h + CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT - 1) / CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT;
causal = (options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_VERT_STR_CAUSAL) != 0;
// Pre-calculate offsets in 'state' for diagonal neighbors
off_ul = - sscanw - 1; // up-left
off_ur = - sscanw + 1; // up-right
off_dr = sscanw + 1; // down-right
off_dl = sscanw - 1; // down-left
// Decode stripe by stripe
sk = cblk.offset;
sj = sscanw + 1;
for (s = nstripes - 1; s >= 0; s--, sk += kstep, sj += jstep)
{
sheight = (s != 0)?CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT:cblk.h - (nstripes - 1) * CSJ2K.j2k.entropy.StdEntropyCoderOptions.STRIPE_HEIGHT;
stopsk = sk + cblk.w;
// Scan by set of 1 stripe column at a time
for (; sk < stopsk; sk++, sj++)
{
// Do half top of column
j = sj;
csj = state[j];
// If any of the two samples is not significant and has a
// non-zero context (i.e. some neighbor is significant) we can
// not skip them
if ((((~ csj) & (csj << 2)) & SIG_MASK_R1R2) != 0)
{
k = sk;
// Scan first row
if ((csj & (STATE_SIG_R1 | STATE_NZ_CTXT_R1)) == STATE_NZ_CTXT_R1)
{
// Use zero coding
if (bin.readBit() != 0)
{
// Became significant
// Use sign coding
sym = bin.readBit();
// Update data
data[k] = (sym << 31) | setmask;
// Update state information (significant bit,
// visited bit, neighbor significant bit of
// neighbors, non zero context of neighbors, sign
// of neighbors)
if (!causal)
{
// If in causal mode do not change contexts of
// previous stripe.
state[j + off_ul] |= STATE_NZ_CTXT_R2 | STATE_D_DR_R2;
state[j + off_ur] |= STATE_NZ_CTXT_R2 | STATE_D_DL_R2;
}
// Update sign state information of neighbors
if (sym != 0)
{
csj |= STATE_SIG_R1 | STATE_VISITED_R1 | STATE_NZ_CTXT_R2 | STATE_V_U_R2 | STATE_V_U_SIGN_R2;
if (!causal)
{
// If in causal mode do not change
// contexts of previous stripe.
state[j - sscanw] |= STATE_NZ_CTXT_R2 | STATE_V_D_R2 | STATE_V_D_SIGN_R2;
}
state[j + 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_H_L_R1 | STATE_H_L_SIGN_R1 | STATE_D_UL_R2;
state[j - 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_H_R_R1 | STATE_H_R_SIGN_R1 | STATE_D_UR_R2;
}
else
{
csj |= STATE_SIG_R1 | STATE_VISITED_R1 | STATE_NZ_CTXT_R2 | STATE_V_U_R2;
if (!causal)
{
// If in causal mode do not change
// contexts of previous stripe.
state[j - sscanw] |= STATE_NZ_CTXT_R2 | STATE_V_D_R2;
}
state[j + 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_H_L_R1 | STATE_D_UL_R2;
state[j - 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_H_R_R1 | STATE_D_UR_R2;
}
}
else
{
csj |= STATE_VISITED_R1;
}
}
if (sheight < 2)
{
state[j] = csj;
continue;
}
if ((csj & (STATE_SIG_R2 | STATE_NZ_CTXT_R2)) == STATE_NZ_CTXT_R2)
{
k += dscanw;
// Use zero coding
if (bin.readBit() != 0)
{
// Became significant
// Use sign coding
sym = bin.readBit();
// Update data
data[k] = (sym << 31) | setmask;
// Update state information (significant bit,
// visited bit, neighbor significant bit of
// neighbors, non zero context of neighbors, sign
// of neighbors)
state[j + off_dl] |= STATE_NZ_CTXT_R1 | STATE_D_UR_R1;
state[j + off_dr] |= STATE_NZ_CTXT_R1 | STATE_D_UL_R1;
// Update sign state information of neighbors
if (sym != 0)
{
csj |= STATE_SIG_R2 | STATE_VISITED_R2 | STATE_NZ_CTXT_R1 | STATE_V_D_R1 | STATE_V_D_SIGN_R1;
state[j + sscanw] |= STATE_NZ_CTXT_R1 | STATE_V_U_R1 | STATE_V_U_SIGN_R1;
state[j + 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_D_DL_R1 | STATE_H_L_R2 | STATE_H_L_SIGN_R2;
state[j - 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_D_DR_R1 | STATE_H_R_R2 | STATE_H_R_SIGN_R2;
}
else
{
csj |= STATE_SIG_R2 | STATE_VISITED_R2 | STATE_NZ_CTXT_R1 | STATE_V_D_R1;
state[j + sscanw] |= STATE_NZ_CTXT_R1 | STATE_V_U_R1;
state[j + 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_D_DL_R1 | STATE_H_L_R2;
state[j - 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_D_DR_R1 | STATE_H_R_R2;
}
}
else
{
csj |= STATE_VISITED_R2;
}
}
state[j] = csj;
}
// Do half bottom of column
if (sheight < 3)
continue;
j += sscanw;
csj = state[j];
// If any of the two samples is not significant and has a
// non-zero context (i.e. some neighbor is significant) we can
// not skip them
if ((((~ csj) & (csj << 2)) & SIG_MASK_R1R2) != 0)
{
k = sk + (dscanw << 1);
// Scan first row
if ((csj & (STATE_SIG_R1 | STATE_NZ_CTXT_R1)) == STATE_NZ_CTXT_R1)
{
// Use zero coding
if (bin.readBit() != 0)
{
// Became significant
// Use sign coding
sym = bin.readBit();
// Update data
data[k] = (sym << 31) | setmask;
// Update state information (significant bit,
// visited bit, neighbor significant bit of
// neighbors, non zero context of neighbors, sign
// of neighbors)
state[j + off_ul] |= STATE_NZ_CTXT_R2 | STATE_D_DR_R2;
state[j + off_ur] |= STATE_NZ_CTXT_R2 | STATE_D_DL_R2;
// Update sign state information of neighbors
if (sym != 0)
{
csj |= STATE_SIG_R1 | STATE_VISITED_R1 | STATE_NZ_CTXT_R2 | STATE_V_U_R2 | STATE_V_U_SIGN_R2;
state[j - sscanw] |= STATE_NZ_CTXT_R2 | STATE_V_D_R2 | STATE_V_D_SIGN_R2;
state[j + 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_H_L_R1 | STATE_H_L_SIGN_R1 | STATE_D_UL_R2;
state[j - 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_H_R_R1 | STATE_H_R_SIGN_R1 | STATE_D_UR_R2;
}
else
{
csj |= STATE_SIG_R1 | STATE_VISITED_R1 | STATE_NZ_CTXT_R2 | STATE_V_U_R2;
state[j - sscanw] |= STATE_NZ_CTXT_R2 | STATE_V_D_R2;
state[j + 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_H_L_R1 | STATE_D_UL_R2;
state[j - 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_H_R_R1 | STATE_D_UR_R2;
}
}
else
{
csj |= STATE_VISITED_R1;
}
}
if (sheight < 4)
{
state[j] = csj;
continue;
}
// Scan second row
if ((csj & (STATE_SIG_R2 | STATE_NZ_CTXT_R2)) == STATE_NZ_CTXT_R2)
{
k += dscanw;
// Use zero coding
if (bin.readBit() != 0)
{
// Became significant
// Use sign coding
sym = bin.readBit();
// Update data
data[k] = (sym << 31) | setmask;
// Update state information (significant bit,
// visited bit, neighbor significant bit of
// neighbors, non zero context of neighbors, sign
// of neighbors)
state[j + off_dl] |= STATE_NZ_CTXT_R1 | STATE_D_UR_R1;
state[j + off_dr] |= STATE_NZ_CTXT_R1 | STATE_D_UL_R1;
// Update sign state information of neighbors
if (sym != 0)
{
csj |= STATE_SIG_R2 | STATE_VISITED_R2 | STATE_NZ_CTXT_R1 | STATE_V_D_R1 | STATE_V_D_SIGN_R1;
state[j + sscanw] |= STATE_NZ_CTXT_R1 | STATE_V_U_R1 | STATE_V_U_SIGN_R1;
state[j + 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_D_DL_R1 | STATE_H_L_R2 | STATE_H_L_SIGN_R2;
state[j - 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_D_DR_R1 | STATE_H_R_R2 | STATE_H_R_SIGN_R2;
}
else
{
csj |= STATE_SIG_R2 | STATE_VISITED_R2 | STATE_NZ_CTXT_R1 | STATE_V_D_R1;
state[j + sscanw] |= STATE_NZ_CTXT_R1 | STATE_V_U_R1;
state[j + 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_D_DL_R1 | STATE_H_L_R2;
state[j - 1] |= STATE_NZ_CTXT_R1 | STATE_NZ_CTXT_R2 | STATE_D_DR_R1 | STATE_H_R_R2;
}
}
else
{
csj |= STATE_VISITED_R2;
}
}
state[j] = csj;
}
}
}
error = false;
// Check the byte padding if the pass is terminated and if the error
// resilience predictable termination is signaled in COx marker.
if (isterm && (options & CSJ2K.j2k.entropy.StdEntropyCoderOptions.OPT_PRED_TERM) != 0)
{
error = bin.checkBytePadding();
}
// Return error condition
return error;
}