filebitstreamreaderagent.java

jpeg2000算法实现

				lastByte = in.getPos()+
				    tilePartLen[t][curTilePart]-1-
				    tilePartHeadLen[t][curTilePart]; 
			    }

                            // Read SOP marker segment if necessary
                            status = pktDec.
                                readSOPMarker(nBytes,precIdx[c][r][l],c,r);

                            if(status){
                                if(pl.getBooleanParameter("cdstr_info"))
                                  FacilityManager.getMsgLogger().
                                    printmsg(MsgLogger.INFO,strInfo);
                                return true;
                            }

                            if(!pph)
                                status = pktDec.
                                    readPktHead(l,r,c,precIdx[c][r][l],
                                                cbI[c][r],nBytes);
			    if(status) {
                                if(pl.getBooleanParameter("cdstr_info"))
                                    FacilityManager.getMsgLogger().
                                        printmsg(MsgLogger.INFO,strInfo);
				return true;
                            }
			    
			    // Store packet head length
                            hlen = in.getPos()-start;
			    pktHL.addElement(new Integer(hlen));
			    
			    status = 
				pktDec.readPktBody(l,r,c,precIdx[c][r][l],
                                                   cbI[c][r],nBytes);
                            plen = in.getPos()-start;
                            strInfo+= " Pkt l="+l+",r="+r+",c="+c+": "+
                                start+", "+plen+", "+hlen+"\n";
			    if(status){
                                if(pl.getBooleanParameter("cdstr_info"))
                                    FacilityManager.getMsgLogger().
                                        printmsg(MsgLogger.INFO,strInfo);
                                return true;
                            }
			    precIdx[c][r][l]++;
			} // End loop on layers
		    } // End test on precinct
  		} // End loop on resolution levels 
  	    } // End loop on components
 	} // End loop on precincts

        if(pl.getBooleanParameter("cdstr_info"))
            FacilityManager.getMsgLogger().printmsg(MsgLogger.INFO,strInfo);
	return false; // Decoding rate was not reached
    }
    
    /** 
     * Reads packets of the current tile according to the
     * component-position-resolution-layer progressiveness.
     *
     * @param lys Index of the first layer for each component and resolution
     *
     * @param lye Index of the last layer
     *
     * @param ress Index of the first resolution level
     *
     * @param rese Index of the last resolution level
     *
     * @param comps Index of the first component
     *
     * @param compe Index of the last component
     *
     * @return True if rate has been reached
     * */
    private boolean readCompPosResLy(int lys[][],int lye,int ress,int rese,
				     int comps,int compe,
                                     int curTilePart) 
        throws IOException{
        boolean pph=false;
	int t = getTileIdx(); // Current tile index
	boolean status=false; // True if decoding rate is reached when
        int lastByte = in.getPos()+tilePartLen[t][curTilePart]-1-
            tilePartHeadLen[t][curTilePart];

	int start;
	Coord xys[],xyInc;
	int x0,y0,x1,y1,xInc,yInc,x0_rl,y0_rl,xInc_rl,yInc_rl;
        int hlen,plen;
        String strInfo = "Tile "+getTileIdx()+" (tile-part:"+curTilePart+
            "): offset, length, header length\n";;

        if(((Boolean)decSpec.pphs.getTileDef(t)).booleanValue()){
            pph = true;
        }

	// precinct index
	int[][][] precIdx = new int[compe][rese][lye];

	for(int c=comps; c<compe; c++){// Loop on components
	    
	    // Loop on precints
	    xys = pktDec.getSotEotArrayMax(c);
	    x0 = xys[0].x;
	    y0 = xys[0].y;
	    x1 = xys[1].x;
	    y1 = xys[1].y;
	    
	    xyInc = pktDec.getIncArrayMax(c);
	    xInc = xyInc.x;
	    yInc = xyInc.y;
	    
	    // Loop on precincts
	    for(int y=y0; y<y1; y+=yInc)
		for(int x=x0; x<x1; x+=xInc){
		    
		    // Loop on resolution levels
		    for(int r=ress; r<rese; r++){
			// Check if resolution level is defined for this
			// component
			if(r>mdl[c]) continue;

			xyInc = pktDec.getIncArray(c,r);
			xInc_rl = xyInc.x;
			yInc_rl = xyInc.y;
			xys = pktDec.getSotEotArray(c,r);
			x0_rl = xys[0].x;
			y0_rl = xys[0].y;

			// Test on precinct
			if( ( (x==x0) || (x%xInc_rl==0) ) &&
			    ( (y==y0) || (y%yInc_rl==0) ) ){
			    
			    // Loop on layers
			    for(int l=lys[c][r]; l<lye; l++){
				start = in.getPos();

                                // If packed packet headers are used, there 
                                // is no need to check that there are bytes 
                                // enough to read header
                                if(pph)
                                    status = 
                                        pktDec.
                                        readPktHead(l,r,c,precIdx[c][r][l],
                                                    cbI[c][r],nBytes);


				// If we are about to read outside of
				// tile-part, skip to next tile-part
                                if(start>lastByte && 
                                   curTilePart < firstPackOff[t].length-1){
				    curTilePart++;
				    in.seek(firstPackOff[t][curTilePart]);
				    lastByte = in.getPos()+
					tilePartLen[t][curTilePart]-1-
					tilePartHeadLen[t][curTilePart]; 
				}

                                // Read SOP marker segment if necessary
                                status = pktDec.
                                    readSOPMarker(nBytes,precIdx[c][r][l],c,r);

                                if(status){
                                    if(pl.getBooleanParameter("cdstr_info"))
                                      FacilityManager.getMsgLogger().
                                        printmsg(MsgLogger.INFO,strInfo);
                                    return true;
                                }

                                if(!pph)
                                    status = 
                                        pktDec.
                                        readPktHead(l,r,c,precIdx[c][r][l],
                                                    cbI[c][r],nBytes);
				if(status){
                                    if(pl.getBooleanParameter("cdstr_info"))
                                        FacilityManager.getMsgLogger().
                                            printmsg(MsgLogger.INFO,strInfo);
				    return true;
				}
			    
				// Store packet head length
                                hlen = in.getPos()-start;
				pktHL.addElement(new Integer(hlen));
			    
				status = 
				    pktDec.readPktBody(l,r,c,precIdx[c][r][l],
                                                       cbI[c][r],nBytes);
                                plen = in.getPos()-start;
                                strInfo+= " Pkt l="+l+",r="+r+",c="+c+": "+
                                    start+", "+plen+", "+hlen+"\n";
				if(status){
                                    if(pl.getBooleanParameter("cdstr_info"))
                                        FacilityManager.getMsgLogger().
                                            printmsg(MsgLogger.INFO,strInfo);
				    return true;
				}
				precIdx[c][r][l]++;
			    } // End loop on layers
			} // End test on precincts
		    } // End loop on resolution levels 
		} // End loop on precincts
	} // End loop on components

        if(pl.getBooleanParameter("cdstr_info"))
            FacilityManager.getMsgLogger().printmsg(MsgLogger.INFO,strInfo);
	return false; // Decoding rate was not reached
    }

    /** 
     * Finish initialization of members for specified tile, reads packets head
     * of each tile and keeps location of each code-block's codewords. The
     * last 2 tasks are done by calling specific methods of PktDecoder.
     *
     * <P>Then, if a parsing output rate is defined, it keeps information of
     * first layers only. This operation simulates a creation of a
     * layer-resolution-component progressive bit-stream which will be next
     * truncated and decoded.
     *
     * @param t Tile index
     *
     * @see PktDecoder
     * */
    private void initTile(int t) throws IOException{
	pktHL = new Vector();

        // Number of layers
        int nl = ((Integer)decSpec.nls.getTileDef(t)).intValue();

        // If packed packet headers was used, get the packet headers for this
        // tile
        if(((Boolean)decSpec.pphs.getTileDef(t)).booleanValue()){
            // Get packed headers as separate input stream
            ByteArrayInputStream pphbais=hd.getPackedPktHead(t);
            
            // Restarts PacketDecoder instance
            cbI = pktDec.restart(nc,mdl,nl,cbI,true,pphbais);
        }
        else{
            // Restarts PacketDecoder instance
            cbI = pktDec.restart(nc,mdl,nl,cbI,false,null);
        }

        // Reads packets of the tile according to the progression order
        int[][] pocSpec = ((int[][])decSpec.pcs.getTileDef(t));
        int nChg = (pocSpec==null) ?  0 : pocSpec.length;

	// Create an array containing information about changes (progression
	// order type, layers index start, layer index end, resolution level
	// start, resolution level end, component index start, component index
	// end). There is one row per progresion order
	int[][] change = new int[nChg+1][6];
	int idx = 0; // Index of the current progression order
	
	// First progression order is given by the COD marker.
	change[0][0] = ((Integer)decSpec.pos.getTileDef(t)).intValue();
	change[0][1] = 0; // layer start

	for(idx=0; idx<nChg; idx++){
	    change[idx][1] = pocSpec[idx][2];// layer end
	    change[idx][2] = pocSpec[idx][0]; // res. lev. start
	    change[idx][3] = pocSpec[idx][3]; // res. lev. end
	    change[idx][4] = pocSpec[idx][1]; // Comp. index start
	    change[idx][5] = pocSpec[idx][4]; // Comp. index end
	    
	    // Next progression order type 
	    change[idx+1][0] = pocSpec[idx][5];
	}
	change[idx][1] = nl; // Layer index end
	change[idx][2] = 0; // resolution level start
	change[idx][3] = decSpec.dls.getMaxInTile(t)+1; // res. level end
	change[idx][4] = 0; // Component index start
	change[idx][5] = nc; // Component index end

        // Seek to the first packet in the first tile-part
	try{
            // If in truncation mode, the first tile-part may be beyond the
            // target decoding rate. In this case, the offset of the first
            // packet is not defined.
            if(isTruncMode && firstPackOff==null || firstPackOff[t]==null)
                return;
            in.seek(firstPackOff[t][0]);
	}
	catch(EOFException e){
	    FacilityManager.getMsgLogger().
		printmsg(MsgLogger.WARNING,"Codestream truncated in tile "+t);
            return;
	}

        curTilePart = 0;

        // Start and end indexes for layers, resolution levels and components.
        int lye,ress,rese,comps,compe;
	boolean status = false;
	int nb = nBytes[t];
	int[][] lys = new int[nc][];
	for(int c=0; c<nc; c++){
	    lys[c] = new int[((Integer)decSpec.dls.getTileCompVal(t,c)).
			    intValue()+1];
	}
	    
	try{
            for(int chg=0; chg<=nChg; chg++){
                lye = change[chg][1];
                ress = change[chg][2];
                rese = change[chg][3];
                comps = change[chg][4];
                compe = change[chg][5];
                
                switch(change[chg][0]){
                case LY_RES_COMP_POS_PROG:
                    status = readLyResCompPos(lys,lye,ress,rese,comps,compe,
                                              curTilePart);
                    break;
                case RES_LY_COMP_POS_PROG:
                    status = readResLyCompPos(lys,lye,ress,rese,comps,compe,
                                              curTilePart);
                    break;
                case RES_POS_COMP_LY_PROG:
                    status = readResPosCompLy(lys,lye,ress,rese,comps,compe,
                                              curTilePart);
                    break;
                case POS_COMP_RES_LY_PROG:
                    status = readPosCompResLy(lys,lye,ress,rese,comps,compe,
                                              curTilePart);
                    break;
                case COMP_POS_RES_LY_PROG:
                    status = readCompPosResLy(lys,lye,ress,rese,comps,compe,
                                              curTilePart);
                    break;
                default:
                    throw new IllegalArgumentException("Not recognized "+
                                                       "progression type");
                }
                
		// Update next first layer index 
		for(int c=comps; c<compe; c++) {
                    if(c>=lys.length) continue;
		    for(int r=ress; r<rese; r++) {
                        if(r>=lys[c].length) continue;
			lys[c][r] = lye;
                    }
                }

                if(status)
                    break;
            }
        }
	catch(EOFException e){