/* * * Class:                   ImgWriterPPM * * Description:             Image writer for unsigned 8 bit data in *                          PPM files. * * * * 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.image.input;import jj2000.j2k.image.*;import jj2000.j2k.io.*;import jj2000.j2k.*;import java.io.*;/** * This class implements the ImgData interface for reading 8 bits unsigned * data from a binary PPM file * * <P> After being read the coefficients are level shifted by subtracting * 2^(nominal bit range - 1) * * <P>The transfer type (see ImgData) of this class is TYPE_INT. * * <P>This class is <i>buffered</i>: the 3 input components(R,G,B) are read * when the first one (R) is asked. The 2 others are stored until they are * needed. * * <P>NOTE: This class is not thread safe, for reasons of internal buffering. * * @see ImgData * */public class ImgReaderPPM extends ImgReader {    /** DC offset value used when reading image */    public static int DC_OFFSET = 128;    /** Where to read the data from */    private RandomAccessFile in;        /** The offset of the raw pixel data in the PPM file */    private int offset;    /** The number of bits that determine the nominal dynamic range */    private int rb;    /** Buffer for the 3 components of each pixel(in the current block) */    private int[][] barr = new int[3][];    /** Data block used only to store coordinates of the buffered blocks */    private DataBlkInt dbi = new DataBlkInt();    /** The line buffer. */    // This makes the class not thread safe (but it is not the only one making    // it so)    private byte buf[];    /** Temporary DataBlkInt object (needed when encoder uses floating-point        filters). This avoid allocating new DataBlk at each time */    private DataBlkInt intBlk;    /**     * Creates a new PPM file reader from the specified file.     *     * @param file The input file.     *     * @param IOException If an error occurs while opening the file.     * */    public ImgReaderPPM(File file) throws IOException {        this(new RandomAccessFile(file,"r"));    }    /**     * Creates a new PPM file reader from the specified file name.     *     * @param fname The input file name.     *     * @param IOException If an error occurs while opening the file.     * */    public ImgReaderPPM(String fname) throws IOException {        this(new RandomAccessFile(fname,"r"));    }    /**     * Creates a new PPM file reader from the specified RandomAccessFile     * object. The file header is read to acquire the image size.     *     * @param in From where to read the data     *     * @exception EOFException if an EOF is read     * @exception IOException if an error occurs when opening the file     * */    private ImgReaderPPM(RandomAccessFile in)throws EOFException,IOException {        this.in = in;        confirmFileType();        skipCommentAndWhiteSpace();        w=readHeaderInt();        skipCommentAndWhiteSpace();        h=readHeaderInt();        skipCommentAndWhiteSpace();        /*Read the highest pixel value from header (not used)*/        readHeaderInt();        nc=3;        rb=8;        }                    /**     * Closes the underlying file from where the image data is being read. No     * operations are possible after a call to this method.     *     * @exception IOException If an I/O error occurs.     * */    public void close() throws IOException {        in.close();        in = null;        // Free memory        barr[0] = null;        barr[1] = null;        barr[2] = null;        buf = null;    }    /**     * Returns the number of bits corresponding to the nominal range of the     * data in the specified component. This is the value rb (range bits) that     * was specified in the constructor, which normally is 8 for non bilevel     * data, and 1 for bilevel data.     *     * <P>If this number is <i>b</b> then the nominal range is between     * -2^(b-1) and 2^(b-1)-1, since unsigned data is level shifted to have a     * nominal avergae of 0.     *     * @param c The index of the component.     *     * @return The number of bits corresponding to the nominal range of the     * data. For floating-point data this value is not applicable and the     * return value is undefined.     * */    public int getNomRangeBits(int c) {        // Check component index        if (c<0 || c>2)            throw new IllegalArgumentException();        return rb;    }    /**     * Returns the position of the fixed point in the specified component     * (i.e. the number of fractional bits), which is always 0 for this     * ImgReader.     *     * @param c The index of the component.     *     * @return The position of the fixed-point (i.e. the number of fractional     * bits). Always 0 for this ImgReader.     * */    public int getFixedPoint(int c) {        // Check component index        if (c<0 || c>2)           throw new IllegalArgumentException();        return 0;    }    /**     * Returns, in the blk argument, the block of image data containing the     * specifed rectangular area, in the specified component. The data is     * returned, as a reference to the internal data, if any, instead of as a     * copy, therefore the returned data should not be modified.     *     * <P> After being read the coefficients are level shifted by subtracting     * 2^(nominal bit range - 1)     *     * <P>The rectangular area to return is specified by the 'ulx', 'uly', 'w'     * and 'h' members of the 'blk' argument, relative to the current     * tile. These members are not modified by this method. The 'offset' and     * 'scanw' of the returned data can be arbitrary. See the 'DataBlk' class.     *     * <P>If the data array in <tt>blk</tt> is <tt>null</tt>, then a new one     * is created if necessary. The implementation of this interface may     * choose to return the same array or a new one, depending on what is more     * efficient. Therefore, the data array in <tt>blk</tt> prior to the     * method call should not be considered to contain the returned data, a     * new array may have been created. Instead, get the array from     * <tt>blk</tt> after the method has returned.     *     * <P>The returned data always has its 'progressive' attribute unset     * (i.e. false).     *     * <P>When an I/O exception is encountered the JJ2KExceptionHandler is     * used. The exception is passed to its handleException method. The action     * that is taken depends on the action that has been registered in     * JJ2KExceptionHandler. See JJ2KExceptionHandler for details.     *     * <P>This method implements buffering for the 3 components: When the     * first one is asked, all the 3 components are read and stored until they     * are needed.     *     * @param blk Its coordinates and dimensions specify the area to     * return. Some fields in this object are modified to return the data.     *     * @param c The index of the component from which to get the data. Only 0,     * 1 and 3 are valid.     *     * @return The requested DataBlk     *     * @see #getCompData     *     * @see JJ2KExceptionHandler     **/    public final DataBlk getInternCompData(DataBlk blk, int c) {        // Check component index        if (c<0||c>2)            throw new IllegalArgumentException();	// Check type of block provided as an argument	if(blk.getDataType()!=DataBlk.TYPE_INT){	    if(intBlk==null)		intBlk = new DataBlkInt(blk.ulx,blk.uly,blk.w,blk.h);	    else{		intBlk.ulx = blk.ulx;		intBlk.uly = blk.uly;		intBlk.w = blk.w;		intBlk.h = blk.h;	    }	    blk = intBlk;	}        // If asking a component for the first time for this block, read the 3        // components        if ((barr[c] == null) ||