org.jpedal.linear.LinearParser Maven / Gradle / Ivy

/*
 * ===========================================
 * Java Pdf Extraction Decoding Access Library
 * ===========================================
 *
 * Project Info:  http://www.idrsolutions.com
 * Help section for developers at http://www.idrsolutions.com/support/
 *
 * (C) Copyright 1997-2017 IDRsolutions and Contributors.
 *
 * This file is part of JPedal/JPDF2HTML5
 *
 @LICENSE@
 *
 * ---------------
 * LinearParser.java
 * ---------------
 */
package org.jpedal.linear;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.HashMap;
import java.util.Map;

import org.jpedal.FileAccess;
import org.jpedal.exception.PdfException;
import org.jpedal.io.LinearizedHintTable;
import org.jpedal.io.ObjectDecoder;
import org.jpedal.io.PdfFileReader;
import org.jpedal.io.PdfObjectReader;
import org.jpedal.objects.raw.LinearizedObject;
import org.jpedal.objects.raw.PageObject;
import org.jpedal.objects.raw.PdfDictionary;
import org.jpedal.objects.raw.PdfObject;
import org.jpedal.parser.PdfStreamDecoder;
import org.jpedal.utils.LogWriter;
import org.jpedal.utils.NumberUtils;
import org.jpedal.utils.repositories.FastByteArrayOutputStream;

public class LinearParser {

    /**
     * flag if we have tested - reset for every file
     */
    public boolean isLinearizationTested;

    private PageObject linObject;

    private final Map linObjects = new HashMap();

    private int linearPageCount = -1;

    /**
     * present if file Linearized
     */
    private PdfObject linearObj;

    /**
     * hold all data in Linearized Obj
     */
    private LinearizedHintTable linHintTable;

    private int E = -1;

    public org.jpedal.linear.LinearThread linearizedBackgroundReaderer;

    public void closePdfFile() {

        E = -1;
        linearObj = null;
        isLinearizationTested = false;
        linObjects.clear();
        if (linearizedBackgroundReaderer != null && linearizedBackgroundReaderer.isAlive()) {
            linearizedBackgroundReaderer.interrupt();
        }

        //wait to die
        while (linearizedBackgroundReaderer != null && linearizedBackgroundReaderer.isAlive() && !linearizedBackgroundReaderer.isInterrupted()) {
            try {
                Thread.sleep(500);
            } catch (final Exception e) {
                LogWriter.writeLog("Exception: " + e.getMessage());
            }
        }

        linHintTable = null;

    }

    private void testForLinearlized(final byte[] buffer, final PdfObjectReader currentPdfFile) {
        int start = 0, end = 0;
        boolean isLinear = false;

        isLinearizationTested = true;

        //scan for Linearized in text
        final int len = buffer.length;
        for (int i = 0; i < buffer.length; i++) {

            if (start == 0 && (i + 2) < len && buffer[i] == 'o' && buffer[i + 1] == 'b' && buffer[i + 2] == 'j') {
                start = i + 3;
            } else if (end == 0 && (i + 5) < len && buffer[i] == 'e' && buffer[i + 1] == 'n' && buffer[i + 2] == 'd' && buffer[i + 3] == 'o' && buffer[i + 4] == 'b' && buffer[i + 5] == 'j') {
                end = i + 7;
            } else if (!isLinear && (i + 6) < len && buffer[i] == '/' && buffer[i + 1] == 'L' && buffer[i + 2] == 'i' && buffer[i + 3] == 'n' && buffer[i + 4] == 'e' && buffer[i + 5] == 'a' && buffer[i + 6] == 'r') {
                isLinear = true;
            }
        }
        
        /*
         * read linear object
         */
        if (isLinear) {
            final int dataLength = end - start;
            final byte[] data = new byte[dataLength + 1];

            System.arraycopy(buffer, start, data, 0, dataLength);
            linearObj = new LinearizedObject("0 0 R");
            linearObj.setStatus(PdfObject.UNDECODED_DIRECT);
            linearObj.setUnresolvedData(data, PdfDictionary.Linearized);

            currentPdfFile.checkResolved(linearObj);
        } else {
            linearObj = null;
        }

    }

