Example usage for com.lowagie.text.pdf PdfReader getStreamBytes

List of usage examples for com.lowagie.text.pdf PdfReader getStreamBytes

  1. HOME
  2. Java
  3. com.lowagie
  4. com.lowagie.text.pdf.*
  5. PdfReader
  6. getStreamBytes

Introduction

In this page you can find the example usage for com.lowagie.text.pdf PdfReader getStreamBytes.

Prototype

public static byte[] getStreamBytes(PRStream stream) throws IOException

Source Link

Document

Get the content from a stream applying the required filters.

Usage

From source file:de.offis.health.icardea.cied.pdf.extractor.PDFiText2Extractor.java

License:LGPL

/**
 * @param fullExportDirectoryPath/*from w w  w .ja va2s  .c om*/
 * @param pdfObjectCounter
 * @param pdfObject
 * @throws IOException
 * @throws Exception
 * @throws FileNotFoundException
 */
private void extractImageFromPdfObject(String fullExportDirectoryPath, int pdfObjectCounter,
        PdfObject pdfObject) throws IOException, Exception, FileNotFoundException {
    boolean rawByteArray = false;

    if (pdfObject != null) {
        if (pdfObject.isStream()) {
            PdfStream pdfStream = (PdfStream) pdfObject;
            PdfObject pdfObjectSubType = pdfStream.get(PdfName.SUBTYPE);

            // Check PDF subtype and make sure it's an Image type
            if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                // Now we have a PDF stream object with an image but what is that exactly?
                byte[] byteArrayImage = null;

                /*
                 * DCTDecode isn't supported by iText2.
                 * The image can be treated as JPEG (we have already
                 * verified it's an image):
                 * http://www.mail-archive.com/itext-questions@lists.sourceforge.net/msg48307.html
                 * 
                 * Check what kind of decoding has to be applied...and
                 * get the byte array containing the image.
                 */
                if ((pdfStream.get(PdfName.FILTER)).toString().equals(PdfName.DCTDECODE.toString())) {
                    // Get the RAW byte array
                    byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    rawByteArray = true;
                } else {
                    /*
                     * PdfReader.getStreamBytes(PRStream) should
                     * automatically apply all decoding filters.
                     * @see com.lowagie.text.pdf.PdfReader#getStreamBytes(PRStream)
                     */
                    byteArrayImage = PdfReader.getStreamBytes((PRStream) pdfStream);
                    rawByteArray = false;
                }

                /*
                // Test PdfImage - START
                logger.trace("");
                logger.trace("");
                        
                if (pdfStream instanceof PdfImage) {
                   PdfImage pdfImage = (PdfImage) pdfStream;
                   logger.trace("");
                   logger.trace("Output for pdfImage object...");
                   logger.trace("pdfImage --> pdfName --> Id..............: " + pdfImage.get(PdfName.ID));
                   logger.trace("pdfImage --> pdfName --> Image...........: " + pdfImage.get(PdfName.IMAGE));
                   logger.trace("pdfImage --> pdfName --> ImageB..........: " + pdfImage.get(PdfName.IMAGEB));
                   logger.trace("pdfImage --> pdfName --> ImageC..........: " + pdfImage.get(PdfName.IMAGEC));
                   logger.trace("pdfImage --> pdfName --> ImageI..........: " + pdfImage.get(PdfName.IMAGEI));
                   logger.trace("pdfImage --> pdfName --> Imagemask.......: " + pdfImage.get(PdfName.IMAGEMASK));
                   logger.trace("pdfImage --> pdfName --> Info............: " + pdfImage.get(PdfName.INFO));
                   logger.trace("pdfImage --> pdfName --> Name............: " + pdfImage.get(PdfName.NAME));
                   logger.trace("pdfImage --> pdfName --> Named...........: " + pdfImage.get(PdfName.NAMED));
                } else {
                   logger.trace("pdfStream is NO instanceof PdfImage");
                }
                        
                // STREAM
                logger.trace("");
                logger.trace("Output for pdfImage object...");
                logger.trace("pdfObject.toString()).....................: " + pdfObject.toString());
                logger.trace("pdfObjectCounter..........................: " + pdfObjectCounter);
                logger.trace("pdfStream --> pdfName --> Page............: " + pdfStream. get(PdfName.PAGE));
                logger.trace("pdfObject.getIndRef().getNumber().........: " + (pdfObject.getIndRef()!=null?pdfObject.getIndRef().toString():"null"));
                logger.trace("pdfStream.getIndRef().getNumber().........: " + (pdfStream.getIndRef()!=null?pdfStream.getIndRef().toString():"null"));
                logger.trace("pdfStream --> pdfName --> toString........: " + pdfStream.toString());
                logger.trace("pdfStream --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                logger.trace("pdfStream --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                logger.trace("pdfStream --> pdfName --> BitsPerComponent: " + pdfStream.get(PdfName.BITSPERCOMPONENT));
                logger.trace("pdfStream --> pdfName --> BitsPerSample...: " + pdfStream.get(PdfName.BITSPERSAMPLE));
                logger.trace("pdfStream --> pdfName --> ColorSpace......: " + pdfStream.get(PdfName.COLORSPACE));
                logger.trace("pdfStream --> pdfName --> Filter..........: " + pdfStream.get(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Filter - as name: " + pdfStream.getAsName(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Name............: " + pdfStream.get(PdfName.NAME));
                logger.trace("pdfStream --> pdfName --> SubType.........: " + pdfStream.get(PdfName.SUBTYPE));
                */

                // Extract the image name
                String streamImageName = (pdfStream.get(PdfName.NAME) == null ? null
                        : pdfStream.get(PdfName.NAME).toString());
                if (streamImageName != null && streamImageName.length() > 1
                        && streamImageName.startsWith("/")) {
                    streamImageName = streamImageName.substring(1);
                } else {
                    streamImageName = null;
                } // end if..else

                String exportFileWithoutExtension = (fullExportDirectoryPath != null ? fullExportDirectoryPath
                        : this.fullPDFDirectoryPath)
                        + GlobalTools.getFileNameWithoutExtension(this.fullPDFFilePath) + "_(" + "p000" + "_ref"
                        + REF_NUMBER_FORMAT.format(pdfObjectCounter)
                        + (streamImageName == null ? "_unk" : "_" + streamImageName) + ")";

                // Test
                FileOutputStream fileOutputStream = null;

                if (rawByteArray) {
                    fileOutputStream = new FileOutputStream(exportFileWithoutExtension + ".jpg");
                    fileOutputStream.write(byteArrayImage);
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    fileOutputStream = null;
                } else {
                    /* 
                     * Check image details
                     */
                    int pdfImageWidth = -1;
                    int pdfImageHeight = -1;
                    int pdfImageBitsPerComponent = -1;

                    try {
                        if (pdfStream.get(PdfName.BITSPERCOMPONENT).isNumber()) {
                            pdfImageBitsPerComponent = new Integer(
                                    pdfStream.get(PdfName.BITSPERCOMPONENT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting BITSPERCOMPONENT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.HEIGHT).isNumber()) {
                            pdfImageHeight = new Integer(pdfStream.get(PdfName.HEIGHT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting HEIGHT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.WIDTH).isNumber()) {
                            pdfImageWidth = new Integer(pdfStream.get(PdfName.WIDTH).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting WIDTH (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    if (PdfName.DEVICERGB.equals(pdfStream.get(PdfName.COLORSPACE))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0 && pdfImageHeight > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(byteArrayImage,
                                pdfImageWidth, pdfImageHeight, pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else if (PdfName.DEVICEGRAY.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.RUNLENGTHDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(
                                ImageProcessingTools.runLengthDecode(byteArrayImage), pdfImageWidth, 2233,
                                pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else {
                        logger.error("Unsupported Image format or missing information to convert the image.");
                    } // end if..else
                }
            } // end if
        } // end if 
    } // end if
}

From source file:de.offis.health.icardea.cied.pdf.extractor.PDFiText2Extractor.java

License:LGPL

/**
 * @param fullExportDirectoryPath/*from w w  w  . j a  va  2  s  .c  o  m*/
 * @param pdfObjectCounter
 * @param pdfObject
 * @throws IOException
 * @throws Exception
 * @throws FileNotFoundException
 */
private void extractImageFromPdfObjectExperimental(String fullExportDirectoryPath, int pdfObjectCounter,
        PdfObject pdfObject) throws IOException, Exception, FileNotFoundException {
    boolean rawByteArray = false;

    if (pdfObject != null) {
        if (pdfObject.isStream()) {
            //|| pdfObject.isDictionary()) {
            //PdfObject pdfObjectSubType = null;
            ////PdfName pdfObjectSubType = null;
            ////PdfStream pdfStream = null;

            //if (pdfObject.isStream()) {
            PdfStream pdfStream = (PdfStream) pdfObject;
            //pdfObjectSubType = pdfStream.get(PdfName.SUBTYPE);
            PdfName pdfObjectSubType = (PdfName) PdfReader.getPdfObject(pdfStream.get(PdfName.SUBTYPE)); // J.U. - 2011-08-22

            /*               
                        } else if (pdfObject.isDictionary()) {
                           PdfDictionary pdfDictionary = (PdfDictionary)PdfReader.getPdfObject(pdfObject);
                           //PdfName pdfObjectSubType = (PdfName)PdfReader.getPdfObject(pdfDictionary.get(PdfName.SUBTYPE));
                           pdfObjectSubType = (PdfName)PdfReader.getPdfObject(pdfDictionary.get(PdfName.SUBTYPE));
                           if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                              int xRefIndex = pdfObject.getIndRef().getNumber();
                              PdfObject innerPdfObject = 
                           }
                        }
            */

            // Check PDF subtype and make sure it's an Image type
            if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                // Now we have a PDF stream object with an image but what is that exactly?
                byte[] byteArrayImage = null;

                /*
                 * DCTDecode isn't supported by iText2.
                 * The image can be treated as JPEG (we have already
                 * verified it's an image):
                 * http://www.mail-archive.com/itext-questions@lists.sourceforge.net/msg48307.html
                 * 
                 * Check what kind of decoding has to be applied...and
                 * get the byte array containing the image.
                 */
                if ((pdfStream.get(PdfName.FILTER)).toString().equals(PdfName.DCTDECODE.toString())) {
                    // Get the RAW byte array
                    byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    rawByteArray = true;
                } else {
                    /*
                     * PdfReader.getStreamBytes(PRStream) should
                     * automatically apply all decoding filters.
                     * @see com.lowagie.text.pdf.PdfReader#getStreamBytes(PRStream)
                     */
                    byteArrayImage = PdfReader.getStreamBytes((PRStream) pdfStream);
                    rawByteArray = false;
                }

                /*
                // Test PdfImage - START
                logger.trace("");
                logger.trace("");
                        
                if (pdfStream instanceof PdfImage) {
                   PdfImage pdfImage = (PdfImage) pdfStream;
                   logger.trace("");
                   logger.trace("Output for pdfImage object...");
                   logger.trace("pdfImage --> pdfName --> Id..............: " + pdfImage.get(PdfName.ID));
                   logger.trace("pdfImage --> pdfName --> Image...........: " + pdfImage.get(PdfName.IMAGE));
                   logger.trace("pdfImage --> pdfName --> ImageB..........: " + pdfImage.get(PdfName.IMAGEB));
                   logger.trace("pdfImage --> pdfName --> ImageC..........: " + pdfImage.get(PdfName.IMAGEC));
                   logger.trace("pdfImage --> pdfName --> ImageI..........: " + pdfImage.get(PdfName.IMAGEI));
                   logger.trace("pdfImage --> pdfName --> Imagemask.......: " + pdfImage.get(PdfName.IMAGEMASK));
                   logger.trace("pdfImage --> pdfName --> Info............: " + pdfImage.get(PdfName.INFO));
                   logger.trace("pdfImage --> pdfName --> Name............: " + pdfImage.get(PdfName.NAME));
                   logger.trace("pdfImage --> pdfName --> Named...........: " + pdfImage.get(PdfName.NAMED));
                } else {
                   logger.trace("pdfStream is NO instanceof PdfImage");
                }
                        
                // STREAM
                logger.trace("");
                logger.trace("Output for pdfImage object...");
                logger.trace("pdfObject.toString()).....................: " + pdfObject.toString());
                logger.trace("pdfObjectCounter..........................: " + pdfObjectCounter);
                logger.trace("pdfStream --> pdfName --> Page............: " + pdfStream. get(PdfName.PAGE));
                logger.trace("pdfObject.getIndRef().getNumber().........: " + (pdfObject.getIndRef()!=null?pdfObject.getIndRef().toString():"null"));
                logger.trace("pdfStream.getIndRef().getNumber().........: " + (pdfStream.getIndRef()!=null?pdfStream.getIndRef().toString():"null"));
                logger.trace("pdfStream --> pdfName --> toString........: " + pdfStream.toString());
                logger.trace("pdfStream --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                logger.trace("pdfStream --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                logger.trace("pdfStream --> pdfName --> BitsPerComponent: " + pdfStream.get(PdfName.BITSPERCOMPONENT));
                logger.trace("pdfStream --> pdfName --> BitsPerSample...: " + pdfStream.get(PdfName.BITSPERSAMPLE));
                logger.trace("pdfStream --> pdfName --> ColorSpace......: " + pdfStream.get(PdfName.COLORSPACE));
                logger.trace("pdfStream --> pdfName --> Filter..........: " + pdfStream.get(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Filter - as name: " + pdfStream.getAsName(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Name............: " + pdfStream.get(PdfName.NAME));
                logger.trace("pdfStream --> pdfName --> SubType.........: " + pdfStream.get(PdfName.SUBTYPE));
                */

                // Extract the image name
                String streamImageName = (pdfStream.get(PdfName.NAME) == null ? null
                        : pdfStream.get(PdfName.NAME).toString());
                if (streamImageName != null && streamImageName.length() > 1
                        && streamImageName.startsWith("/")) {
                    streamImageName = streamImageName.substring(1);
                } else {
                    streamImageName = null;
                } // end if..else

                String exportFileWithoutExtension = (fullExportDirectoryPath != null ? fullExportDirectoryPath
                        : this.fullPDFDirectoryPath)
                        + GlobalTools.getFileNameWithoutExtension(this.fullPDFFilePath) + "_(" + "p000" + "_ref"
                        + REF_NUMBER_FORMAT.format(pdfObjectCounter)
                        + (streamImageName == null ? "_unk" : "_" + streamImageName) + ")";

                // Test
                FileOutputStream fileOutputStream = null;

                if (rawByteArray) {
                    fileOutputStream = new FileOutputStream(exportFileWithoutExtension + ".jpg");
                    fileOutputStream.write(byteArrayImage);
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    fileOutputStream = null;
                } else {
                    /* 
                     * Check image details
                     */
                    int pdfImageWidth = -1;
                    int pdfImageHeight = -1;
                    int pdfImageBitsPerComponent = -1;

                    try {
                        if (pdfStream.get(PdfName.BITSPERCOMPONENT).isNumber()) {
                            pdfImageBitsPerComponent = new Integer(
                                    pdfStream.get(PdfName.BITSPERCOMPONENT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting BITSPERCOMPONENT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.HEIGHT).isNumber()) {
                            pdfImageHeight = new Integer(pdfStream.get(PdfName.HEIGHT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting HEIGHT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.WIDTH).isNumber()) {
                            pdfImageWidth = new Integer(pdfStream.get(PdfName.WIDTH).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting WIDTH (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    if (PdfName.DEVICERGB.equals(pdfStream.get(PdfName.COLORSPACE))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0 && pdfImageHeight > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(byteArrayImage,
                                pdfImageWidth, pdfImageHeight, pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else if (PdfName.DEVICEGRAY.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.RUNLENGTHDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(
                                ImageProcessingTools.runLengthDecode(byteArrayImage), pdfImageWidth, 2233,
                                pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else {
                        logger.error("Unsupported Image format or missing information to convert the image.");
                    } // end if..else
                }
            } // end if
        } // end if 
    } // end if
}

From source file:de.offis.health.icardea.cied.pdf.extractor.PDFiText4Extractor.java

License:LGPL

/**
 * <p>/*www . j a v  a  2s.  com*/
 * This method searches for all image objects from the currently processed
 * PDF file and stores them as PDF in the given export directory or in the
 * same directory where the original PDF file is stored.
 * </p>
 * <p>
 * The filename of the images is build based on the original PDF filename
 * (without extension) and additional details like page number, image
 * number and if available the internal image name.
 * </p>
 * @param fullExportDirectoryPath The optional full export path where the images
 * should be stored. If not given, the location of the original PDF file is used.
 * @throws Exception
 */
private void imageExtractor(String fullExportDirectoryPath) throws Exception {
    if (fullExportDirectoryPath != null) {
        fullExportDirectoryPath = GlobalTools.checkDirectoryPath(fullExportDirectoryPath);
        File exportDirectory = new File(fullExportDirectoryPath);
        if (!exportDirectory.exists()) {
            exportDirectory.mkdirs();
        } // end if
    } // end if

    int totalNumberOfPDFObjects = pdfReader.getXrefSize();
    for (int pdfObjectCounter = 0; pdfObjectCounter < totalNumberOfPDFObjects; pdfObjectCounter++) {
        PdfObject pdfObject = pdfReader.getPdfObject(pdfObjectCounter);
        if (pdfObject != null) {
            if (pdfObject.isStream()) {
                PdfStream pdfStream = (PdfStream) pdfObject;
                PdfObject pdfObjectSubType = pdfStream.get(PdfName.SUBTYPE);

                if (pdfObject == null) {
                    logger.debug("The internal PDF object is null.");
                } // end if

                if (!pdfObject.isStream()) {
                    logger.debug("The internal PDF object is not representing a stream object.");
                } // end if

                // Check PDF subtype and make sure it's an Image type
                if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                    // Now we have a PDF stream object with an image but what is that exactly?
                    //byte[] byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    byte[] byteArrayImage = null;
                    if (PdfName.FLATEDECODE.equals(pdfStream.getAsName(PdfName.FILTER))) {
                        byteArrayImage = PdfReader.getStreamBytes((PRStream) pdfStream);
                        // else if other filter (not supported yet)
                    } else {
                        byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    } // end if..else

                    // Test PdfImage - START
                    /*
                    PdfImage pdfImage = (PdfImage) ((PdfStream)((PRStream)pdfStream));
                    logger.trace("pdfImage --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                    logger.trace("pdfImage --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                    logger.trace("pdfImage --> pdfName --> Id..............: " + pdfImage.get(PdfName.ID));
                    logger.trace("pdfImage --> pdfName --> Image...........: " + pdfImage.get(PdfName.IMAGE));
                    logger.trace("pdfImage --> pdfName --> ImageB..........: " + pdfImage.get(PdfName.IMAGEB));
                    logger.trace("pdfImage --> pdfName --> ImageC..........: " + pdfImage.get(PdfName.IMAGEC));
                    logger.trace("pdfImage --> pdfName --> ImageI..........: " + pdfImage.get(PdfName.IMAGEI));
                    logger.trace("pdfImage --> pdfName --> Imagemask.......: " + pdfImage.get(PdfName.IMAGEMASK));
                    logger.trace("pdfImage --> pdfName --> Info............: " + pdfImage.get(PdfName.INFO));
                    logger.trace("pdfImage --> pdfName --> Name............: " + pdfImage.get(PdfName.NAME));
                    logger.trace("pdfImage --> pdfName --> Named...........: " + pdfImage.get(PdfName.NAMED));
                    logger.trace("pdfImage --> pdfName --> Page............: " + pdfStream.get(PdfName.PAGE));
                    */
                    // Test PdfImage - STOP

                    // STREAM
                    /*
                    logger.trace("pdfObject.toString()): " + pdfObject.toString());
                    logger.trace("pdfObjectCounter.................: " + pdfObjectCounter);
                    logger.trace("pdfObject.getIndRef().getNumber(): " + (pdfObject.getIndRef()!=null?pdfObject.getIndRef().toString():"null"));
                    logger.trace("pdfStream.getIndRef().getNumber(): " + (pdfStream.getIndRef()!=null?pdfStream.getIndRef().toString():"null"));
                    logger.trace("pdfStream --> pdfName --> toString........: " + pdfStream.toString());
                    logger.trace("pdfStream --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                    logger.trace("pdfStream --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                    logger.trace("pdfStream --> pdfName --> BitsPerComponent: " + pdfStream.get(PdfName.BITSPERCOMPONENT));
                    logger.trace("pdfStream --> pdfName --> BitsPerSample...: " + pdfStream.get(PdfName.BITSPERSAMPLE));
                    logger.trace("pdfStream --> pdfName --> ColorSpace......: " + pdfStream.get(PdfName.COLORSPACE));
                    logger.trace("pdfStream --> pdfName --> CCITTFaxDecode..: " + pdfStream.get(PdfName.CCITTFAXDECODE));
                    logger.trace("pdfStream --> pdfName --> Document........: " + pdfStream.get(PdfName.DOCUMENT));
                    logger.trace("pdfStream --> pdfName --> Decode..........: " + pdfStream.get(PdfName.DECODE));
                    logger.trace("pdfStream --> pdfName --> DecodeParms.....: " + pdfStream.get(PdfName.DECODEPARMS));
                    logger.trace("pdfStream --> pdfName --> DeviceGray......: " + pdfStream.get(PdfName.DEVICEGRAY));
                    logger.trace("pdfStream --> pdfName --> DeviceCMYK......: " + pdfStream.get(PdfName.DEVICECMYK));
                    logger.trace("pdfStream --> pdfName --> DeviceRGB.......: " + pdfStream.get(PdfName.DEVICERGB));
                    logger.trace("pdfStream --> pdfName --> Filter..........: " + pdfStream.get(PdfName.FILTER));
                    logger.trace("pdfStream --> pdfName --> Filter - as name: " + pdfStream.getAsName(PdfName.FILTER));
                            
                    logger.trace("pdfStream --> pdfName --> Id..............: " + pdfStream.get(PdfName.ID));
                    logger.trace("pdfStream --> pdfName --> Image...........: " + pdfStream.get(PdfName.IMAGE));
                    logger.trace("pdfStream --> pdfName --> ImageB..........: " + pdfStream.get(PdfName.IMAGEB));
                    logger.trace("pdfStream --> pdfName --> ImageC..........: " + pdfStream.get(PdfName.IMAGEC));
                    logger.trace("pdfStream --> pdfName --> ImageI..........: " + pdfStream.get(PdfName.IMAGEI));
                    logger.trace("pdfStream --> pdfName --> Imagemask.......: " + pdfStream.get(PdfName.IMAGEMASK));
                    logger.trace("pdfStream --> pdfName --> Info............: " + pdfStream.get(PdfName.INFO));
                    logger.trace("pdfStream --> pdfName --> Name............: " + pdfStream.get(PdfName.NAME));
                    logger.trace("pdfStream --> pdfName --> Named...........: " + pdfStream.get(PdfName.NAMED));
                    logger.trace("pdfStream --> pdfName --> Named - as name.: " + pdfStream.getAsName(PdfName.NAMED));
                            
                    logger.trace("pdfStream --> pdfName --> Page............: " + pdfStream.get(PdfName.PAGE));
                    logger.trace("pdfStream --> pdfName --> PageElement.....: " + pdfStream.get(PdfName.PAGEELEMENT));
                    logger.trace("pdfStream --> pdfName --> Pdf.............: " + pdfStream.get(PdfName.PDF));
                    logger.trace("pdfStream --> pdfName --> PdfDocEncoding..: " + pdfStream.get(PdfName.PDFDOCENCODING));
                    logger.trace("pdfStream --> pdfName --> Position........: " + pdfStream.get(PdfName.POSITION));
                    logger.trace("pdfStream --> pdfName --> Producer........: " + pdfStream.get(PdfName.PRODUCER));
                    logger.trace("pdfStream --> pdfName --> Properties......: " + pdfStream.get(PdfName.PROPERTIES));
                    logger.trace("pdfStream --> pdfName --> Sect............: " + pdfStream.get(PdfName.SECT));
                    logger.trace("pdfStream --> pdfName --> SubType.........: " + pdfStream.get(PdfName.SUBTYPE));
                    logger.trace("pdfStream --> pdfName --> Supplement......: " + pdfStream.get(PdfName.SUPPLEMENT));
                    logger.trace("pdfStream --> pdfName --> Title...........: " + pdfStream.get(PdfName.TITLE));
                    */
                    // logger.trace("pdfImage --> pdfName --> : " + (pdfName.).toString());

                    // Extract the image name
                    String streamImageName = (pdfStream.get(PdfName.NAME) == null ? null
                            : pdfStream.get(PdfName.NAME).toString());
                    if (streamImageName != null && streamImageName.length() > 1
                            && streamImageName.startsWith("/")) {
                        streamImageName = streamImageName.substring(1);
                    } else {
                        streamImageName = null;
                    } // end if..else

                    String exportFileWithoutExtension = (fullExportDirectoryPath != null
                            ? fullExportDirectoryPath
                            : this.fullPDFDirectoryPath)
                            + GlobalTools.getFileNameWithoutExtension(this.fullPDFFilePath) + "_(" + "p000"
                            + "_ref" + REF_NUMBER_FORMAT.format(pdfObjectCounter)
                            + (streamImageName == null ? "_unk" : "_" + streamImageName) + ")";

                    // Test
                    FileOutputStream fileOutputStream = new FileOutputStream(
                            exportFileWithoutExtension + ".jpg");

                    /*
                     * Write given byte array to a file.
                     */
                    fileOutputStream.write(byteArrayImage);
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    fileOutputStream = null;

                    /* 
                     * Check image details
                     */
                    int pdfImageBitsPerComponent = -1;
                    try {
                        if (pdfStream.get(PdfName.BITSPERCOMPONENT).isNumber()) {
                            pdfImageBitsPerComponent = new Integer(
                                    pdfStream.get(PdfName.BITSPERCOMPONENT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                    }

                    int pdfImageHeight = -1;
                    try {
                        if (pdfStream.get(PdfName.HEIGHT).isNumber()) {
                            pdfImageHeight = new Integer(pdfStream.get(PdfName.HEIGHT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                    }

                    int pdfImageWidth = -1;
                    try {
                        if (pdfStream.get(PdfName.WIDTH).isNumber()) {
                            pdfImageWidth = new Integer(pdfStream.get(PdfName.WIDTH).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                    }

                    logger.debug("Height..........:" + pdfImageHeight);
                    logger.debug("Width...........:" + pdfImageWidth);
                    logger.debug("BitsPerComponent:" + pdfImageBitsPerComponent);

                    // or you could try making a java.awt.Image from the array:

                    if (PdfName.DEVICERGB.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.FLATEDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0 && pdfImageHeight > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(byteArrayImage,
                                pdfImageWidth, pdfImageHeight, pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else if (PdfName.DEVICEGRAY.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.RUNLENGTHDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(
                                ImageProcessingTools.runLengthDecode(byteArrayImage), pdfImageWidth, 2233,
                                pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } // end if...

                    /*
                    Image image = Toolkit.getDefaultToolkit().createImage(imageByteArray);
                            
                            
                    BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(image, pdfImageWidth, pdfImageHeight);
                    if (bufferedImage != null) {
                       System.out.println("Image-Height....:" + bufferedImage.getHeight());
                       System.out.println("Image-Width.....:" + bufferedImage.getWidth());
                       System.out.println("Image-isAlphaP..:" + bufferedImage.isAlphaPremultiplied());
                       File pngOutputFile = new File(exportFileWithoutExtension + "_imageIO.jpg");
                       ImageIO.write(bufferedImage, "jpg", pngOutputFile);
                    }
                    */
                    /**/

                } // end if
            } // end if 
        } // end if
    } // end for
}

From source file:es.gob.afirma.signers.pades.ltv.PdfDocumentSecurityStore.java

License:Open Source License

private static byte[] getContentBytesFromContentObject(final PdfObject contentObject) throws IOException {
    switch (contentObject.type()) {
    case PdfObject.INDIRECT:
        return getContentBytesFromContentObject(PdfReader.getPdfObject(contentObject));
    case PdfObject.STREAM:
        return PdfReader.getStreamBytes((PRStream) PdfReader.getPdfObject(contentObject));
    case PdfObject.ARRAY:
        final ByteArrayOutputStream allBytes = new ByteArrayOutputStream();
        final ListIterator<PdfObject> iter = ((PdfArray) contentObject).listIterator();
        while (iter.hasNext()) {
            allBytes.write(getContentBytesFromContentObject(iter.next()));
            allBytes.write((byte) ' ');
        }//ww w  .j a v a 2 s  .  c om
        return allBytes.toByteArray();
    default:
        throw new IllegalStateException("No se soporta contenido del tipo: " + contentObject.getClass()); //$NON-NLS-1$
    }
}

From source file:eu.europa.cedefop.europass.jtool.util.ExtractAttachments.java

License:EUPL

/**
* Get the attachment file     /*from  w w  w  . j a v  a2 s. c  om*/
* @param filespec 
* @throws IOException
*/
public void unpackFile(PdfDictionary filespec) throws IOException {
    if (filespec == null)
        return;

    PdfName type = (PdfName) PdfReader.getPdfObject(filespec.get(PdfName.TYPE));
    if (!PdfName.F.equals(type) && !PdfName.FILESPEC.equals(type))
        return;

    PdfDictionary ef = (PdfDictionary) PdfReader.getPdfObject(filespec.get(PdfName.EF));
    if (ef == null)
        return;

    PdfString fn = (PdfString) PdfReader.getPdfObject(filespec.get(PdfName.F));
    if (fn == null)
        return;

    PRStream prs = (PRStream) PdfReader.getPdfObject(ef.get(PdfName.F));
    if (prs == null)
        return;
    byte b[] = PdfReader.getStreamBytes(prs);
    FileOutputStream fout = new FileOutputStream(trgfile);
    fout.write(b);
    fout.close();
}

From source file:eu.europa.ec.markt.dss.signature.pdf.itext.ITextPdfArray.java

License:Open Source License

@Override
public byte[] getBytes(int i) throws IOException {
    return PdfReader.getStreamBytes((PRStream) wrapped.getAsStream(i));
}

From source file:eu.europa.ec.markt.dss.validation.pades.PAdESCertificateSource.java

License:Open Source License

@Override
public List<X509Certificate> getCertificates() {

    try {/*from   ww w.j a  va  2  s .c o  m*/

        List<X509Certificate> certs = new ArrayList<X509Certificate>();

        PdfDictionary dss = catalog.getAsDict(new PdfName("DSS"));

        if (dss != null) {
            PdfArray certsArray = dss.getAsArray(new PdfName("Certs"));

            if (certsArray != null) {
                CertificateFactory factory = CertificateFactory.getInstance("X509");

                for (int i = 0; i < certsArray.size(); i++) {
                    PdfStream stream = certsArray.getAsStream(i);

                    X509Certificate cert = (X509Certificate) factory.generateCertificate(
                            new ByteArrayInputStream(PdfReader.getStreamBytes((PRStream) stream)));
                    if (!certs.contains(cert)) {
                        certs.add(cert);
                    }
                }
            }
        }

        return certs;
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    } catch (CertificateException e) {
        throw new RuntimeException(e);
    }

}

From source file:eu.europa.ec.markt.dss.validation.pades.PAdESCRLSource.java

License:Open Source License

@Override
public List<X509CRL> getCRLsFromSignature() {

    try {//from w  w  w. j av  a 2s.c o m

        List<X509CRL> crls = new ArrayList<X509CRL>();

        PdfDictionary dss = catalog.getAsDict(new PdfName("DSS"));

        if (dss != null) {
            PdfArray crlArray = dss.getAsArray(new PdfName("CRLs"));

            if (crlArray != null) {
                CertificateFactory factory = CertificateFactory.getInstance("X509");

                for (int i = 0; i < crlArray.size(); i++) {
                    PdfStream stream = crlArray.getAsStream(i);

                    X509CRL cert = (X509CRL) factory
                            .generateCRL(new ByteArrayInputStream(PdfReader.getStreamBytes((PRStream) stream)));
                    if (!crls.contains(cert)) {
                        crls.add(cert);
                    }
                }
            }
        }

        return crls;
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    } catch (CertificateException e) {
        throw new RuntimeException(e);
    } catch (CRLException e) {
        throw new RuntimeException(e);
    }

}

From source file:eu.europa.ec.markt.dss.validation.pades.PAdESOCSPSource.java

License:Open Source License

@Override
public List<BasicOCSPResp> getOCSPResponsesFromSignature() {

    try {//from  w  w  w .j  av a  2 s  .  c o m

        List<BasicOCSPResp> ocsps = new ArrayList<BasicOCSPResp>();

        PdfDictionary dss = catalog.getAsDict(new PdfName("DSS"));

        if (dss != null) {
            PdfArray ocspArray = dss.getAsArray(new PdfName("OCSPs"));

            if (ocspArray != null) {

                for (int i = 0; i < ocspArray.size(); i++) {
                    PdfStream stream = ocspArray.getAsStream(i);

                    ocsps.add((BasicOCSPResp) new OCSPResp(PdfReader.getStreamBytes((PRStream) stream))
                            .getResponseObject());
                }
            }
        }

        return ocsps;
    } catch (OCSPException ex) {
        throw new RuntimeException(ex);
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }

}

From source file:eu.europa.ec.markt.dss.validation.pades.PDFDocumentValidator.java

License:Open Source License

private boolean checkVriDict(PdfDictionary vriSigDictionary, boolean _vriVerificationresult,
        PAdESSignature pades, ValidationContext ctx, String hexHash)
        throws CertificateException, IOException, CRLException, OCSPException {

    boolean vriVerificationresult = _vriVerificationresult;

    if (vriSigDictionary == null) {
        LOG.info("Couldn't find the signature VRI identified by " + hexHash + " in the DSS");
        vriVerificationresult = false;// w  ww .  j  ava2  s  .  co  m
    } else {
        LOG.info("Found the signature VRI identified by " + hexHash + " in the DSS");

        // Verify the certs in the VRI
        PdfArray vricert = vriSigDictionary.getAsArray(new PdfName("Cert"));
        if (vricert != null) {
            CertificateFactory factory = CertificateFactory.getInstance("X509");
            List<X509Certificate> certs = new ArrayList<X509Certificate>();
            for (int i = 0; i < vricert.size(); i++) {
                PdfStream stream = vricert.getAsStream(i);
                certs.add((X509Certificate) factory.generateCertificate(
                        new ByteArrayInputStream(PdfReader.getStreamBytes((PRStream) stream))));
            }
            vriVerificationresult &= everyCertificateValueAreThere(ctx, certs, pades.getSigningCertificate());
        }

        // Verify the CRLs in the VRI
        PdfArray vricrl = vriSigDictionary.getAsArray(new PdfName("CRL"));
        if (vricrl != null) {
            CertificateFactory factory = CertificateFactory.getInstance("X509");
            List<X509CRL> crls = new ArrayList<X509CRL>();
            for (int i = 0; i < vricrl.size(); i++) {
                PdfStream stream = vricrl.getAsStream(i);
                crls.add((X509CRL) factory
                        .generateCRL(new ByteArrayInputStream(PdfReader.getStreamBytes((PRStream) stream))));
            }
            vriVerificationresult &= everyCRLValueOrRefAreThere(ctx, crls);
        }

        // Verify the OCSPs in the VRI
        PdfArray vriocsp = vriSigDictionary.getAsArray(new PdfName("OCSP"));
        if (vriocsp != null) {
            List<BasicOCSPResp> ocsps = new ArrayList<BasicOCSPResp>();
            for (int i = 0; i < vriocsp.size(); i++) {
                PdfStream stream = vriocsp.getAsStream(i);
                ocsps.add((BasicOCSPResp) new OCSPResp(PdfReader.getStreamBytes((PRStream) stream))
                        .getResponseObject());
            }
            vriVerificationresult &= everyOCSPValueOrRefAreThere(ctx, ocsps);
        }

    }

    return vriVerificationresult;
}