/* * CVS Identifier: * * $Id: ForwCompTransf.java,v 1.17 2000/12/05 22:45:20 grosbois Exp $ * * Class:               ForwCompTransf * * Description:         Component transformations applied to tiles * * * * COPYRIGHT: *  * This software module was originally developed by Rapha雔 Grosbois and * Diego Santa Cruz (Swiss Federal Institute of Technology-EPFL); Joel * Askel鰂 (Ericsson Radio Systems AB); and Bertrand Berthelot, David * Bouchard, F閘ix 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. * */package jj2000.j2k.image.forwcomptransf;import jj2000.j2k.wavelet.analysis.*;import jj2000.j2k.wavelet.*;import jj2000.j2k.encoder.*;import jj2000.j2k.image.*;import jj2000.j2k.util.*;import jj2000.j2k.*;/**  * This class apply component transformations to the tiles depending * on user specifications. These transformations can be used to * improve compression efficiency but are not related to colour * transforms used to map colour values for display purposes. JPEG * 2000 part I defines 2 component transformations: RCT (Reversible * Component Transformation) and ICT (Irreversible Component * Transformation). * * @see ModuleSpec * */public class ForwCompTransf extends ImgDataAdapter    implements BlkImgDataSrc {    /** Identifier for no component transformation. Value is 0. */    public static final int NONE = 0;    /** Identifier for the Forward Reversible Component Transformation        (FORW_RCT). Value is 1. */    public static final int FORW_RCT = 1;    /** Identifier for the Forward Irreversible Component        Transformation (FORW_ICT). Value is 2 */    public static final int FORW_ICT = 2;    /** The source of image data */    private BlkImgDataSrc src;    /** The component transformations specifications */    private CompTransfSpec cts;    /** The wavelet filter specifications */    private AnWTFilterSpec wfs;    /** The type of the current component transformation JPEG 2000     * part I only support NONE, FORW_RCT and FORW_ICT types*/    private int transfType = NONE;    /** The bit-depths of transformed components */    private int tdepth[];    /** Output block used instead of the one provided as an argument        if the later is DataBlkFloat.*/    private DataBlk outBlk;    /** Block used to request component with index 0 */    private DataBlkInt block0;    /** Block used to request component with index 1*/    private DataBlkInt block1;    /** Block used to request component with index 2*/    private DataBlkInt block2;     /**     * Constructs a new ForwCompTransf object that operates on the     * specified source of image data.     *     * @param imgSrc The source from where to get the data to be     * transformed     *     * @param encSpec The encoder specifications     *     * @see BlkImgDataSrc     * */    public ForwCompTransf(BlkImgDataSrc imgSrc, EncoderSpecs encSpec) {        super(imgSrc);	this.cts = encSpec.cts;        this.wfs = encSpec.wfs;        src = imgSrc;    }    /** The prefix for component transformation type: 'M' */    public final static char OPT_PREFIX = 'M';    /** The list of parameters that is accepted by the forward     * component transformation module. Options start with an 'M'. */    private final static String [][] pinfo = {	{ "Mct", "[<tile index>] [on|off] ...",	  "Specifies to use component transformation with some tiles. "+	  " If the wavelet transform is reversible (w5x3 filter), the "+          "Reversible Component Transformation (RCT) is applied. If not "+          "(w9x7 filter), the Irreversible Component Transformation (ICT)"+          " is used.", null},    };    /**     * Returns the position of the fixed point in the specified     * component. This is the position of the least significant integral     * (i.e. non-fractional) bit, which is equivalent to the number of     * fractional bits. For instance, for fixed-point values with 2 fractional     * bits, 2 is returned. For floating-point data this value does not apply     * and 0 should be returned. Position 0 is the position of the least     * significant bit in the data.     *     * <P>This default implementation assumes that the number of     * fractional bits is not modified by the component mixer.     *     * @param c The index of the component.     *     * @return The value of the fixed point position of the source     * since the color transform does not affect it.     * */     public int getFixedPoint(int c){         return src.getFixedPoint(c);             }                   /**     * Returns the parameters that are used in this class and implementing     * classes. It returns a 2D String array. Each of the 1D arrays is for a     * different option, and they have 4 elements. The first element is the     * option name, the second one is the synopsis, the third one is a long     * description of what the parameter is and the fourth is its default     * value. The synopsis or description may be 'null', in which case it is     * assumed that there is no synopsis or description of the option,     * respectively. Null may be returned if no options are supported.     *     * @return the options name, their synopsis and their explanation,      * or null if no options are supported.     * */    public static String[][] getParameterInfo(){        return pinfo;    }    /**     * Calculates the bitdepths of the transformed components, given the     * bitdepth of the un-transformed components and the component     * tranformation type.     *     * @param ntdepth The bitdepth of each non-transformed components.     *     * @param ttype The type ID of the component transformation.     *     * @param tdepth If not null the results are stored in this     * array, otherwise a new array is allocated and returned.     *     * @return The bitdepth of each transformed component.     * */    public static        int[] calcMixedBitDepths(int ntdepth[], int ttype, int tdepth[]) {        if (ntdepth.length < 3 && ttype != NONE) {            throw new IllegalArgumentException();        }        if (tdepth == null) {            tdepth = new int[ntdepth.length];        }        switch (ttype) {        case NONE:            System.arraycopy(ntdepth,0,tdepth,0,ntdepth.length);            break;        case FORW_RCT:            if (ntdepth.length >3) {                System.arraycopy(ntdepth,3,tdepth,3,ntdepth.length-3);            }            // The formulas are:            // tdepth[0] = ceil(log2(2^(ntdepth[0])+2^ntdepth[1]+            //                        2^(ntdepth[2])))-2+1            // tdepth[1] = ceil(log2(2^(ntdepth[1])+2^(ntdepth[2])-1))+1            // tdepth[2] = ceil(log2(2^(ntdepth[0])+2^(ntdepth[1])-1))+1            // The MathUtil.log2(x) function calculates floor(log2(x)), so we            // use 'MathUtil.log2(2*x-1)+1', which calculates ceil(log2(x))            // for any x>=1, x integer.            tdepth[0] = MathUtil.log2((1<<ntdepth[0])+(2<<ntdepth[1])+                                      (1<<ntdepth[2])-1)-2+1;            tdepth[1] = MathUtil.log2((1<<ntdepth[2])+(1<<ntdepth[1])-1)+1;            tdepth[2] = MathUtil.log2((1<<ntdepth[0])+(1<<ntdepth[1])-1)+1;            break;        case FORW_ICT:            if (ntdepth.length >3) {                System.arraycopy(ntdepth,3,tdepth,3,ntdepth.length-3);            }            // The MathUtil.log2(x) function calculates floor(log2(x)), so we            // use 'MathUtil.log2(2*x-1)+1', which calculates ceil(log2(x))            // for any x>=1, x integer.            tdepth[0] =                MathUtil.log2((int)Math.floor((1<<ntdepth[0])*0.299072+                                              (1<<ntdepth[1])*0.586914+                                              (1<<ntdepth[2])*0.114014)-1)+1;            tdepth[1] =                MathUtil.log2((int)Math.floor((1<<ntdepth[0])*0.168701+                                              (1<<ntdepth[1])*0.331299+                                              (1<<ntdepth[2])*0.5)-1)+1;            tdepth[2] =                MathUtil.log2((int)Math.floor((1<<ntdepth[0])*0.5+                                              (1<<ntdepth[1])*0.418701+                                              (1<<ntdepth[2])*0.081299)-1)+1;            break;        }        return tdepth;    }    /**      * Initialize some variables used with RCT. It must be called, at least,     * at the beginning of each new tile.     * */    private void initForwRCT(){        int i;	        if (src.getNumComps() < 3) {            throw new IllegalArgumentException();        }        // Check that the 3 components have the same dimensions        if (src.getCompWidth(0) != src.getCompWidth(1) ||            src.getCompWidth(0) != src.getCompWidth(2) ||            src.getCompHeight(0) != src.getCompHeight(1) ||            src.getCompHeight(0) != src.getCompHeight(2)) {            throw new IllegalArgumentException("Can not use RCT "+                                               "on components with different "+                                               "dimensions");        }        // Initialize bitdepths        int utd[]; // Premix bitdepths        utd = new int[src.getNumComps()];        for (i=utd.length-1; i>=0; i--) {            utd[i] = src.getNomRangeBits(i);        }        tdepth = calcMixedBitDepths(utd,FORW_RCT,null);    }    /**      * Initialize some variables used with ICT. It must be called, at least,     * at the beginning of a new tile.     * */    private void initForwICT(){        int i;        if (src.getNumComps() < 3) {            throw new IllegalArgumentException();        }        // Check that the 3 components have the same dimensions        if (src.getCompWidth(0) != src.getCompWidth(1) ||            src.getCompWidth(0) != src.getCompWidth(2) ||            src.getCompHeight(0) != src.getCompHeight(1) ||            src.getCompHeight(0) != src.getCompHeight(2)) {            throw new IllegalArgumentException("Can not use ICT "+                                               "on components with different "+                                               "dimensions");        }        // Initialize bitdepths        int utd[]; // Premix bitdepths        utd = new int[src.getNumComps()];        for (i=utd.length-1; i>=0; i--) {            utd[i] = src.getNomRangeBits(i);        }        tdepth = calcMixedBitDepths(utd,FORW_ICT,null);    }    /**     * Returns a string with a descriptive text of which forward component     * transformation is used. This can be either "Forward RCT" or "Forward     * ICT" or "No component transformation" depending on the current tile.     *     * @return A descriptive string     * */    public String toString() {        switch(transfType){        case FORW_RCT:	    return "Forward RCT";        case FORW_ICT:	    return "Forward ICT";        case NONE:	    return "No component transformation";        default:            throw new IllegalArgumentException("Non JPEG 2000 part I"+                                               " component transformation");        }    }    /**     * Returns the number of bits, referred to as the "range bits",     * corresponding to the nominal range of the data in the specified     * component and in the current tile. If this number is <i>b</i> then for     * unsigned data the nominal range is between 0 and 2^b-1, and for signed     * data it is between -2^(b-1) and 2^(b-1)-1. Note that this value can be     * affected by the multiple component transform.     *     * @param c The index of the component.     *     * @return The bitdepth of component 'c' after mixing.     * */    public int getNomRangeBits(int c) {        switch(transfType){        case FORW_RCT:        case FORW_ICT:            return tdepth[c];        case NONE:            return src.getNomRangeBits(c);        default:            throw new IllegalArgumentException("Non JPEG 2000 part I"+                                               " component transformation");        }    }    /**     * Returns true if this transform is reversible in current     * tile. Reversible component transformations are those which operation     * can be completely reversed without any loss of information (not even     * due to rounding).     *     * @return Reversibility of component transformation in current tile     * */    public boolean isReversible(){        switch(transfType){        case NONE:        case FORW_RCT:            return true;        case FORW_ICT:            return false;        default:            throw new IllegalArgumentException("Non JPEG 2000 part I"+                                               " component transformation");        }    }    /**     * Apply forward component transformation associated with the current     * tile. If no component transformation has been requested by the user,     * data are not modified.     *     * <P>This method calls the getInternCompData() method, but respects the     * definitions of the getCompData() method defined in the BlkImgDataSrc     * interface.     *     * @param blk Determines the rectangular area to return, and the     * data is returned in this object.     *     * @param c Index of the output component.     *     * @return The requested DataBlk     *     * @see BlkImgDataSrc#getCompData     * */    public DataBlk getCompData(DataBlk blk, int c){        // If requesting a component whose index is greater than 3 or there is        // no transform return a copy of data (getInternCompData returns the        // actual data in those cases)        if (c>=3 || transfType == NONE) {            return src.getCompData(blk,c);        }        else { // We can use getInternCompData (since data is a copy anyways)            return getInternCompData(blk,c);        }    }