Example usage for com.itextpdf.text.pdf PdfReader getPdfVersion

List of usage examples for com.itextpdf.text.pdf PdfReader getPdfVersion

Introduction

In this page you can find the example usage for com.itextpdf.text.pdf PdfReader getPdfVersion.

Prototype

public char getPdfVersion() 

Source Link

Document

Gets the PDF version.

Usage

From source file:cz.hobrasoft.pdfmu.operation.OperationInspect.java

License:Open Source License

private Inspect execute(PdfReader pdfReader) throws OperationException {
    Inspect result = new Inspect();

    // Fetch the PDF version of the input PDF document
    PdfVersion inVersion = new PdfVersion(pdfReader.getPdfVersion());
    to.println(String.format("PDF version: %s", inVersion));
    result.version = inVersion.toString();

    result.properties = get(pdfReader);/*from   w w  w. j a v a 2  s. com*/

    result.signatures = display(pdfReader);

    return result;
}

From source file:cz.hobrasoft.pdfmu.operation.version.OperationVersionSet.java

License:Open Source License

private static VersionSet execute(InPdfArgs in, OutPdfArgs out, PdfVersion outVersion, boolean onlyIfLower)
        throws OperationException {
    try { // in
        in.open();//  w ww  .jav  a  2s  .co m
        PdfReader pdfReader = in.getPdfReader();

        // Fetch the PDF version of the input PDF document
        PdfVersion inVersion = new PdfVersion(pdfReader.getPdfVersion());
        logger.info(String.format("Input PDF document version: %s", inVersion));

        // Commence to set the PDF version of the output PDF document
        // Determine the desired PDF version
        assert outVersion != null; // The argument "version" has a default value
        logger.info(String.format("Desired output PDF version: %s", outVersion));

        boolean set = true;
        if (outVersion.compareTo(inVersion) <= 0) {
            // The desired version is lower than the current version.
            if (onlyIfLower) {
                set = false;
                logger.info(
                        "The input PDF version is not lower than the desired version. No modification will be performed.");
            } else {
                logger.warning("Setting the PDF version to a lower value.");
            }
        }

        if (set) {
            try { // out
                out.open(pdfReader, false, outVersion.toChar());
                out.close(true);
            } finally {
                out.close(false);
            }
        }

        return new VersionSet(inVersion.toString(), outVersion.toString(), set);
    } finally {
        in.close();
    }
}

From source file:cz.muni.pdfjbim.PdfImageProcessor.java

License:Apache License

/**
 * replace images by they recompressed version according to JBIG2 standard
 * positions and image data given in imagesData
 * @param pdfName represents name of original PDF file
 * @param os represents output stream for writing changed PDF file
 * @param imagesData contains compressed images according to JBIG2 standard and informations about them
 * @throws PdfRecompressionException if version of PDF is lower than 1.4 or was catch DocumentException or IOException
 */// ww  w.j a  v  a  2  s  .  co m
