codestreammanipulator.java

来自「jpeg2000编解码」· Java 代码 · 共 712 行 · 第 1/2 页

                length -= Markers.EPH_LENGTH;   
                 if(tempEph){ // EPH marker is used and is skipped
                    fi.skipBytes(Markers.EPH_LENGTH); 
                 }

                packetData[t][p] = new byte[length];                
                fi.readFully(packetData[t][p],0,length);
                markIndex++;
            }
        }
    }

    /**
     * This method creates the tileparts from the buffered tile headers,
     * packet headers and packet data
     *
     * @exception java.io.IOException If an I/O error ocurred.
     * */
    private void createTileParts() throws IOException{
        int i,prem,t,length;
        int pIndex,phIndex;
        int tppStart;
        int tilePart;
        int p,np,nomnp;
        int numTileParts;
        int numPackets;
        ByteArrayOutputStream temp = new ByteArrayOutputStream();
        byte[] tempByteArr;

        // Create tile parts
        tileParts = new byte[nt][][];
        maxtp = 0;

        for(t=0; t<nt; t++){
            // Calculate number of tile parts. If tileparts are not used, 
            // put all packets in the first tilepart
            if(pptp == 0)
                pptp = ppt[t];
            prem = ppt[t];
            numTileParts = (int)Math.ceil(((double)prem)/pptp);
            numPackets = packetHeaders[t].length;
            maxtp = (numTileParts>maxtp) ? numTileParts:maxtp;
            tileParts[t] = new byte[numTileParts][];

            // Create all the tile parts for tile t
            tppStart = 0;
            pIndex = 0;
            p=0;
            phIndex = 0;

            for(tilePart=0;tilePart<numTileParts;tilePart++){
            
                // Calculate number of packets in this tilepart
                nomnp = (pptp > prem) ? prem:pptp;
                np = nomnp;

                // Write tile part header
                if(tilePart == 0){
                    // Write original tile part header up to SOD marker
                    temp.write(tileHeaders[t],0,
                               tileHeaders[t].length-2);
                }else{
                    // Write empty header of length TP_HEAD_LEN-2
                    temp.write(new byte[TP_HEAD_LEN-2],0,TP_HEAD_LEN-2);
                }

                // Write PPT marker segments if PPT used
                if(pptUsed){ 
                    int pptLength = 3; // Zppt and Lppt
                    int pptIndex = 0;
                    int phLength;
                    
                    p = pIndex;
                    while(np>0){
                        phLength = packetHeaders[t][p].length;
 
                        // If the total legth of the packet headers is greater
                        // than MAX_LPPT, several PPT markers are needed
                        if(pptLength + phLength > Markers.MAX_LPPT){ 

                            temp.write(Markers.PPT>>>8);
                            temp.write(Markers.PPT);
                            temp.write(pptLength>>>8);
                            temp.write(pptLength);
                            temp.write(pptIndex++);
                            for(i=pIndex; i < p ; i++){
                                temp.write(packetHeaders[t][i],0,
                                           packetHeaders[t][i].length);
                            }
                            pptLength = 3; // Zppt and Lppt
                            pIndex = p;
                        }
                        pptLength += phLength;
                        p++;
                        np--;
                    }
                    // Write last PPT marker
                    temp.write(Markers.PPT>>>8);
                    temp.write(Markers.PPT);
                    temp.write(pptLength>>>8);
                    temp.write(pptLength);
                    temp.write(pptIndex);
                    for(i=pIndex; i < p ; i++){

                        temp.write(packetHeaders[t][i],0,
                                   packetHeaders[t][i].length);
                    }
                }
                pIndex = p;
                np = nomnp;

                // Write SOD marker
                temp.write(Markers.SOD>>>8);
                temp.write(Markers.SOD);

                // Write packet data and packet headers if PPT and PPM not used
                for(p=tppStart; p<tppStart+np ; p++){
                  if(!tempSop){
                        temp.write(sopMarkSeg[t][p],0,Markers.SOP_LENGTH);
                  }

                    if(!(ppmUsed || pptUsed)){
                        temp.write(packetHeaders[t][p],0,
                                   packetHeaders[t][p].length);
                    }

                    temp.write(packetData[t][p], 0, packetData[t][p].length);
                }
                tppStart += np;

                // Edit tile part header
                tempByteArr = temp.toByteArray();
                tileParts[t][tilePart] = tempByteArr;
                length = temp.size();

                if(tilePart == 0){
                    // Edit first tile part header
                    tempByteArr[6] = (byte)(length>>>24);         // Psot
                    tempByteArr[7] = (byte)(length>>>16);
                    tempByteArr[8] = (byte)(length>>>8);
                    tempByteArr[9] = (byte)(length);
                    tempByteArr[10] = (byte)(0);                  // TPsot
                    tempByteArr[11] = (byte)(numTileParts);       // TNsot
                }else{
                    // Edit tile part header
                    tempByteArr[0] = (byte)(Markers.SOT>>>8);     // SOT
                    tempByteArr[1] = (byte)(Markers.SOT);
                    tempByteArr[2] = (byte)(0);                   // Lsot
                    tempByteArr[3] = (byte)(10); 
                    tempByteArr[4] = (byte)(t>>>8);               // Isot
                    tempByteArr[5] = (byte)(t);                   // 
                    tempByteArr[6] = (byte)(length>>>24);         // Psot
                    tempByteArr[7] = (byte)(length>>>16);
                    tempByteArr[8] = (byte)(length>>>8);
                    tempByteArr[9] = (byte)(length);
                    tempByteArr[10] = (byte)(tilePart);           //TPsot
                    tempByteArr[11] = (byte)(numTileParts);       // TNsot
                }
                temp.reset();
                prem -= np;
            }
        }
        temp.close();
    }

    /**
     * This method writes the new codestream to the file. 
     *
     * @param fi The file to write the new codestream to
     *
     * @exception java.io.IOException If an I/O error ocurred.
     * */
    private void writeNewCodestream(BufferedRandomAccessFile fi)
        throws IOException{
        int i,t,p,tp;
        int numTiles = tileParts.length;
        int[][] packetHeaderLengths = new int[numTiles][maxtp];
        byte[] temp;
        int length;

        // Write main header up to SOT marker
        fi.write(mainHeader,0,mainHeader.length);

        // If PPM used write all packet headers in PPM markers
        if(ppmUsed){
            ByteArrayOutputStream ppmMarkerSegment =
                new ByteArrayOutputStream();
            int numPackets;
            int totNumPackets;
            int ppmIndex=0;
            int ppmLength;
            int pStart,pStop;
            int prem[] = new int[numTiles];
            
            // Set number of remaining packets 
            for(t=0 ; t<numTiles ; t++){
                prem[t] = packetHeaders[t].length;
            }
                
            // Calculate Nppm values 
            for(tp=0; tp<maxtp ; tp++){ 
                for(t=0 ; t<numTiles ; t++){
                    if(tileParts[t].length > tp){
                        totNumPackets = packetHeaders[t].length;
                        // Calculate number of packets in this tilepart
                        numPackets = 
                            (tp == tileParts[t].length-1) ? 
                            prem[t] : pptp; 

                        pStart = totNumPackets - prem[t];
                        pStop = pStart + numPackets;
                        
                        // Calculate number of packet header bytes for this
                        // tile part
                        for(p=pStart ; p < pStop ; p++)
                            packetHeaderLengths[t][tp] += 
                                packetHeaders[t][p].length;

                        prem[t] -= numPackets;
                    }                   
                }
            }
            
            // Write first PPM marker
            ppmMarkerSegment.write(Markers.PPM >>> 8);
            ppmMarkerSegment.write(Markers.PPM);
            ppmMarkerSegment.write(0); // Temporary Lppm value
            ppmMarkerSegment.write(0); // Temporary Lppm value
            ppmMarkerSegment.write(0); // zppm
            ppmLength = 3;
            ppmIndex++;
            
            // Set number of remaining packets 
            for(t=0 ; t<numTiles ; t++)
                prem[t] = packetHeaders[t].length;
            
            // Write all PPM markers and information
            for(tp=0; tp<maxtp ; tp++){  
                for(t=0 ; t<numTiles ; t++){

                    if(tileParts[t].length > tp){
                        totNumPackets = packetHeaders[t].length;
                        
                        // Calculate number of packets in this tilepart
                        numPackets = 
                            (tp == tileParts[t].length-1) ? prem[t] : pptp; 
                        
                        pStart = totNumPackets - prem[t];
                        pStop = pStart + numPackets;
                        
                        // If Nppm value wont fit in current PPM marker segment
                        // write current PPM marker segment and start new
                        if(ppmLength + 4 > Markers.MAX_LPPM){
                            // Write current PPM marker
                            temp = ppmMarkerSegment.toByteArray();
                            length = temp.length-2;
                            temp[2] = (byte)(length >>> 8);
                            temp[3] = (byte)length;
                            fi.write(temp,0,length+2);

                            // Start new PPM marker segment
                            ppmMarkerSegment.reset();
                            ppmMarkerSegment.write(Markers.PPM >>> 8);
                            ppmMarkerSegment.write(Markers.PPM);
                            ppmMarkerSegment.write(0); // Temporary Lppm value
                            ppmMarkerSegment.write(0); // Temporary Lppm value
                            ppmMarkerSegment.write(ppmIndex++); // zppm
                            ppmLength = 3;
                        }
                        
                        // Write Nppm value
                        length = packetHeaderLengths[t][tp];
                        ppmMarkerSegment.write(length>>>24);
                        ppmMarkerSegment.write(length>>>16);
                        ppmMarkerSegment.write(length>>>8);
                        ppmMarkerSegment.write(length);
                        ppmLength += 4;
                        
                        // Write packet headers
                        for(p=pStart ; p < pStop ; p++){
                            length = packetHeaders[t][p].length;

                            // If next packet header value wont fit in 
                            // current PPM marker segment write current PPM 
                            // marker segment and start new
                            if(ppmLength + length > Markers.MAX_LPPM){
                                // Write current PPM marker
                                temp = ppmMarkerSegment.toByteArray();
                                length = temp.length-2;
                                temp[2] = (byte)(length >>> 8);
                                temp[3] = (byte)length;
                                fi.write(temp,0,length+2);

                                // Start new PPM marker segment
                                ppmMarkerSegment.reset();
                                ppmMarkerSegment.write(Markers.PPM >>> 8);
                                ppmMarkerSegment.write(Markers.PPM);
                                ppmMarkerSegment.write(0); // Temp Lppm value
                                ppmMarkerSegment.write(0); // Temp Lppm value
                                ppmMarkerSegment.write(ppmIndex++); // zppm
                                ppmLength = 3;
                            }
                            
                            // write packet header 
                            ppmMarkerSegment.write(packetHeaders[t][p],0,
                                                   packetHeaders[t][p].length);
                            ppmLength+=packetHeaders[t][p].length;
                        }
                        prem[t]-=numPackets;
                    }
                }
            }
            // Write last PPM marker segment
            temp = ppmMarkerSegment.toByteArray();
            length = temp.length-2;
            temp[2] = (byte)(length >>> 8);
            temp[3] = (byte)length;
            fi.write(temp,0,length+2);
        }

        // Write tile parts interleaved
        for(tp=0;tp<maxtp;tp++){
            for(t=0 ; t<nt ;t++){
                if(tileParts[t].length > tp){
                    temp = tileParts[t][tp];
                    length = temp.length;
                    fi.write(temp,0,length);
                }
            }
        }
        fi.writeShort(Markers.EOC);
    }
}