invcomptransf.java

jpeg2000编解码

/*
 * CVS Identifier:
 *
 * $Id: InvCompTransf.java,v 1.1.1.1 2002/07/22 09:26:51 grosbois Exp $
 *
 * Class:               InvCompTransf
 *
 * Description:         Inverse 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.invcomptransf;

import jj2000.j2k.wavelet.synthesis.*;
import jj2000.j2k.decoder.*;
import jj2000.j2k.image.*;
import jj2000.j2k.util.*;
import jj2000.j2k.*;

import java.util.*;

/** 
 * This class apply inverse component transformations to the tiles depending
 * on specification read from the codestream header. 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 InvCompTransf extends ImgDataAdapter implements BlkImgDataSrc {

    /** Identifier for no component transformation. Value is 0. */
    public static final int NONE = 0;

    /** The prefix for inverse component transformation options: 'M' */
    public final static char OPT_PREFIX = 'M';

    /** The list of parameters that is accepted by the inverse
     * component transformation module. They start with 'M'. */
    private final static String [][] pinfo = null;

    /** Identifier for the Inverse Reversible Component Transformation
        (INV_RCT). Value is 1. */
    public static final int INV_RCT = 1;

    /** Identifier for the Inverse Irreversible Component
        Transformation (INV_ICT). Value is 2 */
    public static final int INV_ICT = 2;

    /** The source of image data */
    private BlkImgDataSrc src;

    /** The component transformations specifications */
    private CompTransfSpec cts;

    /** The wavelet filter specifications */
    private SynWTFilterSpec 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;

    /** Buffer for each component of output data */
    private int[][] outdata = new int[3][];

    /** Block used to request component 0 */
    private DataBlk block0;

    /** Block used to request component 1 */
    private DataBlk block1;

    /** Block used to request component 2 */
    private DataBlk block2;

    /** Data block used only to store coordinates and progressiveness 
	of the buffered blocks */
    private DataBlkInt dbi = new DataBlkInt();

    /** The bit-depths of un-transformed components */
    private int utdepth[];

    /** Flag indicating whether the decoder should skip the component 
     * transform*/
    private boolean noCompTransf = false;

    /**
     * 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 decSpec The decoder specifications
     *
     * @param utdepth The bit depth of the un-transformed components 
     *
     * @param pl The command line optinons of the decoder
     *
     * @see BlkImgDataSrc
     * */
    public InvCompTransf(BlkImgDataSrc imgSrc, DecoderSpecs decSpec,
                         int[] utdepth, ParameterList pl) {
        super(imgSrc);
	this.cts = decSpec.cts;
        this.wfs = decSpec.wfs;
        src = imgSrc;
        this.utdepth = utdepth;
        noCompTransf = !(pl.getBooleanParameter("comp_transf"));
    }

    /**
     * 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;
    }

    /**
     * Returns a string with a descriptive text of which inverse component
     * transformation is used. This can be either "Inverse RCT" or "Inverse
     * ICT" or "No component transformation" depending on the current tile.
     *
     * @return A descriptive string
     * */
    public String toString() {
        switch(transfType){
        case INV_RCT:
	    return "Inverse RCT";
        case INV_ICT:
	    return "Inverse ICT";
        case NONE:
	    return "No component transformation";
        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 INV_RCT:
            return true;
        case INV_ICT:
            return false;
        default:
            throw new IllegalArgumentException("Non JPEG 2000 part I"+
                                               " component transformation");
        }
    }

    /**
     * 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);        
     }     

    /**
     * Calculates the bitdepths of the transformed components, given the
     * bitdepth of the un-transformed components and the component
     * tranformation type.
     *
     * @param utdepth The bitdepth of each un-transformed component
     *
     * @param ttype The type ID of the inverse component tranformation
     *
     * @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 utdepth[], int ttype, int tdepth[]) {

        if (utdepth.length < 3 && ttype != NONE) {
            throw new IllegalArgumentException();
        }

        if (tdepth == null) {
            tdepth = new int[utdepth.length];
        }

        switch (ttype) {
        case NONE:
            System.arraycopy(utdepth,0,tdepth,0,utdepth.length);
            break;
        case INV_RCT:
            if (utdepth.length >3) {
                System.arraycopy(utdepth,3,tdepth,3,utdepth.length-3);
            }
            // The formulas are:
            // tdepth[0] = ceil(log2(2^(utdepth[0])+2^utdepth[1]+
            //                        2^(utdepth[2])))-2+1
            // tdepth[1] = ceil(log2(2^(utdepth[0])+2^(utdepth[1])-1))+1
            // tdepth[2] = ceil(log2(2^(utdepth[1])+2^(utdepth[2])-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<<utdepth[0])+(2<<utdepth[1])+
                                      (1<<utdepth[2])-1)-2+1;
            tdepth[1] = MathUtil.log2((1<<utdepth[2])+(1<<utdepth[1])-1)+1;
            tdepth[2] = MathUtil.log2((1<<utdepth[0])+(1<<utdepth[1])-1)+1;
            break;
        case INV_ICT:
            if (utdepth.length >3) {
                System.arraycopy(utdepth,3,tdepth,3,utdepth.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<<utdepth[0])*0.299072+
                                              (1<<utdepth[1])*0.586914+
                                              (1<<utdepth[2])*0.114014)-1)+1;
            tdepth[1] =
                MathUtil.log2((int)Math.floor((1<<utdepth[0])*0.168701+
                                              (1<<utdepth[1])*0.331299+
                                              (1<<utdepth[2])*0.5)-1)+1;
            tdepth[2] =
                MathUtil.log2((int)Math.floor((1<<utdepth[0])*0.5+
                                              (1<<utdepth[1])*0.418701+
                                              (1<<utdepth[2])*0.081299)-1)+1;
            break;
        }

        return tdepth;
    }

    /**
     * Returns the number of bits, referred to as the "range bits",
     * corresponding to the nominal range of the data in the specified
     * component. If this number is <i>b</b> 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.
     *
     * @param c The index of the component.
     *
     * @return The bitdepth of un-transformed component 'c'.
     * */
    public int getNomRangeBits(int c) {
        return utdepth[c];
    }  
    
    /**
     * Apply inverse 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 || noCompTransf) {
            return src.getCompData(blk,c);
        }
        else { // We can use getInternCompData (since data is a copy anyways)
            return getInternCompData(blk,c);
        }
    }

    /**
     * Apply the inverse component transformation associated with the current
     * tile. If no component transformation has been requested by the user,
     * data are not modified. Else, appropriate method is called (invRCT or
     * invICT).
     *
     * @see #invRCT
     *
     * @see #invICT
     *
     * @param blk Determines the rectangular area to return.
     *
     * @param c Index of the output component.
     *
     * @return The requested DataBlk
     * */
    public DataBlk getInternCompData(DataBlk blk, int c){
        // if specified in the command line that no component transform should
        // be made, return original data
        if(noCompTransf)