public void replaceImageUsingIText(String pdfName, OutputStream os, Jbig2ForPdf imagesData)
        throws PdfRecompressionException {
    if (pdfName == null) {
        throw new NullPointerException("pdfName");
    }

    if (os == null) {
        throw new NullPointerException("os");
    }

    if (imagesData == null) {
        throw new NullPointerException("imagesData is null => nothing to recompress");
    }

    Map<PdfObjId, PdfImage> jbig2Images = imagesData.getMapOfJbig2Images();

    PdfReader pdf;
    PdfStamper stp = null;
    try {
        pdf = new PdfReader(pdfName);
        stp = new PdfStamper(pdf, os);
        PdfWriter writer = stp.getWriter();

        int version;
        if ((version = Integer.parseInt(String.valueOf(pdf.getPdfVersion()))) < 4) {
            writer.setPdfVersion(PdfWriter.PDF_VERSION_1_4);
        }

        Iterator itImages = jbig2Images.values().iterator();
        String key;
        if (itImages.hasNext()) {
            PdfImage myImg = (PdfImage) itImages.next();
            key = myImg.getPdfImageInformation().getKey();
        } else {
            key = "im0";
        }

        for (int pageNum = 1; pageNum <= pdf.getNumberOfPages(); pageNum++) {

            PdfDictionary pg = pdf.getPageN(pageNum);
            PdfDictionary resPg = (PdfDictionary) PdfReader.getPdfObject(pg.get(PdfName.RESOURCES));

            PdfDictionary xobjResPg = (PdfDictionary) PdfReader.getPdfObject(resPg.get(PdfName.XOBJECT));

            PdfObject obj = null;
            if (xobjResPg != null) {
                for (Iterator it = xobjResPg.getKeys().iterator(); it.hasNext();) {
                    PdfObject pdfObjIndirect = xobjResPg.get((PdfName) it.next());
                    if (pdfObjIndirect.isIndirect()) {
                        PdfDictionary pdfObj2 = (PdfDictionary) PdfReader.getPdfObject(pdfObjIndirect);
                        PdfDictionary xobj2Res = (PdfDictionary) PdfReader
                                .getPdfObject(pdfObj2.get(PdfName.RESOURCES));
                        if (xobj2Res != null) {
                            for (Iterator it2 = xobj2Res.getKeys().iterator(); it2.hasNext();) {
                                PdfObject resObj = xobj2Res.get((PdfName) it2.next());
                            }
                            PdfDictionary xobj = (PdfDictionary) PdfReader
                                    .getPdfObject(xobj2Res.get(PdfName.XOBJECT));
                            if (xobj == null) {
                                continue;
                            }
                            obj = xobj.get(new PdfName(key));
                        } else {
                            obj = xobjResPg.get(new PdfName(key));
                            if (obj == null) {
                                obj = pdfObjIndirect;
                            }
                        }
                    }
                }
            }

            if ((obj != null) && (obj.isIndirect())) {

                PdfDictionary tg = (PdfDictionary) PdfReader.getPdfObject(obj);
                if (tg == null) {
                    continue;
                }
                PdfName type = (PdfName) PdfReader.getPdfObject(tg.get(PdfName.SUBTYPE));
                if (PdfName.IMAGE.equals(type)) {
                    PRIndirectReference ref = (PRIndirectReference) obj;
                    PdfObjId imId = new PdfObjId(ref.getNumber(), ref.getGeneration());
                    PdfImage jbImage = jbig2Images.get(imId);
                    if (jbImage == null) {
                        continue;
                    }
                    PdfImageInformation jbImageInfo = jbImage.getPdfImageInformation();
                    Image img = Image.getInstance(jbImageInfo.getWidth(), jbImageInfo.getHeight(),
                            jbImage.getImageData(), imagesData.getGlobalData());

                    PdfReader.killIndirect(obj);
                    Image maskImage = img.getImageMask();

                    if (maskImage != null) {
                        writer.addDirectImageSimple(maskImage);
                    }
                    writer.addDirectImageSimple(img, (PRIndirectReference) obj);
                }
            }
        }
        stp.close();
    } catch (IOException ioEx) {
        throw new PdfRecompressionException(ioEx);
    } catch (DocumentException dEx) {
        throw new PdfRecompressionException(dEx);
    } finally {
        Tools.deleteFilesFromList(imagesData.getJbFiles().toArray(new File[0]));
    }
}

From source file:cz.muni.pdfjbim.PdfImageReplacer.java

License:Apache License

/**
 * replace images by they recompressed version according to JBIG2 standard positions and image
 * data given in imagesData// w  w w . j  av a  2s  .co m
 *
 * @param originalPdf represents name of original PDF file
 * @param os represents output stream for writing changed PDF file
 * @param imagesData contains compressed images according to JBIG2 standard and informations
 * about them
 * @throws PdfRecompressionException if version of PDF is lower than 1.4 or was catch
 * DocumentException or IOException
 */