    public boolean isPageAvailable(final int rawPage, final PdfObjectReader currentPdfFile) {

        boolean isPageAvailable = true;

        try {
            if (linearizedBackgroundReaderer != null && linearizedBackgroundReaderer.isAlive() && rawPage > 1 && linHintTable != null) {

                final Integer key = rawPage;

                //cached data
                if (linObjects.containsKey(key)) {
                    linObject = linObjects.get(key);

                    return true;
                }

                final int objID = linHintTable.getPageObjectRef(rawPage);

                //return if Page data not available
                final byte[] pageData = linHintTable.getObjData(objID);
                if (pageData != null) {
                    
                    /*
                     * turn page into obj
                     */
                    linObject = new PageObject(objID + " 0 R");
                    linObject.setStatus(PdfObject.UNDECODED_DIRECT);
                    linObject.setUnresolvedData(pageData, PdfDictionary.Page);
                    linObject.isDataExternal(true);

                    final PdfFileReader objectReader = currentPdfFile.getObjectReader();

                    //see if object and all refs loaded otherwise exit
                    if (!ObjectDecoder.resolveFully(linObject, objectReader)) {
                        isPageAvailable = false;
                    } else {  //cache once available
                        
                        /*
                         * check content as well
                         */
                        if (linObject != null) {

                            final byte[] b_data = currentPdfFile.getObjectReader().readPageIntoStream(linObject);

                            if (b_data == null) {
                                isPageAvailable = false;
                            } else {
                                //check Resources
                                final PdfObject Resources = linObject.getDictionary(PdfDictionary.Resources);

                                if (Resources == null) {
                                    linObject = null;
                                    isPageAvailable = false;
                                } else if (!ObjectDecoder.resolveFully(Resources, objectReader)) {
                                    linObject = null;
                                    isPageAvailable = false;
                                } else {
                                    Resources.isDataExternal(true);
                                    new PdfStreamDecoder(currentPdfFile).readResources(Resources, true);
                                    if (!Resources.isFullyResolved()) {
                                        linObject = null;
                                        isPageAvailable = false;
                                    }
                                }
                            }
                        }

                        if (isPageAvailable && linObject != null) {
                            linObjects.put(key, linObject);
                        }
                    }
                } else {
                    isPageAvailable = false;
                }
            } else {
                linObject = null;
            }

        } catch (final Exception e) {
            LogWriter.writeLog("Exception: " + e.getMessage());

            isPageAvailable = false;
        }

        return isPageAvailable;
    }

    public byte[] readLinearData(final PdfObjectReader currentPdfFile, final File tempURLFile, final InputStream is, final FileAccess fileAccess) throws IOException {

        final FileChannel fos = new RandomAccessFile(tempURLFile, "rws").getChannel();
        fos.force(true);

        final FastByteArrayOutputStream bos = new FastByteArrayOutputStream(8192);

        // Download buffer
        final byte[] buffer = new byte[4096];
        int read, bytesRead = 0;
        byte[] b;

        //main loop to read all the file bytes (carries on in thread if linearized)
        while ((read = is.read(buffer)) != -1) {

            if (read > 0) {
                synchronized (fos) {

                    b = new byte[read];
                    System.arraycopy(buffer, 0, b, 0, read);
                    final ByteBuffer f = ByteBuffer.wrap(b);
                    fos.write(f);
                }
            }

            bytesRead += read;

            //see if number of bytes loaded
            if (E != -1) {

                bos.write(buffer, 0, read);

                //once correct number of bytes for Linearized object read, start background thread to read rest and process Linearized/page 1
                if (E < bytesRead) {

                    final byte[] linearBytes = bos.toByteArray();

                    //holds all data and copy of file for access
                    linHintTable = new LinearizedHintTable(fos);
                    currentPdfFile.getObjectReader().storeLinearizedTables(linHintTable);

                    linearizedBackgroundReaderer = new LinearThread(is, fos, tempURLFile, linearObj, linearBytes, linHintTable, fileAccess);

                    return linearBytes;

                }
            } else if (!isLinearizationTested) {  //test if linearized

                testForLinearlized(buffer, currentPdfFile);

                if (linearObj != null) {
                    E = linearObj.getInt(PdfDictionary.E);
                    bos.write(buffer, 0, read);
                }
            }
        }

        // Close streams
        is.close();
        synchronized (fos) {
            fos.close();
        }

        return null;
    }


