headerencoder.java

jpeg2000算法实现

/*
 * CVS identifier:
 *
 * $Id: HeaderEncoder.java,v 1.35 2001/03/02 10:10:30 grosbois Exp $
 *
 * Class:                   HeaderEncoder
 *
 * Description:             Write codestream headers.
 *
 *
 *
 * 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.codestream.writer;

import jj2000.j2k.quantization.quantizer.*;
import jj2000.j2k.wavelet.analysis.*;
import jj2000.j2k.entropy.encoder.*;
import jj2000.j2k.quantization.*;
import jj2000.j2k.image.input.*;
import jj2000.j2k.roi.encoder.*;
import jj2000.j2k.codestream.*;
import jj2000.j2k.wavelet.*;
import jj2000.j2k.encoder.*;
import jj2000.j2k.entropy.*;
import jj2000.j2k.image.*;
import jj2000.j2k.util.*;
import jj2000.j2k.io.*;
import jj2000.j2k.*;

import java.util.*;
import java.io.*;

/**
 * This class writes almost of the markers and marker segments in main header
 * and in tile-part headers. It is created by the run() method of the Encoder
 * instance.
 * 
 * <p>A marker segment includes a marker and eventually marker segment
 * parameters. It is designed by the three letter code of the marker
 * associated with the marker segment. JPEG 2000 part I defines 6 types of
 * markers: <ul> <li> Delimiting : SOC,SOT,SOD,EOC (written in
 * FileCodestreamWriter).</li> <li> Fixed information: SIZ.</li> <li>
 * Functional: COD,COC,RGN,QCD,QCC,POC.</li> <li> In bit-stream: SOP,EPH.</li>
 * <li> Pointer: TLM,PLM,PLT,PPM,PPT.</li> <li> Informational:
 * CRG,COM.</li></ul>
 *
 * <p>Main Header is written when Encoder instance calls encodeMainHeader
 * whereas tile-part headers are written when the EBCOTRateAllocator instance
 * calls encodeTilePartHeader.
 *
 * @see Encoder
 * @see Markers
 * @see EBCOTRateAllocator
 * */
public class HeaderEncoder implements Markers, StdEntropyCoderOptions {

    /** Nominal range bit of the component defining default values in QCD for
     * main header */
    private int defimgn;

    /** Nominal range bit of the component defining default values in QCD for
     * tile headers */
    private int deftilenr;
    
    /** The number of components in the image */
    protected int nComp;

    /** The ByteArrayOutputStream to store header data. This handler
     * is kept in order to use methods not accessible from a general
     * DataOutputStream. For the other methods, it's better to use
     * variable hbuf.
     *
     * @see #hbuf */
    protected ByteArrayOutputStream baos;
    
    /** The DataOutputStream to store header data. This kind of object 
     * is useful to write short, int, .... It's constructor takes
     * baos as parameter.
     *
     * @see #baos
     **/
    protected DataOutputStream hbuf;

    /** The image data reader. Source of original data info */
    protected ImgData origSrc;

    /** An array specifying, for each component,if the data was signed
        or not */
    protected boolean isOrigSig[];

    /** Reference to the rate allocator */
    protected PostCompRateAllocator ralloc;

    /** Reference to the DWT module */
    protected ForwardWT dwt;

    /** Reference to the tiler module */
    protected Tiler tiler;

    /** Reference to the ROI module */
    protected ROIScaler roiSc;

    /** The encoder specifications */
    protected EncoderSpecs encSpec;

    /**
     * Initializes the header writer with the references to the coding chain.
     *
     * @param origsrc The original image data (before any component mixing,
     * tiling, etc.)
     *
     * @param isorigsig An array specifying for each component if it was
     * originally signed or not.
     *
     * @param dwt The discrete wavelet transform module.
     *
     * @param tiler The tiler module.
     *
     * @param encSpec The encoder specifications
     *
     * @param roiSc The ROI scaler module.
     *
     * @param ralloc The post compression rate allocator.
     * */
    public HeaderEncoder(ImgData origsrc, boolean isorigsig[],
                         ForwardWT dwt, Tiler tiler,EncoderSpecs encSpec, 
			 ROIScaler roiSc, PostCompRateAllocator ralloc) {
        if (origsrc.getNumComps() != isorigsig.length) {
            throw new IllegalArgumentException();
        }
        this.origSrc   = origsrc;
        this.isOrigSig = isorigsig;
        this.dwt       = dwt;
        this.tiler     = tiler;
        this.encSpec   = encSpec;
        this.roiSc     = roiSc;
        this.ralloc    = ralloc;
        
        baos = new ByteArrayOutputStream();
        hbuf = new DataOutputStream(baos);
        nComp = origsrc.getNumComps();
    }

