since: 2.1.3 -

since: 2.1.3 -

since: 2.1.3 -

since: 2.1.3 -

since: 2.1.3 -

 protected PdfStream() 
{
        super();
        type = STREAM;
}

Constructs a PdfStream-object.

 public PdfStream(byte[] bytes) 
{
    // constructors
        super();
        type = STREAM;
        this.bytes = bytes;
        rawLength = bytes.length;
        put(PdfName.LENGTH, new PdfNumber(bytes.length));
}

Constructs a PdfStream-object.

Parameters:

bytes - content of the new PdfObject as an array of byte.

 public PdfStream(InputStream inputStream,
    PdfWriter writer) 
{
        super();
        type = STREAM;
        this.inputStream = inputStream;
        this.writer = writer;
        ref = writer.getPdfIndirectReference();
        put(PdfName.LENGTH, ref);
}

Creates an efficient stream. No temporary array is ever created. The InputStream is totally consumed but is not closed. The general usage is:

InputStream in = ...;
PdfStream stream = new PdfStream(in, writer);
stream.flateCompress();
writer.addToBody(stream);
stream.writeLength();
in.close();

Parameters:

inputStream - the data to write to this stream

writer - the PdfWriter for this stream

 public  void flateCompress() 
{
    	flateCompress(DEFAULT_COMPRESSION);
}

Compresses the stream.

 public  void flateCompress(int compressionLevel) 
{
        if (!Document.compress)
            return;
        // check if the flateCompress-method has already been
        if (compressed) {
            return;
        }
    	this.compressionLevel = compressionLevel;
        if (inputStream != null) {
            compressed = true;
            return;
        }
        // check if a filter already exists
        PdfObject filter = PdfReader.getPdfObject(get(PdfName.FILTER));
        if (filter != null) {
            if (filter.isName()) {
                if (PdfName.FLATEDECODE.equals(filter))
                    return;
            }
            else if (filter.isArray()) {
                if (((PdfArray) filter).contains(PdfName.FLATEDECODE))
                    return;
            }
            else {
                throw new RuntimeException("Stream could not be compressed: filter is not a name or array.");
            }
        }
        try {
            // compress
            ByteArrayOutputStream stream = new ByteArrayOutputStream();
            DeflaterOutputStream zip = new DeflaterOutputStream(stream, new Deflater(compressionLevel));
            if (streamBytes != null)
                streamBytes.writeTo(zip);
            else
                zip.write(bytes);
            zip.close();
            // update the object
            streamBytes = stream;
            bytes = null;
            put(PdfName.LENGTH, new PdfNumber(streamBytes.size()));
            if (filter == null) {
                put(PdfName.FILTER, PdfName.FLATEDECODE);
            }
            else {
                PdfArray filters = new PdfArray(filter);
                filters.add(PdfName.FLATEDECODE);
                put(PdfName.FILTER, filters);
            }
            compressed = true;
        }
        catch(IOException ioe) {
            throw new ExceptionConverter(ioe);
        }
}

Compresses the stream.

 public int getRawLength() 
{
        return rawLength;
}

Gets the raw length of the stream.

 protected  void superToPdf(PdfWriter writer,
    OutputStream os) throws IOException 
{
        super.toPdf(writer, os);
}

 public  void toPdf(PdfWriter writer,
    OutputStream os) throws IOException 
{
        if (inputStream != null && compressed)
            put(PdfName.FILTER, PdfName.FLATEDECODE);
        PdfEncryption crypto = null;
        if (writer != null)
            crypto = writer.getEncryption();
        if (crypto != null) {
            PdfObject filter = get(PdfName.FILTER);
            if (filter != null) {
                if (PdfName.CRYPT.equals(filter))
                    crypto = null;
                else if (filter.isArray()) {
                    ArrayList af = ((PdfArray)filter).getArrayList();
                    if (!af.isEmpty() && PdfName.CRYPT.equals(af.get(0)))
                        crypto = null;
                }
            }
        }
        PdfObject nn = get(PdfName.LENGTH);
        if (crypto != null && nn != null && nn.isNumber()) {
            int sz = ((PdfNumber)nn).intValue();
            put(PdfName.LENGTH, new PdfNumber(crypto.calculateStreamSize(sz)));
            superToPdf(writer, os);
            put(PdfName.LENGTH, nn);
        }
        else
            superToPdf(writer, os);
        os.write(STARTSTREAM);
        if (inputStream != null) {
            rawLength = 0;
            DeflaterOutputStream def = null;
            OutputStreamCounter osc = new OutputStreamCounter(os);
            OutputStreamEncryption ose = null;
            OutputStream fout = osc;
            if (crypto != null && !crypto.isEmbeddedFilesOnly())
                fout = ose = crypto.getEncryptionStream(fout);
            if (compressed)    
                fout = def = new DeflaterOutputStream(fout, new Deflater(compressionLevel), 0x8000);
            byte buf[] = new byte[4192];
            while (true) {
                int n = inputStream.read(buf);
                if (n < = 0)
                    break;
                fout.write(buf, 0, n);
                rawLength += n;
            }
            if (def != null)
                def.finish();
            if (ose != null)
                ose.finish();
            inputStreamLength = osc.getCounter();
        }
        else {
            if (crypto != null && !crypto.isEmbeddedFilesOnly()) {
                byte b[];
                if (streamBytes != null) {
                    b = crypto.encryptByteArray(streamBytes.toByteArray());
                }
                else {
                    b = crypto.encryptByteArray(bytes);
                }
                os.write(b);
            }
            else {
                if (streamBytes != null)
                    streamBytes.writeTo(os);
                else
                    os.write(bytes);
            }
        }
        os.write(ENDSTREAM);
}

 public String toString() 
{
    	if (get(PdfName.TYPE) == null) return "Stream";
    	return "Stream of type: " + get(PdfName.TYPE);
}

 public  void writeContent(OutputStream os) throws IOException 
{
        if (streamBytes != null)
            streamBytes.writeTo(os);
        else if (bytes != null)
            os.write(bytes);
}

Writes the data content to an OutputStream.

 public  void writeLength() throws IOException 
{
        if (inputStream == null)
            throw new UnsupportedOperationException("writeLength() can only be called in a contructed PdfStream(InputStream,PdfWriter).");
        if (inputStreamLength == -1)
            throw new IOException("writeLength() can only be called after output of the stream body.");
        writer.addToBody(new PdfNumber(inputStreamLength), ref, false);
}

Writes the stream length to the PdfWriter.

This method must be called and can only be called if the constructor #PdfStream(InputStream,PdfWriter) is used to create the stream.