    public PdfObject readHintTable(final PdfObjectReader currentPdfFile) throws PdfException {

        long Ooffset = -1;

        linearPageCount = -1;

        final int O = linearObj.getInt(PdfDictionary.O);

        //read in the pages from the catalog and set values
        final PdfObject pdfObject;
        if (O != -1) {
            linearObj.setIntNumber(PdfDictionary.O, -1);
            currentPdfFile.getObjectReader().readReferenceTable(linearObj, currentPdfFile.getObjectReader());
            pdfObject = new PageObject(O, 0);
            currentPdfFile.readObject(pdfObject);

            //get page count from linear data
            linearPageCount = linearObj.getInt(PdfDictionary.N);

            Ooffset = currentPdfFile.getObjectReader().getOffset(O);

        } else { //use O as flag and reset
            pdfObject = currentPdfFile.getObjectReader().readReferenceTable(null, currentPdfFile.getObjectReader());
        }
        
        /*
         * read and decode the hints table
         */
        final int[] H = linearObj.getIntArray(PdfDictionary.H);

        final byte[] hintStream = currentPdfFile.getObjectReader().getBytes(H[0], H[1]);

        //find <<
        final int length = hintStream.length;
        int startHint = 0;
        int i = 0;
        boolean contentIsDodgy = false;

        //number
        int keyStart2 = i;
        while (hintStream[i] != 10 && hintStream[i] != 13 && hintStream[i] != 32 && hintStream[i] != 47 && hintStream[i] != 60 && hintStream[i] != 62) {

            if (hintStream[i] < 48 || hintStream[i] > 57) //if its not a number value it looks suspicious
            {
                contentIsDodgy = true;
            }

            i++;
        }

        //trap for content not correct
        if (!contentIsDodgy) {

            final int number = NumberUtils.parseInt(keyStart2, i, hintStream);

            //generation
            while (hintStream[i] == 10 || hintStream[i] == 13 || hintStream[i] == 32 || hintStream[i] == 47 || hintStream[i] == 60) {
                i++;
            }

            keyStart2 = i;
            //move cursor to end of reference
            while (i < 10 && hintStream[i] != 10 && hintStream[i] != 13 && hintStream[i] != 32 && hintStream[i] != 47 && hintStream[i] != 60 && hintStream[i] != 62) {
                i++;
            }
            final int generation = NumberUtils.parseInt(keyStart2, i, hintStream);

            while (i < length - 1) {

                if (hintStream[i] == '<' && hintStream[i + 1] == '<') {
                    startHint = i;
                    i = length;
                }

                i++;
            }

            final byte[] data = new byte[length - startHint];

            //convert the raw data into a PDF object
            System.arraycopy(hintStream, startHint, data, 0, data.length);
            final LinearizedObject hintObj = new LinearizedObject(number, generation);
            hintObj.setStatus(PdfObject.UNDECODED_DIRECT);
            hintObj.setUnresolvedData(data, PdfDictionary.Linearized);
            currentPdfFile.checkResolved(hintObj);

            //get page content pointers
            linHintTable.readTable(hintObj, linearObj, O, Ooffset);

        }

        return pdfObject;
    }

    public int getPageCount() {
        return linearPageCount;
    }

    public boolean hasLinearData() {
        return linearObj != null && E != -1;
    }

    public PdfObject getLinearPageObject() {
        return linObject;
    }

    public PdfObject getLinearObject(final boolean isOpen, final PdfObjectReader currentPdfFile) {

        //lazy initialisation if not URLstream
        if (!isLinearizationTested && isOpen) {
            testForLinearlized(currentPdfFile.getObjectReader().getBytes(0, 400), currentPdfFile);
        }

        return linearObj;
    }
}