    /**
     * Resets the contents of this HeaderEncoder to its initial state. It
     * erases all the data in the header buffer and reactualizes the
     * headerLength field of the bit stream writer.
     * */
    public void reset() {
        baos.reset();
        hbuf = new DataOutputStream(baos);
    }

    /** 
     * Returns the byte-buffer used to store the codestream header.
     *
     * @return A byte array countaining codestream header
     * */
    protected byte[] getBuffer(){
        return baos.toByteArray();
    }

    /**
     * Returns the length of the header.
     *
     * @return The length of the header in bytes
     * */
    public int getLength() {
        return hbuf.size();
    }

    /**
     * Writes the header to the specified BinaryDataOutput.
     *
     * @param out Where to write the header.
     * */
    public void writeTo(BinaryDataOutput out) throws IOException {
        int i,len;
        byte buf[];

        buf = getBuffer();
        len = getLength();

        for (i=0; i<len; i++) {
            out.writeByte(buf[i]);
        }
    }

    /**
     * Returns the number of bytes used in the codestream header's
     * buffer.
     *
     * @return Header length in buffer (without any header
     * overhead)
     * */
    protected int getBufferLength(){
        return baos.size();
    }

    /**
     * Writes the header to the specified OutputStream.
     *
     * @param out Where to write the header.
     * */
    public void writeTo(OutputStream out) throws IOException {
        out.write(getBuffer(),0,getBufferLength());
    }

    /**
     * Start Of Codestream marker (SOC) signalling the beginning of a
     * codestream. 
     * */
    private void writeSOC() throws IOException {
        hbuf.writeShort(SOC);
    }

    /**
     * Writes SIZ marker segment of the codestream header. It is a fixed
     * information marker segment containing informations about image and tile
     * sizes. It is required in the main header immediately after SOC marker
     * segment.
     * */
    private void writeSIZ() throws IOException {
        int tmp;

        // SIZ marker
        hbuf.writeShort(SIZ);
        
        // Lsiz (Marker length) corresponding to
        // Lsiz(2 bytes)+Rsiz(2)+Xsiz(4)+Ysiz(4)+XOsiz(4)+YOsiz(4)+
	// XTsiz(4)+YTsiz(4)+XTOsiz(4)+YTOsiz(4)+Csiz(2)+
        // (Ssiz(1)+XRsiz(1)+YRsiz(1))*nComp
        // markSegLen = 38 + 3*nComp;
        int markSegLen = 38 + 3*nComp;
        hbuf.writeShort(markSegLen);
        
        // Rsiz (codestream capabilities)
	hbuf.writeShort(0); // JPEG 2000 - Part I
        
        // Xsiz (original image width)
        hbuf.writeInt(tiler.getImgWidth()+tiler.getImgULX());
        
        // Ysiz (original image height)
        hbuf.writeInt(tiler.getImgHeight()+tiler.getImgULY());
        
	// XOsiz (horizontal offset from the origin of the reference
	// grid to the left side of the image area)
	hbuf.writeInt(tiler.getImgULX());

	// YOsiz (vertical offset from the origin of the reference
	// grid to the top side of the image area)
	hbuf.writeInt(tiler.getImgULY());

        // XTsiz (nominal tile width)
        hbuf.writeInt(tiler.getNomTileWidth());
            
        // YTsiz (nominal tile height)
        hbuf.writeInt(tiler.getNomTileHeight());

        Coord torig = tiler.getTilingOrigin(null);
	// XTOsiz (Horizontal offset from the origin of the reference
	// grid to the left side of the first tile)
	hbuf.writeInt(torig.x);

	// YTOsiz (Vertical offset from the origin of the reference
	// grid to the top side of the first tile)
	hbuf.writeInt(torig.y);

        // Csiz (number of components)
        hbuf.writeShort(nComp);
                
        // Bit-depth and downsampling factors.
        for(int c=0; c<nComp; c++){ // Loop on each component
            
            // Ssiz bit-depth before mixing
            tmp = origSrc.getNomRangeBits(c)-1;            

            tmp |= ( (isOrigSig[c]?1:0)<<SSIZ_DEPTH_BITS );
            hbuf.write(tmp);
            
            // XRsiz (component sub-sampling value x-wise)
            hbuf.write(tiler.getCompSubsX(c));
            
            // YRsiz (component sub-sampling value y-wise)
            hbuf.write(tiler.getCompSubsY(c));
            
        } // End loop on each component
        
    }

