jpexs-decompiler/libsrc/gnujpdf/src/gnu/jpdf/PDFStream.java

/* 
 * $Id: PDFStream.java,v 1.2 2007/08/26 18:56:35 gil1 Exp $
 *
 * $Date: 2007/08/26 18:56:35 $
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public 
 * License as published by the Free Software Foundation; either 
 * version 2.1 of the License, or (at your option) any later version. 
 * 
 * This library is distributed in the hope that it will be useful, 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
 * Lesser General Public License for more details. 
 * 
 * You should have received a copy of the GNU Lesser General Public 
 * License along with this library; if not, write to the Free Software 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
package gnu.jpdf;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.zip.DeflaterOutputStream;

/**
 * This class implements a PDF stream object. In PDF, streams contain data
 * like the graphic operators that render a page, or the pixels of an image.
 *
 * <p>In PDF, a stream can be compressed using several different methods, or
 * left uncompressed. Here we support both uncompressed, and FlateDecode as
 * it's supported by the java core.
 *
 * @author Peter T Mount http://www.retep.org.uk/pdf/
 * @author Eric Z. Beard, ericzbeard@hotmail.com
 * @version $Revision: 1.2 $, $Date: 2007/08/26 18:56:35 $
 *
 */
public class PDFStream extends PDFObject implements Serializable
{


  /*
   * NOTE: The original class is the work of Peter T. Mount, who released it 
   * in the uk.org.retep.pdf package.  It was modified by Eric Z. Beard as 
   * follows: 
   * The package name was changed to gnu.jpdf.  
   * The formatting was changed a little bit.
   * It is still licensed under the LGPL.
   */

    /**
     * This holds the stream's content.
     */
    transient ByteArrayOutputStream buf;
    
    /**
     * True if we will compress the stream in the pdf file
     */
    boolean deflate;
    
    /**
     * Constructs a plain stream.
     * <p>By default, the stream will be compressed.
     */
    public PDFStream() {
        this(null);
    }
    
    /**
     * Constructs a stream. The supplied type is stored in the stream's header
     * and is used by other objects that extend the PDFStream class (like
     * PDFImage).
     * <p>By default, the stream will be compressed.
     * @param type type for the stream
     * @see PDFImage
     */
    public PDFStream(String type) {
        super(type);
        buf = new ByteArrayOutputStream();
        
        // default deflate mode
        deflate = false;
    }
    
    /**
     * @param mode true will FlatDecode the stream
     */
    public void setDeflate(boolean mode) {
    	// TODO: Restore the next line of code to allow deflate to occur.
        deflate = mode;
    }
    
    /**
     * Returs true if the stream will be compressed.
     * @return true if compression is enabled
     */
    public boolean getDeflate() {
        return deflate;
    }
    
    /**
     * Returns the OutputStream that will append to this stream.
     * @return The stream for this object
     */
    public OutputStream getOutputStream() {
        return (OutputStream)buf;
    }
    
    /**
     * Creates a PrintWriter that will append to this stream.
     * @return a PrintWriter to write to the stream
     */
    public PrintWriter getWriter() {
        return new PrintWriter(buf,true);
    }
    
    /**
     * This is for extenders, and provides access to the stream.
     * @return ByteArrayOutputStream containing the contents.
     */
    public ByteArrayOutputStream getStream() {
        return buf;
    }
    
    /**
     * @param os OutputStream to send the object to
     * @exception IOException on error
     */
    public void write(OutputStream os) throws IOException {
        writeStart(os);
        writeStream(os);
        // Unlike most PDF objects, we dont call writeEnd(os) because we
        // contain a stream
    }
    
    /**
     * This inserts the Streams length, then the actual stream, finally
     * the end of stream/object markers.
     *
     * <p>This is intended for anyone extending PDFStream, as objects
     * containing streams do no use writeEnd(), and they must be able
     * to write the actual stream.
     *
     * @param os OutputStream to send the object to
     * @exception IOException on error
     */
    public void writeStream(OutputStream os) throws IOException {
        if(deflate) {
            ByteArrayOutputStream b = new ByteArrayOutputStream();
            DeflaterOutputStream dos = new DeflaterOutputStream(b);
            //,new Deflater(Deflater.BEST_COMPRESSION,true));
            buf.writeTo(dos);
            dos.finish();
            dos.close();
            
            // FlatDecode is compatible with the java.util.zip.Deflater class
            os.write("/Filter /FlateDecode\n".getBytes());
            os.write("/Length ".getBytes());
            os.write(Integer.toString(b.size()+1).getBytes());
            os.write("\n>>\nstream\n".getBytes());
            b.writeTo(os);
            os.write("\n".getBytes());
        } else {
            // This is a non-deflated stream
            os.write("/Length ".getBytes());
            os.write(Integer.toString(buf.size()).getBytes());
            os.write("\n>>\nstream\n".getBytes());
            buf.writeTo(os);
        }
        
        os.write("endstream\nendobj\n".getBytes());
        
        // Unlike most PDF objects, we dont call writeEnd(os) because we
        // contain a stream
    }



  // Why is this here?  Did it have a specific purpose?

    
    /**
     * This implements our own special Serialization for this object.
     *
     * <p>Here we write the length of the stream's contents, then a byte
     * array of the contents. We have to do this, as ByteArrayOutputStream
     * is not serializable (hence the transient tag).
     *
     */
    private void writeObject(java.io.ObjectOutputStream out) throws IOException
    {
        out.writeInt(buf.size());
        out.write(buf.toByteArray());
    }
    
    /**
     * This implements our own special Serialization for this object
     *
     * <p>Here we read the length of the stream's contents, then a byte
     * array of the contents. Then we recreate a new ByteArrayOutputStream.
     * We have to do this, as ByteArrayOutputStream is not serializable
     * (hence the transient tag).
     *
     */
    private void readObject(java.io.ObjectInputStream in) throws IOException
    {
        int l = in.readInt();
        byte b[] = new byte[l];
        in.read(b,0,l);
        buf=new ByteArrayOutputStream(l);
        buf.write(b);
    }
    
}