forwwtfull.java

jpeg2000编解码

                decomposedComps[c] = new DataBlkInt(0,0,w,h);
                bufblk = new DataBlkInt();
            } else {
                decomposedComps[c] = new DataBlkFloat(0,0,w,h);
                bufblk = new DataBlkFloat();
            }
	    
            // Get data from source line by line (this diminishes the memory
            // requirements on the data source)
            dst_data = decomposedComps[c].getData();
            int lstart = getCompULX(c);
            bufblk.ulx = lstart;
            bufblk.w = w;
            bufblk.h = 1;
            int kk = getCompULY(c);
            for (k=0; k<h; k++,kk++) {
                bufblk.uly = kk;
                bufblk.ulx = lstart;
                bufblk = src.getInternCompData(bufblk,c);
                System.arraycopy(bufblk.getData(),bufblk.offset,
                                 dst_data,k*w,w);
            }
                        
            //Decompose source image
            waveletTreeDecomposition(decomposedComps[c],
                                     getAnSubbandTree(tIdx,c),c); 
	    
            // Make the first subband the current one
            currentSubband[c] = getNextSubband(c);

            lastn[c] = -1;
            lastm[c] = 0;
        }
        
        // Get the next code-block to "send"
        do {
            // Calculate number of code-blocks in current subband
            ncblks = currentSubband[c].numCb;
            // Goto next code-block
            lastn[c]++;
            if (lastn[c] == ncblks.x) { // Got to end of this row of
                // code-blocks
                lastn[c] = 0;
                lastm[c]++;
            }
            if (lastm[c] < ncblks.y) {
                // Not past the last code-block in the subband, we can return
                // this code-block
                break;
            }
            // If we get here we already sent all code-blocks in this subband,
            // goto next subband
            currentSubband[c] = getNextSubband(c);
            lastn[c] = -1;
            lastm[c] = 0;
            if ( currentSubband[c] == null ) {
                // We don't need the transformed data any more (a priori)
                decomposedComps[c] = null;
                // All code-blocks from all subbands in the current
                // tile have been returned so we return a null
                // reference
                return null;
            }
            // Loop to find the next code-block
        } while (true);
        

        // Project code-block partition origin to subband. Since the origin is
        // always 0 or 1, it projects to the low-pass side (throught the ceil
        // operator) as itself (i.e. no change) and to the high-pass side
        // (through the floor operator) as 0, always.
        acb0x = cb0x;
        acb0y = cb0y;
        switch (currentSubband[c].sbandIdx) {
        case Subband.WT_ORIENT_LL:
            // No need to project since all low-pass => nothing to do
            break;
        case Subband.WT_ORIENT_HL:
            acb0x = 0;
            break;
        case Subband.WT_ORIENT_LH:
            acb0y = 0;
            break;
        case Subband.WT_ORIENT_HH:
            acb0x = 0;
            acb0y = 0;
            break;
        default:
            throw new Error("Internal JJ2000 error");
        }

        // Initialize output code-block
        if (cblk==null) {
            if (intData) {
                cblk = new CBlkWTDataInt();
            } else {
                cblk = new CBlkWTDataFloat();
            }
        }
        cbn = lastn[c];
        cbm = lastm[c];
        sb = currentSubband[c];
        cblk.n = cbn;
        cblk.m = cbm;
        cblk.sb = sb;
        // Calculate the indexes of first code-block in subband with respect
        // to the partitioning origin, to then calculate the position and size
        // NOTE: when calculating "floor()" by integer division the dividend
        // and divisor must be positive, we ensure that by adding the divisor
        // to the dividend and then substracting 1 to the result of the
        // division
        cn = (sb.ulcx-acb0x+sb.nomCBlkW)/sb.nomCBlkW-1;
        cm = (sb.ulcy-acb0y+sb.nomCBlkH)/sb.nomCBlkH-1;
        if(cbn==0) { // Left-most code-block, starts where subband starts
            cblk.ulx = sb.ulx;
        } else {
            // Calculate starting canvas coordinate and convert to subb. coords
            cblk.ulx = (cn+cbn)*sb.nomCBlkW - (sb.ulcx-acb0x) + sb.ulx;
        }
        if(cbm==0) { // Bottom-most code-block, starts where subband starts
            cblk.uly = sb.uly;
        } else {
            cblk.uly = (cm+cbm)*sb.nomCBlkH - (sb.ulcy-acb0y) + sb.uly;
        }
        if(cbn<ncblks.x-1) {
            // Calculate where next code-block starts => width
            cblk.w = (cn+cbn+1)*sb.nomCBlkW - (sb.ulcx-acb0x) + sb.ulx -
                cblk.ulx;
        } else { // Right-most code-block, ends where subband ends
            cblk.w = sb.ulx+sb.w-cblk.ulx;
        }
        if(cbm<ncblks.y-1) {
            // Calculate where next code-block starts => height
            cblk.h = (cm+cbm+1)*sb.nomCBlkH - (sb.ulcy-acb0y) + sb.uly -
                cblk.uly;
        } else { // Bottom-most code-block, ends where subband ends
            cblk.h = sb.uly+sb.h-cblk.uly;
        }
        cblk.wmseScaling = 1f;
 
        // Since we are in getNextInternCodeBlock() we can return a
        // reference to the internal buffer, no need to copy. Just initialize
        // the 'offset' and 'scanw'
        cblk.offset = cblk.uly*decomposedComps[c].w+cblk.ulx;
        cblk.scanw = decomposedComps[c].w;

        // For the data just put a reference to our buffer
        cblk.setData(decomposedComps[c].getData());
        // Return code-block
        return cblk;
    }
    
    /**
     * 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>
     *
     * <p>The data returned by this method is always a copy of the internal
     * data of this object, 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.  The 'magbits'
     * of the returned data is not set by this method and should be
     * ignored. See the 'CBlkWTData' class.</p>
     *
     * <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.</p>
     *
     * @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 'c', or
     * null if all code-blocks for the current tile have been returned.
     *
     * @see CBlkWTData
     * */
    public CBlkWTData getNextCodeBlock(int c, CBlkWTData cblk) {
        // We can not directly use getNextInternCodeBlock() since that returns
        // a reference to the internal buffer, we have to copy that data

        int j,k;
        int w;
        Object dst_data; // a int[] or float[] object
        int[] dst_data_int;
        float[] dst_data_float;
        Object src_data; // a int[] or float[] object

	intData = (filters.getWTDataType(tIdx,c)==DataBlk.TYPE_INT);

        dst_data = null;

        // Cache the data array, if any
        if (cblk != null) {
            dst_data = cblk.getData();
        }

        // Get the next code-block
        cblk = getNextInternCodeBlock(c,cblk);

        if (cblk == null) {
            return null; // No more code-blocks in current tile for component
            // c
        }

        // Ensure size of output buffer
        if (intData) { // int data
            dst_data_int = (int[]) dst_data;
            if (dst_data_int == null || dst_data_int.length < cblk.w*cblk.h) {
                dst_data = new int[cblk.w*cblk.h];
            }
        } else { // float data
            dst_data_float = (float[]) dst_data;
            if (dst_data_float == null ||
                dst_data_float.length < cblk.w*cblk.h) {
                dst_data = new float[cblk.w*cblk.h];
            }
        }
	
        // Copy data line by line
        src_data = cblk.getData();
        w = cblk.w;
        for (j = w*(cblk.h-1), k = cblk.offset+(cblk.h-1)*cblk.scanw;
             j >= 0; j -= w, k -= cblk.scanw) {
            System.arraycopy(src_data,k,dst_data,j,w);
        }
        cblk.setData(dst_data);
        cblk.offset = 0;
        cblk.scanw = w;
	
        return cblk;
    }
    
    /** 
     * Return the data type of this CBlkWTDataSrc. Its value should be either
     * DataBlk.TYPE_INT or DataBlk.TYPE_FLOAT but can change according to the
     * current tile-component.
     *
     * @param t The index of the tile for which to return the data type.
     *
     * @param c The index of the component for which to return the data type.
     *
     * @return Current data type
     * */
    public int getDataType(int t,int c) {
	return filters.getWTDataType(t,c);
    }

    /**
     * Returns the next subband that will be used to get the next code-block
     * to return by the getNext[Intern]CodeBlock method.
     *
     * @param c The component
     *
     * @return Its returns the next subband that will be used to get the next
     * code-block to return by the getNext[Intern]CodeBlock method.
     **/
    private SubbandAn getNextSubband(int c) {
        int down = 1;
        int up = 0;
        int direction = down;
        SubbandAn nextsb;
        
        nextsb = currentSubband[c];
        //If it is the first call to this method
        if(nextsb == null) {
            nextsb = getAnSubbandTree(tIdx,c);
            //If there is no decomposition level then send the whole image
            if(!nextsb.isNode) {
                return nextsb;
            }
        }
        
        //Find the next subband to send
        do {
            //If the current subband is null then break
            if(nextsb == null) {
                break;
            }
                
            //If the current subband is a leaf then select the next leaf to
            //send or go up in the decomposition tree if the leaf was a LL
            //one.
            else if(!nextsb.isNode) {
                switch (nextsb.orientation) {
                    case Subband.WT_ORIENT_HH :
                        nextsb = (SubbandAn)nextsb.getParent().getLH();
                        direction = down;
                        break;
                    case Subband.WT_ORIENT_LH :
                        nextsb = (SubbandAn)nextsb.getParent().getHL();
                        direction = down;
                        break;
                    case Subband.WT_ORIENT_HL :
                        nextsb = (SubbandAn)nextsb.getParent().getLL();
                        direction = down;
                        break;
                    case Subband.WT_ORIENT_LL :
                        nextsb = (SubbandAn)nextsb.getParent();
                        direction = up;
                        break;
                }
            }
            
            //Else if the current subband is a node 
            else if(nextsb.isNode) {
                //If the direction is down the select the HH subband of the
                //current node.
                if(direction == down) {
                    nextsb = (SubbandAn)nextsb.getHH();
                }
                //Else the direction is up the select the next node to cover
                //or still go up in the decomposition tree if the node is a LL
                //subband
                else if(direction == up) {
                    switch (nextsb.orientation) {
                        case Subband.WT_ORIENT_HH :
                            nextsb = (SubbandAn)nextsb.getParent().getLH();
                            direction = down;
                            break;
                        case Subband.WT_ORIENT_LH :
                            nextsb = (SubbandAn)nextsb.getParent().getHL();
                            direction = down;
                            break;
                        case Subband.WT_ORIENT_HL :
                            nextsb = (SubbandAn)nextsb.getParent().getLL();
                            direction = down;
                            break;
                        case Subband.WT_ORIENT_LL :
                            nextsb = (SubbandAn)nextsb.getParent();
                            direction = up;
                            break;
                    }
                }
            }
            
            if(nextsb == null) {
                break;               
            }