/* * CVS identifier: * * $Id: FileCodestreamWriter.java,v 1.1.1.1 2002/07/22 09:26:47 grosbois Exp $ * * Class:                   FileCodestreamWriter * * Description:             Implementation of the bit stream writer for streams. * * * * 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.codestream.*;import java.io.*;/** * This class implements a CodestreamWriter for Java streams. The streams can * be files or network connections, or any other resource that presents itself * as a OutputStream. See the CodestreamWriter abstract class for more details * on the implementation of the CodestreamWriter abstract class. * * <p>Before any packet data is written to the bit stream (even in simulation * mode) the complete header should be written otherwise incorrect estimates * are given by getMaxAvailableBytes() for rate allocation. * * @see CodestreamWriter * */public class FileCodestreamWriter extends CodestreamWriter     implements Markers {    /** The upper limit for the value of the Nsop field of the SOP marker */    private final static int SOP_MARKER_LIMIT = 65535;    /** Index of the current tile */    private int tileIdx = 0;    /** The file to write */    private OutputStream out;    /** The number of bytes already written to the codestream, excluding the     * header length, magic number and header length info. */    int ndata=0;    /** The default buffer length, 1024 bytes */    public static int DEF_BUF_LEN = 1024;        /** Array used to store the SOP markers values */    byte sopMarker[];    /** Array used to store the EPH markers values */    byte ephMarker[];        /** The packet index (when start of packet markers i.e. SOP markers) are     *  used. */    int packetIdx=0;        /** Offset of end of last packet containing ROI information */    private int offLastROIPkt = 0;    /** Length of last packets containing no ROI information */    private int lenLastNoROI = 0;    /**     * Opens the file 'file' for writing the codestream. The magic number is     * written to the bit stream. Normally, the header encoder must be empty     * (i.e. no data has been written to it yet). A BufferedOutputStream is     * used on top of the file to increase throughput, the length of the     * buffer is DEF_BUF_LEN.     *     * @param file The file where to write the bit stream     *     * @param mb The maximum number of bytes that can be written to the bit     * stream.     *     * @exception IOException If an error occurs while trying to open the file     * for writing or while writing the magic number.     * */    public FileCodestreamWriter(File file, int mb) throws IOException {        super(mb);        out = new BufferedOutputStream(new FileOutputStream(file),DEF_BUF_LEN);        initSOP_EPHArrays();    }    /**     * Opens the file named 'fname' for writing the bit stream, using the 'he'     * header encoder. The magic number is written to the bit     * stream. Normally, the header encoder must be empty (i.e. no data has     * been written to it yet). A BufferedOutputStream is used on top of the     * file to increase throughput, the length of the buffer is DEF_BUF_LEN.     *     * @param fname The name of file where to write the bit stream     *     * @param mb The maximum number of bytes that can be written to the bit     * stream.     *     * @param encSpec The encoder's specifications     *     * @exception IOException If an error occurs while trying to open the file     * for writing or while writing the magic number.     * */    public FileCodestreamWriter(String fname, int mb) throws IOException {        super(mb);        out = new BufferedOutputStream(new FileOutputStream(fname),                                       DEF_BUF_LEN);        initSOP_EPHArrays();    }    /**     * Uses the output stream 'os' for writing the bit stream, using the 'he'     * header encoder. The magic number is written to the bit     * stream. Normally, the header encoder must be empty (i.e. no data has     * been written to it yet). No BufferedOutputStream is used on top of the     * output stream 'os'.     *     * @param os The output stream where to write the bit stream.     *     * @param mb The maximum number of bytes that can be written to the bit     * stream.     *     * @exception IOException If an error occurs while writing the magic     * number to the 'os' output stream.     * */    public FileCodestreamWriter(OutputStream os, int mb) throws IOException {        super(mb);        out = os;        initSOP_EPHArrays();    }    /**     * Returns the number of bytes remaining available in the bit stream. This     * is the maximum allowed number of bytes minus the number of bytes that     * have already been written to the bit stream. If more bytes have been     * written to the bit stream than the maximum number of allowed bytes,     * then a negative value is returned.     *     * @return The number of bytes remaining available in the bit stream.     * */    public final int getMaxAvailableBytes() {        return maxBytes-ndata;    }    /**     * Returns the current length of the entire bit stream.     *     * @return the current length of the bit stream     * */    public int getLength() {        if (getMaxAvailableBytes() >= 0) {            return ndata;        }        else {            return maxBytes;        }    }    /**     * Writes a packet head to the bit stream and returns the number of bytes     * used by this header. It returns the total number of bytes that the     * packet head takes in the bit stream. If in simulation mode then no data     * is written to the bit stream but the number of bytes is     * calculated. This can be used for iterative rate allocation.     *     * <P>If the length of the data that is to be written to the bit stream is     * more than the space left (as returned by getMaxAvailableBytes()) only     * the data that does not exceed the allowed length is written, the rest     * is discarded. However the value returned by the method is the total     * length of the packet, as if all of it was written to the bit stream.     *     * <P>If the bit stream header has not been commited yet and 'sim' is     * false, then the bit stream header is automatically commited (see     * commitBitstreamHeader() method) before writting the packet.     *     * @param head The packet head data.     *     * @param hlen The number of bytes in the packet head.     *     * @param sim Simulation mode flag. If true nothing is written to the bit     * stream, but the number of bytes that would be written is returned.     *     * @param sop Start of packet header marker flag. This flag indicates     * whether or not SOP markers should be written. If true, SOP markers     * should be written, if false, they should not.     *     * @param eph End of Packet Header marker flag. This flag indicates     * whether or not EPH markers should be written. If true, EPH markers     * should be written, if false, they should not.     *     * @return The number of bytes spent by the packet head.     *     * @exception IOException If an I/O error occurs while writing to the     * output stream.     *     * @see #commitBitstreamHeader     * */     public int writePacketHead(byte head[],int hlen,boolean sim, 			       boolean sop, boolean eph) throws IOException{        int len = hlen	    + (sop?Markers.SOP_LENGTH:0) 	    + (eph?Markers.EPH_LENGTH:0);                // If not in simulation mode write the data         if(!sim){ 	    // Write the head bytes 	    if(getMaxAvailableBytes()<len){		len = getMaxAvailableBytes(); 	    }             if(len > 0){                 // Write Start Of Packet header markers if necessary                 if(sop){                     // The first 4 bytes of the array have been filled in the                     // classe's constructor.                     sopMarker[4] = (byte)(packetIdx>>8);                     sopMarker[5] = (byte)(packetIdx);                     out.write(sopMarker, 0, Markers.SOP_LENGTH);                     packetIdx++;                     if(packetIdx>SOP_MARKER_LIMIT){                         // Reset SOP value as we have reached its upper limit                         packetIdx = 0;                     }                 }                 out.write(head,0,hlen); 		// Update data length 		ndata += len;                 // Write End of Packet Header markers if necessary                 if(eph){                     out.write(ephMarker,0,Markers.EPH_LENGTH);                }                 // Deal with ROI Information                lenLastNoROI += len;            }         }        return len;     }    /**     * Writes a packet body to the bit stream and returns the number of bytes     * used by this body .If in simulation mode then no data is written to the     * bit stream but the number of bytes is calculated. This can be used for     * iterative rate allocation.     *     * <P>If the length of the data that is to be written to the bit stream is     * more than the space left (as returned by getMaxAvailableBytes()) only     * the data that does not exceed the allowed length is written, the rest     * is discarded. However the value returned by the method is the total     * length of the packet body , as if all of it was written to the bit     * stream.     *     * @param body The packet body data.     *     * @param blen The number of bytes in the packet body.     *     * @param sim Simulation mode flag. If true nothing is written to the bit     * stream, but the number of bytes that would be written is returned.     *     * @param roiInPkt Whether or not this packet contains ROI information     *     * @param roiLen Number of byte to read in packet body to get all the ROI     * information      *     * @return The number of bytes spent by the packet body.     *     * @exception IOException If an I/O error occurs while writing to the     * output stream.     *     * @see #commitBitstreamHeader     * */     public int writePacketBody(byte body[],int blen,boolean sim,                               boolean roiInPkt, int roiLen)         throws IOException{         int len = blen;         // If not in simulation mode write the data         if (!sim) {             // Write the body bytes             len = blen;             if(getMaxAvailableBytes() < len){                len = getMaxAvailableBytes();             }             if(blen > 0){                out.write(body,0,len);             }             // Update data length             ndata += len;             // Deal with ROI information            if(roiInPkt) {                offLastROIPkt += lenLastNoROI + roiLen;                lenLastNoROI = len-roiLen;            } else {                lenLastNoROI += len;            }        }        return len;     }    /**     * Writes the EOC marker and closes the underlying stream.     *     * @exception IOException If an error occurs while closing the underlying     * stream.     * */    public void close() throws IOException {	// Write the EOC marker and close the codestream.        out.write(EOC>>8);        out.write(EOC);                ndata += 2; // Add two to length of codestream for EOC marker                out.close();    }    /**      * Gives the offset of the end of last packet containing ROI information      *     * @return End of last ROI packet      * */    public int getOffLastROIPkt(){        return offLastROIPkt;    }    /**     * Writes the header data in the codestream and actualize ndata with the     * header length. The header is either a MainHeaderEncoder or a     * TileHeaderEncoder.     *     * @param he The current header encoder.     *     * @exception IOException If an I/O error occurs while writing the data.     * */    public void commitBitstreamHeader(HeaderEncoder he) throws IOException {        // Actualize ndata        ndata += he.getLength();        he.writeTo(out);         // Write the header        // Reset packet index used for SOP markers        packetIdx = 0;        // Deal with ROI information        lenLastNoROI += he.getLength();    }    /**     * Performs the initialisation of the arrays that are used to store the     * values used to write SOP and EPH markers     * */    private void initSOP_EPHArrays() {                // Allocate and set first values of SOP marker as they will not be        // modified        sopMarker = new byte[Markers.SOP_LENGTH];        sopMarker[0] = (byte)(Markers.SOP>>8);        sopMarker[1] = (byte)Markers.SOP;        sopMarker[2] = (byte)0x00;        sopMarker[3] = (byte)0x04;        // Allocate and set values of EPH marker as they will not be        // modified        ephMarker = new byte[Markers.EPH_LENGTH];        ephMarker[0] = (byte)(Markers.EPH>>8);        ephMarker[1] = (byte)Markers.EPH;    }}