filebitstreamreaderagent.java

jpeg2000算法实现

/*
 * CVS identifier:
 *
 * $Id: FileBitstreamReaderAgent.java,v 1.44 2001/03/02 10:09:13 grosbois Exp $
 *
 * Class:                   FileBitstreamReaderAgent
 *
 * Description:             Retrieve code-blocks codewords in the bit stream
 *
 *
 *
 * 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.reader;

import jj2000.j2k.quantization.dequantizer.*;
import jj2000.j2k.wavelet.synthesis.*;
import jj2000.j2k.entropy.decoder.*;
import jj2000.j2k.codestream.*;
import jj2000.j2k.decoder.*;
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 reads the bit stream (with the help of HeaderDecoder for tile
 * headers and PktDecoder for packets header and body) and retrives location
 * of all code-block's codewords.
 *
 * <P>Note: All tile-parts headers are read by the constructor whereas packets
 * are processed when decoding related tile (when setTile method is called).
 *
 * <P>In parsing mode, the reader simulates a virtual layer-resolution
 * progressive bit stream with the same truncation points in each code-block,
 * whereas in truncation mode, only the first bytes are taken into account (it
 * behaves like if it is a real truncated codestream).
 *
 * @see HeaderDecoder
 * @see PktDecoder
 * */
public class FileBitstreamReaderAgent extends BitstreamReaderAgent 
    implements Markers, ProgressionType, StdEntropyCoderOptions{

    /** Reference to the PktDecoder instance */
    public PktDecoder pktDec;
    
    /** Reference to the ParameterList instance */
    private ParameterList pl;

    /** The RandomAccessIO where to get data from */
    private RandomAccessIO in;

    /** The number of tiles in the image */
    private int nt;

    /** Offset of the first packet in each tile-part in each tile */
    private int[][] firstPackOff;

    /** Number of bytes allocated to each tile. In parsing mode, this number
     * is related to the tile length in the codestream whereas in truncation
     * mode all the rate is affected to the first tiles. */
    private int[] nBytes;

    /** Length of each tile-part (written in Psot) */
    private int[][] tilePartLen;

    /** Total length of each tile */
    private int[] totTileLen;

    /** Total length of tiles' header */
    private int[] totTileHeadLen;

    /** First tile part header length*/
    private int firstTilePartHeadLen;

    /** Total length of all tile parts in all tiles */
    private double totAllTileLen;

    /** Length of main header */
    private int mainHeadLen;

    /** Length of all tile-part headers */
    private int[][] tilePartHeadLen;

    /** Length of each packet head found in the tile */
    private Vector pktHL;

    /** True if truncation mode is used. False if parsing mode */
    private boolean isTruncMode;

    /** The number of tile-parts that remain to read */
    private int remainingTileParts;

    /** The number of tile-parts read so far for each tile */
    private int[] tilePartsRead;

    /** Thetotal  number of tile-parts read so far */
    private int totTilePartsRead=0;

    /** The number of tile-parts in each tile */
    private int[] tileParts;

    /** The current tile part being used */
    private int curTilePart;

    /** The number of the tile-part in the codestream */
    private int[][] tilePartNum;

    /** Array containing info. for all the code-blocks:<br>
     * - 1st dim: component index.<br>
     * - 2nd dim: resolution level index.<br>
     * - 3rd dim: subband index.<br>
     * - 4th/5th dim: code-block index (vert. and horiz.).<br>
     */
    private CBlkInfo[][][][][] cbI;

    /** 
     * Reads all tiles headers and keep offset of their first packet. Finally
     * the rate allocation method is called.
     *
     * @param hd HeaderDecoder of the codestream.
     *
     * @param ehs The input stream where to read bit-stream.
     *
     * @param decSpec The decoder specifications 
     *
     * @param pl The ParameterList instance created from the command-line
     * arguments.
     *
     * @see #allocateRate
     * */
    public FileBitstreamReaderAgent(HeaderDecoder hd,RandomAccessIO ehs,
                                    DecoderSpecs decSpec,ParameterList pl)
    throws IOException {
        super(hd,decSpec);
        
        this.pl = pl;
        String strInfo = "Codestream elements information in bytes "+
            "(offset, total length, header length):\n\n";
        
        // Get decoding rate
        boolean rateInBytes;
        boolean parsing = pl.getBooleanParameter("parsing");
        try{
            trate = pl.getFloatParameter("rate");
        }
        catch (NumberFormatException e) {
            throw new Error("Invalid value in 'rate' option: "+
                  pl.getParameter("rate"));
        }
        catch (IllegalArgumentException e) {
            throw new Error("'rate' option is missing");
        }
        
        try{
            tnbytes = pl.getIntParameter("nbytes");
        }
        catch (NumberFormatException e) {
            throw new Error("Invalid value in 'nbytes' option: "+
                  pl.getParameter("nbytes"));
        }
        catch (IllegalArgumentException e) {
            throw new Error("'nbytes' option is missing");
        }
        
        // Check that '-rate' and '-nbytes' are not used at the same time
        ParameterList defaults = pl.getDefaultParameterList();
        if(tnbytes != defaults.getFloatParameter("nbytes"))
            rateInBytes = true;
        else
            rateInBytes = false;

        if(rateInBytes && trate != defaults.getIntParameter("rate")) {
            throw new Error("Cannot use '-rate' and '-nbytes' options at the "+
                  "same time.");
        }

        if(rateInBytes){
            trate = tnbytes*8f/hd.getImgWidth()/hd.getImgHeight();
        }
        else {
            tnbytes = (int)(trate*hd.getImgWidth()*hd.getImgHeight())/8;
        }
        isTruncMode = !pl.getBooleanParameter("parsing");

        // initializations
        nt = ntX * ntY;
        in = ehs;
        pktDec = new PktDecoder(decSpec,hd,ehs,this,isTruncMode);

        tileParts = new int[nt];
        totTileLen = new int[nt];
	tilePartLen = new int[nt][];
        tilePartNum = new int[nt][];
        firstPackOff = new int[nt][];
        tilePartsRead = new int[nt];
        totTileHeadLen = new int[nt];
	tilePartHeadLen = new int[nt][];
	nBytes = new int[nt];
        hd.nTileParts = new int[nt];


	this.isTruncMode = isTruncMode;
        int t=0, pos, tp=0, tptot=0;

	// Keeps main header's length, takes file format into account
        int cdstreamStart = hd.initPos; // Codestream offset in the file
	mainHeadLen = in.getPos() - cdstreamStart;
        anbytes = mainHeadLen;
        strInfo += "Main header length    : "+cdstreamStart+", "+mainHeadLen+
            ", "+mainHeadLen+"\n";

        // If cannot even read the first tile-part
        if(anbytes > tnbytes){
            throw new Error("Requested bitrate is too small.");
        }

        // Read all tile-part headers from all tiles.
	int tilePartStart;
        boolean rateReached = false;
        int mdl;
        totAllTileLen = 0;
        remainingTileParts = nt; // at least as many tile-parts as tiles
        try{
            while(remainingTileParts != 0){
                tilePartStart = in.getPos();
                // Read tile-part header
		try{
                    t = readTilePartHeader();
                    tp = tilePartsRead[t];
		}
		catch(EOFException e){
		    firstPackOff[t][tp]=in.length();
		    throw e;
		}

                pos = in.getPos();

                // In truncation mode, if target decoding rate is reached in
                // tile-part header, skips the tile-part and stop reading
                if(isTruncMode){
                    if( (pos-cdstreamStart) > tnbytes ){
                        firstPackOff[t][tp]=in.length();
                        rateReached = true;
                        break;
                    }
                }
                
                // Set tile part position and header length
                firstPackOff[t][tp] = pos;
                tilePartHeadLen[t][tp] = (pos-tilePartStart);

                strInfo += "Tile-part "+tp+" of tile "+t+" : "+tilePartStart
                    +", "+tilePartLen[t][tp]+", "+tilePartHeadLen[t][tp]+"\n";

                // Update length counters
                totTileLen[t] += tilePartLen[t][tp];
                totTileHeadLen[t] += tilePartHeadLen[t][tp];
                totAllTileLen += tilePartLen[t][tp];
                if(isTruncMode){
                    if(anbytes+tilePartLen[t][tp] > tnbytes) {
                        anbytes += tilePartHeadLen[t][tp];
                        rateReached = true;
                        nBytes[t] += (tnbytes-anbytes);
                        break;
                    }
                    else {
                        anbytes += tilePartHeadLen[t][tp];
                        nBytes[t] += (tilePartLen[t][tp]-
                                      tilePartHeadLen[t][tp]);
                    }
                }
                else {
                    if(anbytes+tilePartHeadLen[t][tp] > tnbytes) {
                        break;
                    }
                    else {
                        anbytes += tilePartHeadLen[t][tp];
                    }
                }
                
                // If this is first tile-part, remember header length
                if(tptot == 0)
                    firstTilePartHeadLen = tilePartHeadLen[t][tp];
                
                // Go to the beginning of next tile part
                tilePartsRead[t]++;
                in.seek(tilePartStart+tilePartLen[t][tp]);
                remainingTileParts--;
                tptot++;
            }
        } catch(EOFException e) {
            if(pl.getBooleanParameter("cdstr_info"))
               FacilityManager.getMsgLogger().
                   printmsg(MsgLogger.INFO,strInfo); 
	    FacilityManager.getMsgLogger().
		printmsg(MsgLogger.WARNING,"Codestream truncated in tile "+t);

            // Bit-rate allocation
            if(!isTruncMode)
                allocateRate();

            // Update 'res' value once all tile-part headers are read
            if(pl.getParameter("res") == null){
                res = decSpec.dls.getMin();
            }
            else{
                try {
                    res = pl.getIntParameter("res");
                    if(res<0){
                        throw new
                            IllegalArgumentException("Specified negative "+
                                                     "resolution level "+