public void replaceImageUsingIText(InputStream originalPdf, OutputStream os, List<Jbig2ForPdf> imagesDataList)
        throws PdfRecompressionException {
    if (originalPdf == null) {
        throw new NullPointerException("pdfName");
    }

    if (os == null) {
        throw new NullPointerException("os");
    }

    if (imagesDataList == null) {
        throw new NullPointerException("imagesData is null => nothing to recompress");
    }

    log.info("Replacing old images in PDF with their equivalent encoded according to standard JBIG2");
    PdfReader pdf;
    PdfStamper stp = null;
    try {
        pdf = new PdfReader(originalPdf);
        stp = new PdfStamper(pdf, os);
        PdfWriter writer = stp.getWriter();

        int version;
        if ((version = Integer.parseInt(String.valueOf(pdf.getPdfVersion()))) < 4) {
            log.debug("PDF version of original PDF was {} => changing to PDF version 1.4", pdf.getPdfVersion());
            writer.setPdfVersion(PdfWriter.PDF_VERSION_1_4);
        }

        for (Jbig2ForPdf imagesData : imagesDataList) {

            Map<PdfObjId, PdfImage> jbig2Images = imagesData.getMapOfJbig2Images();

            Iterator itImages = jbig2Images.values().iterator();
            String key;
            if (itImages.hasNext()) {
                PdfImage myImg = (PdfImage) itImages.next();
                key = myImg.getPdfImageInformation().getKey();
            } else {
                key = "im0";
            }

            for (int pageNum = 1; pageNum <= pdf.getNumberOfPages(); pageNum++) {

                PdfDictionary pg = pdf.getPageN(pageNum);
                PdfDictionary resPg = (PdfDictionary) PdfReader.getPdfObject(pg.get(PdfName.RESOURCES));

                PdfDictionary xobjResPg = (PdfDictionary) PdfReader.getPdfObject(resPg.get(PdfName.XOBJECT));

                PdfObject obj = null;
                if (xobjResPg != null) {
                    for (Iterator it = xobjResPg.getKeys().iterator(); it.hasNext();) {
                        PdfObject pdfObjIndirect = xobjResPg.get((PdfName) it.next());
                        if (pdfObjIndirect.isIndirect()) {
                            PdfDictionary pdfObj2 = (PdfDictionary) PdfReader.getPdfObject(pdfObjIndirect);
                            PdfDictionary xobj2Res = (PdfDictionary) PdfReader
                                    .getPdfObject(pdfObj2.get(PdfName.RESOURCES));
                            if (xobj2Res != null) {
                                for (Iterator it2 = xobj2Res.getKeys().iterator(); it2.hasNext();) {
                                    PdfObject resObj = xobj2Res.get((PdfName) it2.next());
                                }
                                PdfDictionary xobj = (PdfDictionary) PdfReader
                                        .getPdfObject(xobj2Res.get(PdfName.XOBJECT));
                                if (xobj == null) {
                                    continue;
                                }
                                obj = xobj.get(new PdfName(key));
                            } else {
                                obj = xobjResPg.get(new PdfName(key));
                                if (obj == null) {
                                    obj = pdfObjIndirect;
                                }
                            }
                        }
                    }
                }

                if ((obj != null) && (obj.isIndirect())) {

                    PdfDictionary tg = (PdfDictionary) PdfReader.getPdfObject(obj);
                    if (tg == null) {
                        continue;
                    }
                    PdfName type = (PdfName) PdfReader.getPdfObject(tg.get(PdfName.SUBTYPE));
                    if (PdfName.IMAGE.equals(type)) {
                        PRIndirectReference ref = (PRIndirectReference) obj;
                        PdfObjId imId = new PdfObjId(ref.getNumber(), ref.getGeneration());
                        PdfImage jbImage = jbig2Images.get(imId);
                        if (jbImage == null) {
                            continue;
                        }

                        log.debug("Replacing image {}", jbImage);
                        PdfImageInformation jbImageInfo = jbImage.getPdfImageInformation();
                        Image img = Image.getInstance(jbImageInfo.getWidth(), jbImageInfo.getHeight(),
                                jbImage.getImageData(), imagesData.getGlobalData());

                        PdfReader.killIndirect(obj);
                        Image maskImage = img.getImageMask();

                        if (maskImage != null) {
                            writer.addDirectImageSimple(maskImage);
                        }
                        writer.addDirectImageSimple(img, (PRIndirectReference) obj);
                    }
                }
            }
        }
    } catch (IOException ioEx) {
        throw new PdfRecompressionException(ioEx);
    } catch (DocumentException dEx) {
        throw new PdfRecompressionException(dEx);
    } finally {
        log.debug("Deleting temporary files created during process of PDF recompression");
        for (Jbig2ForPdf imagesData : imagesDataList) {
            Tools.deleteFilesFromList(imagesData.getJbFiles().toArray(new File[0]));
        }
        try {
            if (stp != null) {
                stp.close();
            }
        } catch (DocumentException ex) {
            log.error("Exception thrown while closing stream", ex);
        } catch (IOException ex) {
            log.error("Exception thrown while closing stream", ex);
        }
    }

}

