/** * 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 } }
public SampleModel getSampleModel() { if (sampleModel != null) return sampleModel; int realWidth = (int) Math.min(tileWidth, width); int realHeight = (int) Math.min(tileHeight, height); if (nComp == 1 && (maxDepth == 1 || maxDepth == 2 || maxDepth == 4)) sampleModel = new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, realWidth, realHeight, maxDepth); else if (maxDepth <= 8) sampleModel = new PixelInterleavedSampleModel( DataBuffer.TYPE_BYTE, realWidth, realHeight, nComp, realWidth * nComp, bandOffsets); else if (maxDepth <= 16) sampleModel = new PixelInterleavedSampleModel( isSigned ? DataBuffer.TYPE_SHORT : DataBuffer.TYPE_USHORT, realWidth, realHeight, nComp, realWidth * nComp, bandOffsets); else if (maxDepth <= 32) sampleModel = new PixelInterleavedSampleModel( DataBuffer.TYPE_INT, realWidth, realHeight, nComp, realWidth * nComp, bandOffsets); else throw new IllegalArgumentException(I18N.getString("J2KReadState11") + " " + +maxDepth); return sampleModel; }
/** * 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; } }
public Raster getTile(int tileX, int tileY, WritableRaster raster) throws IOException { Point nT = ictransf.getNumTiles(null); if (noTransform) { if (tileX >= nT.x || tileY >= nT.y) throw new IllegalArgumentException(I18N.getString("J2KImageReader0")); ictransf.setTile(tileX * tileStepX, tileY * tileStepY); // The offset of the active tiles is the same for all components, // since we don't support different component dimensions. int tOffx; int tOffy; int cTileWidth; int cTileHeight; if (raster != null && (this.resolution < hd.getDecoderSpecs().dls.getMin()) || stepX != 1 || stepY != 1) { tOffx = raster.getMinX(); tOffy = raster.getMinY(); cTileWidth = Math.min(raster.getWidth(), ictransf.getTileWidth()); cTileHeight = Math.min(raster.getHeight(), ictransf.getTileHeight()); } else { tOffx = ictransf.getCompULX(0) - (ictransf.getImgULX() + ictransf.getCompSubsX(0) - 1) / ictransf.getCompSubsX(0) + destinationRegion.x; tOffy = ictransf.getCompULY(0) - (ictransf.getImgULY() + ictransf.getCompSubsY(0) - 1) / ictransf.getCompSubsY(0) + destinationRegion.y; cTileWidth = ictransf.getTileWidth(); cTileHeight = ictransf.getTileHeight(); } if (raster == null) raster = Raster.createWritableRaster(sampleModel, new Point(tOffx, tOffy)); int numBands = sampleModel.getNumBands(); if (tOffx + cTileWidth >= destinationRegion.width + destinationRegion.x) cTileWidth = destinationRegion.width + destinationRegion.x - tOffx; if (tOffy + cTileHeight >= destinationRegion.height + destinationRegion.y) cTileHeight = destinationRegion.height + destinationRegion.y - tOffy; // create the line buffer for pixel data if it is not large enough // or null if (pixbuf == null || pixbuf.length < cTileWidth * numBands) pixbuf = new int[cTileWidth * numBands]; boolean prog = false; // Deliver in lines to reduce memory usage for (int l = 0; l < cTileHeight; l++) { if (reader.getAbortRequest()) break; // Request line data for (int i = 0; i < numBands; i++) { if (reader.getAbortRequest()) break; DataBlkInt db = dataBlocks[i]; db.ulx = 0; db.uly = l; db.w = cTileWidth; db.h = 1; ictransf.getInternCompData(db, channelMap[sourceBands[i]]); prog = prog || db.progressive; int[] data = db.data; int k1 = db.offset + cTileWidth - 1; int fracBit = fracBits[i]; int lS = levelShift[i]; int min = minValues[i]; int max = maxValues[i]; if (ImageUtil.isBinary(sampleModel)) { // Force min max to 0 and 1. min = 0; max = 1; if (bytebuf == null || bytebuf.length < cTileWidth * numBands) bytebuf = new byte[cTileWidth * numBands]; for (int j = cTileWidth - 1; j >= 0; j--) { int tmp = (data[k1--] >> fracBit) + lS; bytebuf[j] = (byte) ((tmp < min) ? min : ((tmp > max) ? max : tmp)); } ImageUtil.setUnpackedBinaryData( bytebuf, raster, new Rectangle(tOffx, tOffy + l, cTileWidth, 1)); } else { for (int j = cTileWidth - 1; j >= 0; j--) { int tmp = (data[k1--] >> fracBit) + lS; pixbuf[j] = (tmp < min) ? min : ((tmp > max) ? max : tmp); } raster.setSamples(tOffx, tOffy + l, cTileWidth, 1, destinationBands[i], pixbuf); } } } } else { readSubsampledRaster(raster); } return raster; }