    /**
     * Writes COD marker segment. COD is a functional marker segment
     * containing the code style default (coding style, decomposition,
     * layering) used for compressing all the components in an image.
     *
     * <p>The values can be overriden for an individual component by a COC
     * marker in either the main or the tile header.
     *
     * @param mh Flag indicating whether this marker belongs to the main
     * header
     *
     * @param tileIdx Tile index if the marker belongs to a tile-part header
     * 
     * @see #writeCOC
     * */
    protected void writeCOD(boolean mh, int tileIdx) 
	throws IOException {
	AnWTFilter[][] filt;
        boolean precinctPartitionUsed;
        int tmp;
        int mrl=0,a=0;
        int ppx=0, ppy=0;
	Progression[] prog;
        
        if (mh) {
	    mrl = ((Integer)encSpec.dls.getDefault()).intValue();
            // get default precinct size 
            ppx = encSpec.pss.getPPX(-1,-1,mrl);
            ppy = encSpec.pss.getPPY(-1,-1,mrl);
	    prog = (Progression[])(encSpec.ps.getDefault());
        }
        else {
	    mrl = ((Integer)encSpec.dls.getTileDef(tileIdx)).intValue();
            // get precinct size for specified tile
            ppx = encSpec.pss.getPPX(tileIdx,-1,mrl);
            ppy = encSpec.pss.getPPY(tileIdx,-1,mrl);
	    prog = (Progression[])(encSpec.ps.getTileDef(tileIdx));
        }

        if ( ppx != PRECINCT_PARTITION_DEF_SIZE ||
             ppy != PRECINCT_PARTITION_DEF_SIZE ) {
            precinctPartitionUsed = true;
        }
        else {
            precinctPartitionUsed = false;
        }
        
        if ( precinctPartitionUsed ) {
	    // If precinct partition is used we add one byte per resolution
	    // level i.e. mrl+1 (+1 for resolution 0).
            a = mrl+1;
        }
          
        // Write COD marker
	hbuf.writeShort(COD);
        
        // Lcod (marker segment length (in bytes)) Basic : Lcod(2
        // bytes)+Scod(1)+SGcod(4)+SPcod(5+a)  where:
        // a=0 if no precinct partition is used
	// a=mrl+1 if precinct partition used
        int markSegLen = 12+a;
        hbuf.writeShort(markSegLen);
        
        // Scod (coding style parameter)
	tmp=0;
        if ( precinctPartitionUsed ) 
            tmp=SCOX_PRECINCT_PARTITION;

        // Are SOP markers used ?
	if (mh) {
            if( ((String)encSpec.sops.getDefault().toString())
                 .equalsIgnoreCase("on") ) {
                tmp |= SCOX_USE_SOP;
            }
        }
        else {
            if ( ((String)encSpec.sops.getTileDef(tileIdx).toString())
                 .equalsIgnoreCase("on") ) {
                tmp |= SCOX_USE_SOP;
            }
        }
        
        // Are EPH markers used ?
        if(mh){
            if ( ((String)encSpec.ephs.getDefault().toString())
                 .equalsIgnoreCase("on") ) {
                tmp |= SCOX_USE_EPH;
            }
        }
        else{
            if ( ((String)encSpec.ephs.getTileDef(tileIdx).toString())
                 .equalsIgnoreCase("on") ) {
                tmp |= SCOX_USE_EPH;
            }
        }
	hbuf.write(tmp);
        
        // SGcod
        // Progression order
        hbuf.write(prog[0].type);
        
        // Number of layers
        hbuf.writeShort(ralloc.getNumLayers());
        
        // Multiple component transform
        // CSsiz (Color transform)
        String str = null;
        if(mh)
            str = (String)encSpec.cts.getDefault();
        else
            str = (String)encSpec.cts.getTileDef(tileIdx);

        if(str.equals("none"))
            hbuf.write(0);
        else
            hbuf.write(1);

        // SPcod
        // Number of decomposition levels
        hbuf.write(mrl);
        
        // Code-block width and height
        if ( mh ) {
            // main header, get default values
            tmp = encSpec.cblks.
                getCBlkWidth(ModuleSpec.SPEC_DEF,-1,-1);