From source file:de.mat.utils.pdftools.PdfExtractEmptyPages.java

License:Mozilla Public License

/**
 * <h4>FeatureDomain:</h4>/*from   ww  w .  j  a  v a  2s  .  com*/
 *     PublishingTools
 * <h4>FeatureDescription:</h4>
 *     reads readerOrig and adds pages to writerRemoved if empty, or to 
 *     writerTrimmed if not empty
 * <h4>FeatureResult:</h4>
 *   <ul>
 *     <li>updates writerTrimmed - add all pages which are not empty
 *     <li>updates writerRemoved - add all empty pages
 *   </ul> 
 * <h4>FeatureKeywords:</h4>
 *     PDF Publishing
 * @param origFileName - orig filename of the sourcepdf
 * @param readerOrig - reader of source
 * @param writerTrimmed - writer for trimmed pages
 * @param writerRemoved - writer for empty pages
 * @param flgTrim - ??
 * @return - count of trimmed pages
 * @throws Exception
 */
public static int addTrimmedPages(String origFileName, PdfReader readerOrig, PdfCopy writerTrimmed,
        PdfCopy writerRemoved, boolean flgTrim) throws Exception {
    PdfImportedPage page = null;
    int countTrimmedPages = 0;

    //loop each page
    for (int i = 1; i <= readerOrig.getNumberOfPages(); i++) {
        boolean flgIsEmpty = true;

        // get dictionary
        PdfDictionary pageDict = readerOrig.getPageN(i);

        // every pdf-version has its own way :-(
        char version = readerOrig.getPdfVersion();

        if (version == '3') {
            // PDF-Version: 3

            // examine the resource dictionary for /Font or
            // /XObject keys.  If either are present, they're almost
            // certainly actually used on the page -> not blank.
            PdfObject myObj = pageDict.get(PdfName.RESOURCES);
            PdfDictionary resDict = null;
            if (myObj instanceof PdfDictionary) {
                resDict = (PdfDictionary) myObj;
            } else {
                resDict = (PdfDictionary) PdfReader.getPdfObject(myObj);
            }
            if (resDict != null) {
                flgIsEmpty = resDict.get(PdfName.FONT) == null && resDict.get(PdfName.XOBJECT) == null;
                if (LOGGER.isInfoEnabled()) {
                    if (flgIsEmpty) {
                        LOGGER.info("probably empty page " + i + " Version: 1." + version
                                + " FONT/XOBJECT found in File:" + origFileName);
                    } else {
                        LOGGER.info("normal page " + i + " Version: 1." + version
                                + " no FONT/XOBJECT found in File:" + origFileName);
                    }
                }
            }
        } else if (version == '4') {
            // PDF-Version: 4
            // check the contentsize.

            // get the page content
            byte bContent[] = readerOrig.getPageContent(i);
            ByteArrayOutputStream bs = new ByteArrayOutputStream();
            // write the content to an output stream
            bs.write(bContent);

            flgIsEmpty = true;
            if (bs.size() > blankPdfsize) {
                if (LOGGER.isInfoEnabled())
                    LOGGER.info("normal page " + i + " Version: 1." + version + " BS:" + bs.size() + " File:"
                            + origFileName);
                flgIsEmpty = false;
            } else {
                if (LOGGER.isInfoEnabled())
                    LOGGER.info("probably empty page " + i + " Version: 1." + version + " BS:" + bs.size()
                            + " File:" + origFileName);
            }
        } else if (version == '5') {
            // PDF-Version: 5
            // check the contentsize.

            // get the page content
            byte bContent[] = readerOrig.getPageContent(i);
            ByteArrayOutputStream bs = new ByteArrayOutputStream();
            // write the content to an output stream
            bs.write(bContent);

            flgIsEmpty = true;
            if (bs.size() > blankPdfsize_v5) {
                if (LOGGER.isInfoEnabled())
                    LOGGER.info("normal page " + i + " Version: 1." + version + " BS:" + bs.size() + " File:"
                            + origFileName);
                flgIsEmpty = false;
            } else {
                if (LOGGER.isInfoEnabled())
                    LOGGER.info("probably empty page " + i + " Version: 1." + version + " BS:" + bs.size()
                            + " File:" + origFileName);
            }
        }

        // add page to removed or trimmed document
        if (!flgIsEmpty || !flgTrim) {
            if (LOGGER.isInfoEnabled())
                LOGGER.info("add page " + i);
            page = writerTrimmed.getImportedPage(readerOrig, i);
            writerTrimmed.addPage(page);
            countTrimmedPages++;
        } else {
            if (LOGGER.isInfoEnabled())
                LOGGER.info("skip page " + i + " Version: 1." + version + " File:" + origFileName);
            if (writerRemoved != null) {
                page = writerRemoved.getImportedPage(readerOrig, i);
                writerRemoved.addPage(page);
            }
        }
    }

    return countTrimmedPages;
}

