/**
* Converts the floating point value to its exponent-mantissa representation. The mantissa
* occupies the 11 least significant bits (bits 10-0), and the exponent the previous 5 bits (bits
* 15-11).
*
* @param step The quantization step, normalized to a dynamic range of 1.
* @return The exponent mantissa representation of the step.
*/
public static int convertToExpMantissa(float step) {
int exp;
exp = (int) Math.ceil(-Math.log(step) / log2);
if (exp > QSTEP_MAX_EXPONENT) {
// If step size is too small for exponent representation, use the
// minimum, which is exponent QSTEP_MAX_EXPONENT and mantissa 0.
return (QSTEP_MAX_EXPONENT << QSTEP_MANTISSA_BITS);
}
// NOTE: this formula does not support more than 5 bits for the
// exponent, otherwise (-1<<exp) might overflow (the - is used to be
// able to represent 2**31)
return (exp << QSTEP_MANTISSA_BITS)
| ((int) ((-step * (-1 << exp) - 1f) * (1 << QSTEP_MANTISSA_BITS) + 0.5f));
}
/**
* Returns the maximum number of magnitude bits in any subband in the given tile-component if
* derived quantization is used
*
* @param sb The root of the subband tree of the tile-component
* @param t Tile index
* @param c Component index
* @return The highest number of magnitude bit-planes
*/
private int getMaxMagBitsDerived(Subband sb, int t, int c) {
int tmp, max = 0;
int g = ((Integer) gbs.getTileCompVal(t, c)).intValue();
if (!sb.isNode) {
float baseStep = ((Float) qsss.getTileCompVal(t, c)).floatValue();
return g - 1 + sb.level - (int) Math.floor(Math.log(baseStep) / log2);
}
max = getMaxMagBitsDerived(sb.getLL(), t, c);
tmp = getMaxMagBitsDerived(sb.getLH(), t, c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsDerived(sb.getHL(), t, c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsDerived(sb.getHH(), t, c);
if (tmp > max) max = tmp;
return max;
}
/**
* Returns the maximum number of magnitude bits in any subband in the given tile-component if
* expounded quantization is used
*
* @param sb The root of the subband tree of the tile-component
* @param t Tile index
* @param c Component index
* @return The highest number of magnitude bit-planes
*/
private int getMaxMagBitsExpounded(Subband sb, int t, int c) {
int tmp, max = 0;
int g = ((Integer) gbs.getTileCompVal(t, c)).intValue();
if (!sb.isNode) {
float baseStep = ((Float) qsss.getTileCompVal(t, c)).floatValue();
return g
- 1
- (int)
Math.floor(
Math.log(baseStep / (((SubbandAn) sb).l2Norm * (1 << sb.anGainExp))) / log2);
}
max = getMaxMagBitsExpounded(sb.getLL(), t, c);
tmp = getMaxMagBitsExpounded(sb.getLH(), t, c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsExpounded(sb.getHL(), t, c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsExpounded(sb.getHH(), t, c);
if (tmp > max) max = tmp;
return max;
}
/**
* Returns the next code-block in the current tile for the specified component. The order in which
* code-blocks are returned is not specified. However each code-block is returned only once and
* all code-blocks will be returned if the method is called 'N' times, where 'N' is the number of
* code-blocks in the tile. After all the code-blocks have been returned for the current tile
* calls to this method will return 'null'.
*
* <p>When changing the current tile (through 'setTile()' or 'nextTile()') this method will always
* return the first code-block, as if this method was never called before for the new current
* tile.
*
* <p>The data returned by this method can be the data in the internal buffer of this object, if
* any, and thus can not be modified by the caller. The 'offset' and 'scanw' of the returned data
* can be arbitrary. See the 'CBlkWTData' class.
*
* <p>The 'ulx' and 'uly' members of the returned 'CBlkWTData' object contain the coordinates of
* the top-left corner of the block, with respect to the tile, not the subband.
*
* @param c The component for which to return the next code-block.
* @param 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.
* @return The next code-block in the current tile for component 'n', or null if all code-blocks
* for the current tile have been returned.
* @see CBlkWTData
*/
public final CBlkWTData getNextInternCodeBlock(int c, CBlkWTData cblk) {
// NOTE: this method is declared final since getNextCodeBlock() relies
// on this particular implementation
int k, j;
int tmp, shiftBits, jmin;
int w, h;
int outarr[];
float infarr[] = null;
CBlkWTDataFloat infblk;
float invstep; // The inverse of the quantization step size
boolean intq; // flag for quantizig ints
SubbandAn sb;
float stepUDR; // The quantization step size (for a dynamic
// range of 1, or unit)
int g = ((Integer) gbs.getTileCompVal(tIdx, c)).intValue();
// Are we quantizing ints or floats?
intq = (src.getDataType(tIdx, c) == DataBlk.TYPE_INT);
// Check that we have an output object
if (cblk == null) {
cblk = new CBlkWTDataInt();
}
// Cache input float code-block
infblk = this.infblk;
// Get data to quantize. When quantizing int data 'cblk' is used to
// get the data to quantize and to return the quantized data as well,
// that's why 'getNextCodeBlock()' is used. This can not be done when
// quantizing float data because of the different data types, that's
// why 'getNextInternCodeBlock()' is used in that case.
if (intq) { // Source data is int
cblk = src.getNextCodeBlock(c, cblk);
if (cblk == null) {
return null; // No more code-blocks in current tile for comp.
}
// Input and output arrays are the same (for "in place" quant.)
outarr = (int[]) cblk.getData();
} else { // Source data is float
// Can not use 'cblk' to get float data, use 'infblk'
infblk = (CBlkWTDataFloat) src.getNextInternCodeBlock(c, infblk);
if (infblk == null) {
// Release buffer from infblk: this enables to garbage collect
// the big buffer when we are done with last code-block of
// component.
this.infblk.setData(null);
return null; // No more code-blocks in current tile for comp.
}
this.infblk = infblk; // Save local cache
infarr = (float[]) infblk.getData();
// Get output data array and check that there is memory to put the
// quantized coeffs in
outarr = (int[]) cblk.getData();
if (outarr == null || outarr.length < infblk.w * infblk.h) {
outarr = new int[infblk.w * infblk.h];
cblk.setData(outarr);
}
cblk.m = infblk.m;
cblk.n = infblk.n;
cblk.sb = infblk.sb;
cblk.ulx = infblk.ulx;
cblk.uly = infblk.uly;
cblk.w = infblk.w;
cblk.h = infblk.h;
cblk.wmseScaling = infblk.wmseScaling;
cblk.offset = 0;
cblk.scanw = cblk.w;
}
// Cache width, height and subband of code-block
w = cblk.w;
h = cblk.h;
sb = cblk.sb;
if (isReversible(tIdx, c)) { // Reversible only for int data
cblk.magbits = g - 1 + src.getNomRangeBits(c) + sb.anGainExp;
shiftBits = 31 - cblk.magbits;
// Update the convertFactor field
cblk.convertFactor = (1 << shiftBits);
// Since we used getNextCodeBlock() to get the int data then
// 'offset' is 0 and 'scanw' is the width of the code-block The
// input and output arrays are the same (i.e. "in place")
for (j = w * h - 1; j >= 0; j--) {
tmp = (outarr[j] << shiftBits);
outarr[j] = ((tmp < 0) ? (1 << 31) | (-tmp) : tmp);
}
} else { // Non-reversible, use step size
float baseStep = ((Float) qsss.getTileCompVal(tIdx, c)).floatValue();
// Calculate magnitude bits and quantization step size
if (isDerived(tIdx, c)) {
cblk.magbits = g - 1 + sb.level - (int) Math.floor(Math.log(baseStep) / log2);
stepUDR = baseStep / (1 << sb.level);
} else {
cblk.magbits =
g - 1 - (int) Math.floor(Math.log(baseStep / (sb.l2Norm * (1 << sb.anGainExp))) / log2);
stepUDR = baseStep / (sb.l2Norm * (1 << sb.anGainExp));
}
shiftBits = 31 - cblk.magbits;
// Calculate step that decoder will get and use that one.
stepUDR = convertFromExpMantissa(convertToExpMantissa(stepUDR));
invstep = 1.0f / ((1L << (src.getNomRangeBits(c) + sb.anGainExp)) * stepUDR);
// Normalize to magnitude bits (output fractional point)
invstep *= (1 << (shiftBits - src.getFixedPoint(c)));
// Update convertFactor and stepSize fields
cblk.convertFactor = invstep;
cblk.stepSize = ((1L << (src.getNomRangeBits(c) + sb.anGainExp)) * stepUDR);
if (intq) { // Quantizing int data
// Since we used getNextCodeBlock() to get the int data then
// 'offset' is 0 and 'scanw' is the width of the code-block
// The input and output arrays are the same (i.e. "in place")
for (j = w * h - 1; j >= 0; j--) {
tmp = (int) (outarr[j] * invstep);
outarr[j] = ((tmp < 0) ? (1 << 31) | (-tmp) : tmp);
}
} else { // Quantizing float data
for (j = w * h - 1, k = infblk.offset + (h - 1) * infblk.scanw + w - 1, jmin = w * (h - 1);
j >= 0;
jmin -= w) {
for (; j >= jmin; k--, j--) {
tmp = (int) (infarr[k] * invstep);
outarr[j] = ((tmp < 0) ? (1 << 31) | (-tmp) : tmp);
}
// Jump to beggining of previous line in input
k -= infblk.scanw - w;
}
}
}
// Return the quantized code-block
return cblk;
}
/**
* This class implements scalar quantization of integer or floating-point valued source data. The
* source data is the wavelet transformed image data and the output is the quantized wavelet
* coefficients represented in sign-magnitude (see below).
*
* <p>Sign magnitude representation is used (instead of two's complement) for the output data. The
* most significant bit is used for the sign (0 if positive, 1 if negative). Then the magnitude of
* the quantized coefficient is stored in the next M most significat bits. The rest of the bits
* (least significant bits) can contain a fractional value of the quantized coefficient. This
* fractional value is not to be coded by the entropy coder. However, it can be used to compute
* rate-distortion measures with greater precision.
*
* <p>The value of M is determined for each subband as the sum of the number of guard bits G and the
* nominal range of quantized wavelet coefficients in the corresponding subband (Rq), minus 1:
*
* <p>M = G + Rq -1
*
* <p>The value of G should be the same for all subbands. The value of Rq depends on the
* quantization step size, the nominal range of the component before the wavelet transform and the
* analysis gain of the subband (see Subband).
*
* <p>The blocks of data that are requested should not cross subband boundaries.
*
* @see Subband
* @see Quantizer
*/
public class StdQuantizer extends Quantizer {
/** The number of mantissa bits for the quantization steps */
public static final int QSTEP_MANTISSA_BITS = 11;
/** The number of exponent bits for the quantization steps */
// NOTE: formulas in 'convertFromExpMantissa()' and
// 'convertToExpMantissa()' methods do not support more than 5 bits.
public static final int QSTEP_EXPONENT_BITS = 5;
/** The maximum value of the mantissa for the quantization steps */
public static final int QSTEP_MAX_MANTISSA = (1 << QSTEP_MANTISSA_BITS) - 1;
/** The maximum value of the exponent for the quantization steps */
public static final int QSTEP_MAX_EXPONENT = (1 << QSTEP_EXPONENT_BITS) - 1;
/** Natural log of 2, used as a convenience variable */
private static double log2 = Math.log(2);
/** The quantization type specifications */
private QuantTypeSpec qts;
/** The quantization step size specifications */
private QuantStepSizeSpec qsss;
/** The guard bits specifications */
private GuardBitsSpec gbs;
/**
* The 'CBlkWTDataFloat' object used to request data, used when quantizing floating-point data.
*/
// This variable makes the class thread unsafe, but it avoids allocating
// new objects for code-block that is quantized.
private CBlkWTDataFloat infblk;
/**
* Initializes the source of wavelet transform coefficients. The constructor takes information on
* whether the quantizer is in reversible, derived or expounded mode. If the quantizer is
* reversible the value of 'derived' is ignored. If the source data is not integer (int) then the
* quantizer can not be reversible.
*
* <p>After initializing member attributes, getAnSubbandTree is called for all components setting
* the 'stepWMSE' for all subbands in the current tile.
*
* @param src The source of wavelet transform coefficients.
* @param encSpec The encoder specifications
*/
public StdQuantizer(CBlkWTDataSrc src, J2KImageWriteParamJava wp) {
super(src);
qts = wp.getQuantizationType();
qsss = wp.getQuantizationStep();
gbs = wp.getGuardBits();
}
/**
* Returns the quantization type spec object associated to the quantizer.
*
* @return The quantization type spec
*/
public QuantTypeSpec getQuantTypeSpec() {
return qts;
}
/**
* Returns the number of guard bits used by this quantizer in the given tile-component.
*
* @param t Tile index
* @param c Component index
* @return The number of guard bits
*/
public int getNumGuardBits(int t, int c) {
return ((Integer) gbs.getTileCompVal(t, c)).intValue();
}
/**
* Returns true if the quantized data is reversible, for the specified tile-component. For the
* quantized data to be reversible it is necessary and sufficient that the quantization is
* reversible.
*
* @param t The tile to test for reversibility
* @param c The component to test for reversibility
* @return True if the quantized data is reversible, false if not.
*/
public boolean isReversible(int t, int c) {
return qts.isReversible(t, c);
}
/**
* Returns true if given tile-component uses derived quantization step sizes.
*
* @param t Tile index
* @param c Component index
* @return True if derived
*/
public boolean isDerived(int t, int c) {
return qts.isDerived(t, c);
}
/**
* Returns the next code-block in the current tile for the specified component, as a copy (see
* below). The order in which code-blocks are returned is not specified. However each code-block
* is returned only once and all code-blocks will be returned if the method is called 'N' times,
* where 'N' is the number of code-blocks in the tile. After all the code-blocks have been
* returned for the current tile calls to this method will return 'null'.
*
* <p>When changing the current tile (through 'setTile()' or 'nextTile()') this method will always
* return the first code-block, as if this method was never called before for the new current
* tile.
*
* <p>The data returned by this method is always a copy of the data. Therfore 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 'CBlkWTData' class.
*
* <p>The 'ulx' and 'uly' members of the returned 'CBlkWTData' object contain the coordinates of
* the top-left corner of the block, with respect to the tile, not the subband.
*
* @param c The component for which to return the next code-block.
* @param 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.
* @return The next code-block in the current tile for component 'n', or null if all code-blocks
* for the current tile have been returned.
* @see CBlkWTData
*/
public CBlkWTData getNextCodeBlock(int c, CBlkWTData cblk) {
return getNextInternCodeBlock(c, cblk);
}
/**
* Returns the next code-block in the current tile for the specified component. The order in which
* code-blocks are returned is not specified. However each code-block is returned only once and
* all code-blocks will be returned if the method is called 'N' times, where 'N' is the number of
* code-blocks in the tile. After all the code-blocks have been returned for the current tile
* calls to this method will return 'null'.
*
* <p>When changing the current tile (through 'setTile()' or 'nextTile()') this method will always
* return the first code-block, as if this method was never called before for the new current
* tile.
*
* <p>The data returned by this method can be the data in the internal buffer of this object, if
* any, and thus can not be modified by the caller. The 'offset' and 'scanw' of the returned data
* can be arbitrary. See the 'CBlkWTData' class.
*
* <p>The 'ulx' and 'uly' members of the returned 'CBlkWTData' object contain the coordinates of
* the top-left corner of the block, with respect to the tile, not the subband.
*
* @param c The component for which to return the next code-block.
* @param 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.
* @return The next code-block in the current tile for component 'n', or null if all code-blocks
* for the current tile have been returned.
* @see CBlkWTData
*/
public final CBlkWTData getNextInternCodeBlock(int c, CBlkWTData cblk) {
// NOTE: this method is declared final since getNextCodeBlock() relies
// on this particular implementation
int k, j;
int tmp, shiftBits, jmin;
int w, h;
int outarr[];
float infarr[] = null;
CBlkWTDataFloat infblk;
float invstep; // The inverse of the quantization step size
boolean intq; // flag for quantizig ints
SubbandAn sb;
float stepUDR; // The quantization step size (for a dynamic
// range of 1, or unit)
int g = ((Integer) gbs.getTileCompVal(tIdx, c)).intValue();
// Are we quantizing ints or floats?
intq = (src.getDataType(tIdx, c) == DataBlk.TYPE_INT);
// Check that we have an output object
if (cblk == null) {
cblk = new CBlkWTDataInt();
}
// Cache input float code-block
infblk = this.infblk;
// Get data to quantize. When quantizing int data 'cblk' is used to
// get the data to quantize and to return the quantized data as well,
// that's why 'getNextCodeBlock()' is used. This can not be done when
// quantizing float data because of the different data types, that's
// why 'getNextInternCodeBlock()' is used in that case.
if (intq) { // Source data is int
cblk = src.getNextCodeBlock(c, cblk);
if (cblk == null) {
return null; // No more code-blocks in current tile for comp.
}
// Input and output arrays are the same (for "in place" quant.)
outarr = (int[]) cblk.getData();
} else { // Source data is float
// Can not use 'cblk' to get float data, use 'infblk'
infblk = (CBlkWTDataFloat) src.getNextInternCodeBlock(c, infblk);
if (infblk == null) {
// Release buffer from infblk: this enables to garbage collect
// the big buffer when we are done with last code-block of
// component.
this.infblk.setData(null);
return null; // No more code-blocks in current tile for comp.
}
this.infblk = infblk; // Save local cache
infarr = (float[]) infblk.getData();
// Get output data array and check that there is memory to put the
// quantized coeffs in
outarr = (int[]) cblk.getData();
if (outarr == null || outarr.length < infblk.w * infblk.h) {
outarr = new int[infblk.w * infblk.h];
cblk.setData(outarr);
}
cblk.m = infblk.m;
cblk.n = infblk.n;
cblk.sb = infblk.sb;
cblk.ulx = infblk.ulx;
cblk.uly = infblk.uly;
cblk.w = infblk.w;
cblk.h = infblk.h;
cblk.wmseScaling = infblk.wmseScaling;
cblk.offset = 0;
cblk.scanw = cblk.w;
}
// Cache width, height and subband of code-block
w = cblk.w;
h = cblk.h;
sb = cblk.sb;
if (isReversible(tIdx, c)) { // Reversible only for int data
cblk.magbits = g - 1 + src.getNomRangeBits(c) + sb.anGainExp;
shiftBits = 31 - cblk.magbits;
// Update the convertFactor field
cblk.convertFactor = (1 << shiftBits);
// Since we used getNextCodeBlock() to get the int data then
// 'offset' is 0 and 'scanw' is the width of the code-block The
// input and output arrays are the same (i.e. "in place")
for (j = w * h - 1; j >= 0; j--) {
tmp = (outarr[j] << shiftBits);
outarr[j] = ((tmp < 0) ? (1 << 31) | (-tmp) : tmp);
}
} else { // Non-reversible, use step size
float baseStep = ((Float) qsss.getTileCompVal(tIdx, c)).floatValue();
// Calculate magnitude bits and quantization step size
if (isDerived(tIdx, c)) {
cblk.magbits = g - 1 + sb.level - (int) Math.floor(Math.log(baseStep) / log2);
stepUDR = baseStep / (1 << sb.level);
} else {
cblk.magbits =
g - 1 - (int) Math.floor(Math.log(baseStep / (sb.l2Norm * (1 << sb.anGainExp))) / log2);
stepUDR = baseStep / (sb.l2Norm * (1 << sb.anGainExp));
}
shiftBits = 31 - cblk.magbits;
// Calculate step that decoder will get and use that one.
stepUDR = convertFromExpMantissa(convertToExpMantissa(stepUDR));
invstep = 1.0f / ((1L << (src.getNomRangeBits(c) + sb.anGainExp)) * stepUDR);
// Normalize to magnitude bits (output fractional point)
invstep *= (1 << (shiftBits - src.getFixedPoint(c)));
// Update convertFactor and stepSize fields
cblk.convertFactor = invstep;
cblk.stepSize = ((1L << (src.getNomRangeBits(c) + sb.anGainExp)) * stepUDR);
if (intq) { // Quantizing int data
// Since we used getNextCodeBlock() to get the int data then
// 'offset' is 0 and 'scanw' is the width of the code-block
// The input and output arrays are the same (i.e. "in place")
for (j = w * h - 1; j >= 0; j--) {
tmp = (int) (outarr[j] * invstep);
outarr[j] = ((tmp < 0) ? (1 << 31) | (-tmp) : tmp);
}
} else { // Quantizing float data
for (j = w * h - 1, k = infblk.offset + (h - 1) * infblk.scanw + w - 1, jmin = w * (h - 1);
j >= 0;
jmin -= w) {
for (; j >= jmin; k--, j--) {
tmp = (int) (infarr[k] * invstep);
outarr[j] = ((tmp < 0) ? (1 << 31) | (-tmp) : tmp);
}
// Jump to beggining of previous line in input
k -= infblk.scanw - w;
}
}
}
// Return the quantized code-block
return cblk;
}
/**
* Calculates the parameters of the SubbandAn objects that depend on the Quantizer. The 'stepWMSE'
* field is calculated for each subband which is a leaf in the tree rooted at 'sb', for the
* specified component. The subband tree 'sb' must be the one for the component 'n'.
*
* @param sb The root of the subband tree.
* @param c The component index
* @see SubbandAn#stepWMSE
*/
protected void calcSbParams(SubbandAn sb, int c) {
float baseStep;
if (sb.stepWMSE > 0f) // parameters already calculated
return;
if (!sb.isNode) {
if (isReversible(tIdx, c)) {
sb.stepWMSE = (float) Math.pow(2, -(src.getNomRangeBits(c) << 1)) * sb.l2Norm * sb.l2Norm;
} else {
baseStep = ((Float) qsss.getTileCompVal(tIdx, c)).floatValue();
if (isDerived(tIdx, c)) {
sb.stepWMSE =
baseStep
* baseStep
* (float) Math.pow(2, (sb.anGainExp - sb.level) << 1)
* sb.l2Norm
* sb.l2Norm;
} else {
sb.stepWMSE = baseStep * baseStep;
}
}
} else {
calcSbParams((SubbandAn) sb.getLL(), c);
calcSbParams((SubbandAn) sb.getHL(), c);
calcSbParams((SubbandAn) sb.getLH(), c);
calcSbParams((SubbandAn) sb.getHH(), c);
sb.stepWMSE = 1f; // Signal that we already calculated this branch
}
}
/**
* Converts the floating point value to its exponent-mantissa representation. The mantissa
* occupies the 11 least significant bits (bits 10-0), and the exponent the previous 5 bits (bits
* 15-11).
*
* @param step The quantization step, normalized to a dynamic range of 1.
* @return The exponent mantissa representation of the step.
*/
public static int convertToExpMantissa(float step) {
int exp;
exp = (int) Math.ceil(-Math.log(step) / log2);
if (exp > QSTEP_MAX_EXPONENT) {
// If step size is too small for exponent representation, use the
// minimum, which is exponent QSTEP_MAX_EXPONENT and mantissa 0.
return (QSTEP_MAX_EXPONENT << QSTEP_MANTISSA_BITS);
}
// NOTE: this formula does not support more than 5 bits for the
// exponent, otherwise (-1<<exp) might overflow (the - is used to be
// able to represent 2**31)
return (exp << QSTEP_MANTISSA_BITS)
| ((int) ((-step * (-1 << exp) - 1f) * (1 << QSTEP_MANTISSA_BITS) + 0.5f));
}
/**
* Converts the exponent-mantissa representation to its floating-point value. The mantissa
* occupies the 11 least significant bits (bits 10-0), and the exponent the previous 5 bits (bits
* 15-11).
*
* @param ems The exponent-mantissa representation of the step.
* @return The floating point representation of the step, normalized to a dynamic range of 1.
*/
private static float convertFromExpMantissa(int ems) {
// NOTE: this formula does not support more than 5 bits for the
// exponent, otherwise (-1<<exp) might overflow (the - is used to be
// able to represent 2**31)
return (-1f - ((float) (ems & QSTEP_MAX_MANTISSA)) / ((float) (1 << QSTEP_MANTISSA_BITS)))
/ (float) (-1 << ((ems >> QSTEP_MANTISSA_BITS) & QSTEP_MAX_EXPONENT));
}
/**
* Returns the maximum number of magnitude bits in any subband of the current tile.
*
* @param c the component number
* @return The maximum number of magnitude bits in all subbands of the current tile.
*/
public int getMaxMagBits(int c) {
Subband sb = getAnSubbandTree(tIdx, c);
if (isReversible(tIdx, c)) {
return getMaxMagBitsRev(sb, c);
} else {
if (isDerived(tIdx, c)) {
return getMaxMagBitsDerived(sb, tIdx, c);
} else {
return getMaxMagBitsExpounded(sb, tIdx, c);
}
}
}
/**
* Returns the maximum number of magnitude bits in any subband of the current tile if reversible
* quantization is used
*
* @param sb The root of the subband tree of the current tile
* @param c the component number
* @return The highest number of magnitude bit-planes
*/
private int getMaxMagBitsRev(Subband sb, int c) {
int tmp, max = 0;
int g = ((Integer) gbs.getTileCompVal(tIdx, c)).intValue();
if (!sb.isNode) return g - 1 + src.getNomRangeBits(c) + sb.anGainExp;
max = getMaxMagBitsRev(sb.getLL(), c);
tmp = getMaxMagBitsRev(sb.getLH(), c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsRev(sb.getHL(), c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsRev(sb.getHH(), c);
if (tmp > max) max = tmp;
return max;
}
/**
* Returns the maximum number of magnitude bits in any subband in the given tile-component if
* derived quantization is used
*
* @param sb The root of the subband tree of the tile-component
* @param t Tile index
* @param c Component index
* @return The highest number of magnitude bit-planes
*/
private int getMaxMagBitsDerived(Subband sb, int t, int c) {
int tmp, max = 0;
int g = ((Integer) gbs.getTileCompVal(t, c)).intValue();
if (!sb.isNode) {
float baseStep = ((Float) qsss.getTileCompVal(t, c)).floatValue();
return g - 1 + sb.level - (int) Math.floor(Math.log(baseStep) / log2);
}
max = getMaxMagBitsDerived(sb.getLL(), t, c);
tmp = getMaxMagBitsDerived(sb.getLH(), t, c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsDerived(sb.getHL(), t, c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsDerived(sb.getHH(), t, c);
if (tmp > max) max = tmp;
return max;
}
/**
* Returns the maximum number of magnitude bits in any subband in the given tile-component if
* expounded quantization is used
*
* @param sb The root of the subband tree of the tile-component
* @param t Tile index
* @param c Component index
* @return The highest number of magnitude bit-planes
*/
private int getMaxMagBitsExpounded(Subband sb, int t, int c) {
int tmp, max = 0;
int g = ((Integer) gbs.getTileCompVal(t, c)).intValue();
if (!sb.isNode) {
float baseStep = ((Float) qsss.getTileCompVal(t, c)).floatValue();
return g
- 1
- (int)
Math.floor(
Math.log(baseStep / (((SubbandAn) sb).l2Norm * (1 << sb.anGainExp))) / log2);
}
max = getMaxMagBitsExpounded(sb.getLL(), t, c);
tmp = getMaxMagBitsExpounded(sb.getLH(), t, c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsExpounded(sb.getHL(), t, c);
if (tmp > max) max = tmp;
tmp = getMaxMagBitsExpounded(sb.getHH(), t, c);
if (tmp > max) max = tmp;
return max;
}
}