From source file:org.pdfsam.pdf.DefaultITextLoader.java

License:Open Source License

public void accept(PdfReader reader, PdfDocumentDescriptor descriptor) {
    descriptor.pages(reader.getNumberOfPages());
    descriptor.setVersion(new PdfVersionAdapter(Character.toString(reader.getPdfVersion())).getEnumValue());
    Map<String, String> info = reader.getInfo();
    descriptor.setInformationDictionary(info);
    Optional.ofNullable(PdfDate.decode(info.get("CreationDate"))).map(FORMATTER::format)
            .ifPresent(c -> descriptor.putInformation("FormattedCreationDate", c));
}

From source file:org.pdfsam.pdf.ITextPdfLoadService.java

License:Open Source License

public void load(Collection<PdfDocumentDescriptor> toLoad) {
    LOG.debug(DefaultI18nContext.getInstance().i18n("Loading"));
    for (PdfDocumentDescriptor current : toLoad) {
        if (!current.isInvalid()) {
            LOG.trace("Loading {}", current.getFileName());
            PdfReader reader = null;
            try {
                current.moveStatusTo(LOADING);
                reader = current.toPdfFileSource().open(new DefaultPdfSourceOpener());
                current.setPages(reader.getNumberOfPages());
                current.setVersion(String.format("1.%c", reader.getPdfVersion()));
                current.setInformationDictionary(reader.getInfo());
                if (current.hasPassword()) {
                    current.moveStatusTo(LOADED_WITH_USER_PWD_DECRYPTION);
                } else {
                    current.moveStatusTo(LOADED);
                }//from  w  w  w .  j  av  a  2  s  .c o  m
            } catch (TaskWrongPasswordException twpe) {
                current.moveStatusTo(ENCRYPTED);
                LOG.warn("User password required for '{}'", current.getFileName(), twpe);
            } catch (Exception e) {
                LOG.error("An error occured loading the document '{}'", current.getFileName(), e);
                current.moveStatusTo(WITH_ERRORS);
            } finally {
                try {
                    nullSafeClosePdfReader(reader);
                } catch (RuntimeException e) {
                    LOG.warn("An error occured closing the document", e);
                }
            }
        } else {
            LOG.trace("Skipping invalid document {}", current.getFileName());
        }
    }
    LOG.debug(DefaultI18nContext.getInstance().i18n("Documents loaded"));
}

From source file:org.sejda.impl.itext5.component.AbstractPdfCopier.java

License:Open Source License

/**
 * initialize the copier using the given reader and the given output version.
 * /* w w  w  .ja v a  2 s.  co  m*/
 * @param reader
 * @param outputStream
 *            the output stream to write to.
 * @param version
 *            version for the created pdf copy, if null the version number is taken from the input {@link PdfReader}
 */
void init(PdfReader reader, OutputStream outputStream, PdfVersion version) throws TaskException {
    try {
        pdfDocument = new Document(reader.getPageSizeWithRotation(1));
        pdfCopy = new PdfSmartCopy(pdfDocument, outputStream);
        if (version == null) {
            pdfCopy.setPdfVersion(reader.getPdfVersion());
        } else {
            pdfCopy.setPdfVersion(version.getVersionAsCharacter());
        }
        pdfDocument.addCreator(Sejda.CREATOR);
    } catch (DocumentException e) {
        throw new TaskException("An error occurred opening the PdfSmartCopy.", e);
    }
}

From source file:uk.bl.wa.tika.parser.pdf.itext.PDFParser.java

License:Apache License

private static void extractMetadata(PdfReader reader, Metadata metadata) {
    try {/*from w w w. jav a2  s . co  m*/
        HashMap<String, String> map = reader.getInfo();
        // Clone the PDF info:
        for (String key : map.keySet()) {
            metadata.set(key.toLowerCase(), map.get(key));
        }
        // Add other data of interest:
        metadata.set("pdf:version", "1." + reader.getPdfVersion());
        metadata.set("pdf:numPages", "" + reader.getNumberOfPages());
        metadata.set("pdf:cryptoMode", "" + getCryptoModeAsString(reader));
        metadata.set("pdf:openedWithFullPermissions", "" + reader.isOpenedWithFullPermissions());
        metadata.set("pdf:encrypted", "" + reader.isEncrypted());
        metadata.set("pdf:metadataEncrypted", "" + reader.isMetadataEncrypted());
        metadata.set("pdf:128key", "" + reader.is128Key());
        metadata.set("pdf:tampered", "" + reader.isTampered());
        // Also grap XMP metadata, if present:
        byte[] xmpmd = reader.getMetadata();
        if (xmpmd != null) {
            // This is standard Tika code for parsing standard stuff from the XMP:
            JempboxExtractor extractor = new JempboxExtractor(metadata);
            extractor.parse(new ByteArrayInputStream(xmpmd));
            // This is custom XMP-handling code:
            XMPMetadata xmp = XMPMetadata.load(new ByteArrayInputStream(xmpmd));
            // There is a special class for grabbing data in the PDF schema - not sure it will add much here:
            // Could parse xmp:CreatorTool and pdf:Producer etc. etc. out of here.
            //XMPSchemaPDF pdfxmp = xmp.getPDFSchema();
            // Added a PDF/A schema class:
            xmp.addXMLNSMapping(XMPSchemaPDFA.NAMESPACE, XMPSchemaPDFA.class);
            XMPSchemaPDFA pdfaxmp = (XMPSchemaPDFA) xmp.getSchemaByClass(XMPSchemaPDFA.class);
            if (pdfaxmp != null) {
                metadata.set("pdfaid:part", pdfaxmp.getPart());
                metadata.set("pdfaid:conformance", pdfaxmp.getConformance());
                String version = "A-" + pdfaxmp.getPart() + pdfaxmp.getConformance().toLowerCase();
                //metadata.set("pdfa:version", version );                    
                metadata.set("pdf:version", version);
            }
        }
        // Attempt to determine Adobe extension level:
        PdfDictionary extensions = reader.getCatalog().getAsDict(PdfName.EXTENSIONS);
        if (extensions != null) {
            PdfDictionary adobeExt = extensions.getAsDict(PdfName.ADBE);
            if (adobeExt != null) {
                PdfName baseVersion = adobeExt.getAsName(PdfName.BASEVERSION);
                int el = adobeExt.getAsNumber(PdfName.EXTENSIONLEVEL).intValue();
                metadata.set("pdf:version",
                        baseVersion.toString().substring(1) + " Adobe Extension Level " + el);
            }
        }
        // Ensure the normalised metadata are mapped in:
        if (map.get("Title") != null)
            metadata.set(Metadata.TITLE, map.get("Title"));
        if (map.get("Author") != null)
            metadata.set(Metadata.AUTHOR, map.get("Author"));
    } catch (Exception e) {
        System.err.println("PDFParser.extractMetadata() caught Exception: " + e.getMessage());
        e.printStackTrace();
    }
}