summaryrefslogtreecommitdiffstats
path: root/sdext/source/pdfimport/xpdfwrapper
diff options
context:
space:
mode:
Diffstat (limited to 'sdext/source/pdfimport/xpdfwrapper')
-rw-r--r--sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx1112
-rw-r--r--sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.hxx309
-rw-r--r--sdext/source/pdfimport/xpdfwrapper/pnghelper.cxx402
-rw-r--r--sdext/source/pdfimport/xpdfwrapper/pnghelper.hxx84
-rw-r--r--sdext/source/pdfimport/xpdfwrapper/wrapper_gpl.cxx159
5 files changed, 2066 insertions, 0 deletions
diff --git a/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx
new file mode 100644
index 000000000..16ad04bf6
--- /dev/null
+++ b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx
@@ -0,0 +1,1112 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "pdfioutdev_gpl.hxx"
+#include "pnghelper.hxx"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <math.h>
+
+#include <memory>
+#include <vector>
+
+// sigh, UTF8.h was removed in poppler-0.21.0 and put back in 0.21.1, then renamed to UnicodeMapFuncs.h in 0.62.0
+// FIXME: we can't use #if POPPLER_CHECK_VERSION(0, 21, 0) && !POPPLER_CHECK_VERSION(0, 21, 1)
+// because the internal poppler does not provide poppler-version.h and the macro always returns 0
+#if POPPLER_CHECK_VERSION(0, 62, 0)
+#include <UnicodeMapFuncs.h>
+#elif POPPLER_CHECK_VERSION(0, 21, 1)
+#include <UTF8.h>
+#elif POPPLER_CHECK_VERSION(0, 21, 0)
+#include "UTF.h"
+#else
+#include "UTF8.h"
+#endif
+
+#ifdef _WIN32
+# define snprintf _snprintf
+
+#if defined __GNUC__
+#pragma GCC diagnostic warning "-Wformat"
+#pragma GCC diagnostic warning "-Wformat-extra-args"
+#endif
+#endif
+
+/* SYNC STREAMS
+ ============
+
+ We stream human-readable tokens to stdout, and binary data (fonts,
+ bitmaps) to g_binary_out. Another process reads from those pipes, and
+ there lies the rub: things can deadlock, if the two involved
+ processes access the pipes in different order. At any point in
+ time, both processes must access the same pipe. To ensure this,
+ data must be flushed to the OS before writing to a different pipe,
+ otherwise not-yet-written data will leave the reading process
+ waiting on the wrong pipe.
+ */
+
+namespace pdfi
+{
+
+/// cut off very small numbers & clamp value to zero
+static double normalize( double val )
+{
+ return fabs(val) < 0.0000001 ? 0.0 : val;
+}
+
+namespace
+{
+
+/** Escapes line-ending characters (\n and \r) in input string.
+ */
+std::vector<char> lcl_escapeLineFeeds(const char* const i_pStr)
+{
+ size_t nLength(strlen(i_pStr));
+ std::vector<char> aBuffer;
+ aBuffer.reserve(2*nLength+1);
+
+ const char* pRead = i_pStr;
+ while( nLength-- )
+ {
+ if( *pRead == '\r' )
+ {
+ aBuffer.push_back('\\');
+ aBuffer.push_back('r');
+ }
+ else if( *pRead == '\n' )
+ {
+ aBuffer.push_back('\\');
+ aBuffer.push_back('n');
+ }
+ else if( *pRead == '\\' )
+ {
+ aBuffer.push_back('\\');
+ aBuffer.push_back('\\');
+ }
+ else
+ aBuffer.push_back(*pRead);
+ pRead++;
+ }
+ aBuffer.push_back(0);
+
+ return aBuffer;
+}
+
+}
+
+/// for the temp char buffer the header gets snprintfed in
+#define WRITE_BUFFER_SIZE 1024
+
+/// for the initial std::vector capacity when copying stream from xpdf
+#define WRITE_BUFFER_INITIAL_CAPACITY (1024*100)
+
+static void initBuf(OutputBuffer& io_rBuffer)
+{
+ io_rBuffer.reserve(WRITE_BUFFER_INITIAL_CAPACITY);
+}
+
+static void writeBinaryBuffer( const OutputBuffer& rBuffer )
+{
+ // ---sync point--- see SYNC STREAMS above
+ fflush(stdout);
+
+ // put buffer to stderr
+ if( !rBuffer.empty() )
+ if( fwrite(rBuffer.data(), sizeof(char),
+ rBuffer.size(), g_binary_out) != static_cast<size_t>(rBuffer.size()) )
+ exit(1); // error
+
+ // ---sync point--- see SYNC STREAMS above
+ fflush(g_binary_out);
+}
+
+static bool ExtractJpegData(Stream* str, OutputBuffer& outBuf)
+{
+ int bytesToMarker = 0;
+ int bytesToLen = -1;
+ bool collectBytes = false;
+ int startOfScan = 0;
+ int b1 = -1;
+ for (; ; )
+ {
+ const int b2 = b1;
+ b1 = str->getChar();
+
+ if (b1 == -1)
+ return false;
+
+ if (collectBytes)
+ {
+ outBuf.push_back(static_cast<Output_t>(b1));
+
+ bytesToMarker--;
+ bytesToLen--;
+ }
+
+ if (bytesToMarker == 0)
+ {
+ if (startOfScan == 1)
+ {
+ bytesToMarker = -1;
+ startOfScan = 2;
+ }
+ else if (b2 == 0xFF)
+ {
+ if (b1 == 0xD8)
+ {
+ collectBytes = true;
+ bytesToMarker = 2;
+
+ outBuf.push_back(Output_t(0xFF));
+ outBuf.push_back(Output_t(0xD8));
+ }
+ else
+ {
+ bytesToLen = 2;
+ }
+ if (b1 == 0xDA)
+ {
+ startOfScan = 1;
+ }
+ }
+ else if (collectBytes)
+ {
+ return false;
+ }
+ }
+
+ if (bytesToLen == 0)
+ {
+ bytesToMarker = b2 * 256 + b1;
+ }
+
+ if (startOfScan == 2)
+ if ((b2 == 0xFF) && (b1 == 0xD9))
+ return true;
+ }
+}
+
+static void writeJpeg_( OutputBuffer& o_rOutputBuf, Stream* str )
+{
+ // dump JPEG file as-is
+#if POPPLER_CHECK_VERSION(0, 17, 3)
+ str = str->getNextStream();
+#else
+ str = ((DCTStream *)str)->getRawStream();
+#endif
+ str->reset();
+
+ o_rOutputBuf.clear();
+ ExtractJpegData(str, o_rOutputBuf);
+
+ printf( " JPEG %d", static_cast<int>(o_rOutputBuf.size()) );
+ printf("\n");
+
+ str->close();
+}
+
+static void writePbm_(OutputBuffer& o_rOutputBuf, Stream* str, int width, int height, bool bInvert )
+{
+ // write as PBM (char by char, to avoid stdlib lineend messing)
+ o_rOutputBuf.clear();
+ o_rOutputBuf.resize(WRITE_BUFFER_SIZE);
+ o_rOutputBuf[0] = 'P';
+ o_rOutputBuf[1] = '4';
+ o_rOutputBuf[2] = 0x0A;
+ char *pAsCharPtr = reinterpret_cast<char *>(&o_rOutputBuf[3]);
+ int nOutLen = snprintf(pAsCharPtr, WRITE_BUFFER_SIZE-10, "%d %d", width, height);
+ if( nOutLen < 0 )
+ nOutLen = WRITE_BUFFER_SIZE-10;
+ o_rOutputBuf[3+nOutLen] =0x0A;
+ o_rOutputBuf[3+nOutLen+1]=0;
+
+ const int header_size = 3+nOutLen+1;
+ const int size = height * ((width + 7) / 8);
+
+ printf( " PBM %d", size + header_size );
+ printf("\n");
+
+ // trim buffer to exact header length
+ o_rOutputBuf.resize(header_size);
+
+ // initialize stream
+ str->reset();
+
+ // copy the raw stream
+ if( bInvert )
+ {
+ for( int i=0; i<size; ++i)
+ o_rOutputBuf.push_back(static_cast<char>(str->getChar() ^ 0xff));
+ }
+ else
+ {
+ for( int i=0; i<size; ++i)
+ o_rOutputBuf.push_back(static_cast<char>(str->getChar()));
+ }
+
+ str->close();
+}
+
+static void writePpm_( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width,
+ int height,
+ GfxImageColorMap* colorMap )
+{
+ // write as PPM (char by char, to avoid stdlib lineend messing)
+ o_rOutputBuf.clear();
+ o_rOutputBuf.resize(WRITE_BUFFER_SIZE);
+ o_rOutputBuf[0] = 'P';
+ o_rOutputBuf[1] = '6';
+ o_rOutputBuf[2] = '\n';
+ char *pAsCharPtr = reinterpret_cast<char *>(&o_rOutputBuf[3]);
+ int nOutLen = snprintf(pAsCharPtr, WRITE_BUFFER_SIZE-10, "%d %d", width, height);
+ if( nOutLen < 0 )
+ nOutLen = WRITE_BUFFER_SIZE-10;
+ o_rOutputBuf[3+nOutLen] ='\n';
+ o_rOutputBuf[3+nOutLen+1]='2';
+ o_rOutputBuf[3+nOutLen+2]='5';
+ o_rOutputBuf[3+nOutLen+3]='5';
+ o_rOutputBuf[3+nOutLen+4]='\n';
+ o_rOutputBuf[3+nOutLen+5]=0;
+
+ const int header_size = 3+nOutLen+5;
+ const int size = width*height*3 + header_size;
+
+ printf( " PPM %d", size );
+ printf("\n");
+
+ // trim buffer to exact header size
+ o_rOutputBuf.resize(header_size);
+
+ // initialize stream
+ unsigned char *p;
+ GfxRGB rgb;
+ std::unique_ptr<ImageStream> imgStr(
+ new ImageStream(str,
+ width,
+ colorMap->getNumPixelComps(),
+ colorMap->getBits()));
+ imgStr->reset();
+
+ for( int y=0; y<height; ++y)
+ {
+ p = imgStr->getLine();
+ for( int x=0; x<width; ++x)
+ {
+ colorMap->getRGB(p, &rgb);
+ o_rOutputBuf.push_back(colToByte(rgb.r));
+ o_rOutputBuf.push_back(colToByte(rgb.g));
+ o_rOutputBuf.push_back(colToByte(rgb.b));
+
+ p +=colorMap->getNumPixelComps();
+ }
+ }
+}
+
+// call this only for 1 bit image streams !
+static void writePng_( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width,
+ int height,
+ GfxRGB const & zeroColor,
+ GfxRGB const & oneColor,
+ bool bIsMask )
+{
+ o_rOutputBuf.clear();
+
+ // get png image
+ PngHelper::createPng( o_rOutputBuf, str, width, height, zeroColor, oneColor, bIsMask );
+
+ printf( " PNG %d", static_cast<int>(o_rOutputBuf.size()) );
+ printf("\n");
+}
+
+static void writePng_( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width, int height, GfxImageColorMap* colorMap,
+ Stream* maskStr,
+ int maskWidth, int maskHeight, GfxImageColorMap* maskColorMap )
+{
+ o_rOutputBuf.clear();
+
+ // get png image
+ PngHelper::createPng( o_rOutputBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap );
+
+ printf( " PNG %d", static_cast<int>(o_rOutputBuf.size()) );
+ printf("\n");
+}
+
+static void writePng_( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width, int height, GfxImageColorMap* colorMap,
+ Stream* maskStr,
+ int maskWidth, int maskHeight, bool maskInvert )
+{
+ o_rOutputBuf.clear();
+
+ // get png image
+ PngHelper::createPng( o_rOutputBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert );
+
+ printf( " PNG %d", static_cast<int>(o_rOutputBuf.size()) );
+ printf("\n");
+}
+
+// stolen from ImageOutputDev.cc
+static void writeMask_( OutputBuffer& o_rOutputBuf, Stream* str, int width, int height, bool bInvert )
+{
+ if( str->getKind() == strDCT )
+ writeJpeg_(o_rOutputBuf, str);
+ else
+ writePbm_(o_rOutputBuf, str, width, height, bInvert );
+}
+
+static void writeImage_( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width,
+ int height,
+ GfxImageColorMap* colorMap )
+{
+ // dump JPEG file
+ if( str->getKind() == strDCT &&
+ (colorMap->getNumPixelComps() == 1 ||
+ colorMap->getNumPixelComps() == 3) )
+ {
+ writeJpeg_(o_rOutputBuf, str);
+ }
+ else if (colorMap->getNumPixelComps() == 1 &&
+ colorMap->getBits() == 1)
+ {
+ // this is a two color bitmap, write a png
+ // provide default colors
+ GfxRGB zeroColor = { 0, 0, 0 },
+ oneColor = { byteToCol( 0xff ), byteToCol( 0xff ), byteToCol( 0xff ) };
+ if( colorMap->getColorSpace()->getMode() == csIndexed || colorMap->getColorSpace()->getMode() == csDeviceGray )
+ {
+ unsigned char nIndex = 0;
+ colorMap->getRGB( &nIndex, &zeroColor );
+ nIndex = 1;
+ colorMap->getRGB( &nIndex, &oneColor );
+ }
+ writePng_( o_rOutputBuf, str, width, height, zeroColor, oneColor, false);
+ }
+ else
+ writePpm_( o_rOutputBuf, str, width, height, colorMap );
+}
+
+// forwarders
+
+
+static void writeImageLF( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width,
+ int height,
+ GfxImageColorMap* colorMap ) { writeImage_(o_rOutputBuf,str,width,height,colorMap); }
+static void writeMaskLF( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width,
+ int height,
+ bool bInvert ) { writeMask_(o_rOutputBuf,str,width,height,bInvert); }
+
+
+int PDFOutDev::parseFont( long long nNewId, GfxFont* gfxFont, GfxState* state ) const
+{
+ FontAttributes aNewFont;
+ int nSize = 0;
+
+#if POPPLER_CHECK_VERSION(0, 64, 0)
+ const
+#endif
+ GooString* pFamily = gfxFont->getName();
+ if( pFamily )
+ {
+ aNewFont.familyName.clear();
+ aNewFont.familyName.append( gfxFont->getName() );
+ }
+ else
+ {
+ aNewFont.familyName.clear();
+ aNewFont.familyName.append( "Arial" );
+ }
+
+ aNewFont.isBold = gfxFont->isBold();
+ aNewFont.isItalic = gfxFont->isItalic();
+ aNewFont.size = state->getTransformedFontSize();
+ aNewFont.isUnderline = false;
+
+ if( gfxFont->getType() == fontTrueType || gfxFont->getType() == fontType1 )
+ {
+ // TODO(P3): Unfortunately, need to read stream twice, since
+ // we must write byte count to stdout before
+ char* pBuf = gfxFont->readEmbFontFile( m_pDoc->getXRef(), &nSize );
+ if( pBuf )
+ {
+ aNewFont.isEmbedded = true;
+ gfree(pBuf);
+ }
+ }
+
+ m_aFontMap[ nNewId ] = aNewFont;
+ return nSize;
+}
+
+void PDFOutDev::writeFontFile( GfxFont* gfxFont ) const
+{
+ if( gfxFont->getType() != fontTrueType && gfxFont->getType() != fontType1 )
+ return;
+
+ int nSize = 0;
+ char* pBuf = gfxFont->readEmbFontFile( m_pDoc->getXRef(), &nSize );
+ if( !pBuf )
+ return;
+
+ // ---sync point--- see SYNC STREAMS above
+ fflush(stdout);
+
+ if( fwrite(pBuf, sizeof(char), nSize, g_binary_out) != static_cast<size_t>(nSize) )
+ {
+ gfree(pBuf);
+ exit(1); // error
+ }
+ // ---sync point--- see SYNC STREAMS above
+ fflush(g_binary_out);
+ gfree(pBuf);
+}
+
+#if POPPLER_CHECK_VERSION(0, 83, 0)
+void PDFOutDev::printPath( const GfxPath* pPath )
+#else
+void PDFOutDev::printPath( GfxPath* pPath )
+#endif
+{
+ int nSubPaths = pPath ? pPath->getNumSubpaths() : 0;
+ for( int i=0; i<nSubPaths; i++ )
+ {
+#if POPPLER_CHECK_VERSION(0, 83, 0)
+ const
+#endif
+ GfxSubpath* pSub = pPath->getSubpath( i );
+ const int nPoints = pSub->getNumPoints();
+
+ printf( " subpath %d", pSub->isClosed() );
+
+ for( int n=0; n<nPoints; ++n )
+ {
+ printf( " %f %f %d",
+ normalize(pSub->getX(n)),
+ normalize(pSub->getY(n)),
+ pSub->getCurve(n) );
+ }
+ }
+}
+
+PDFOutDev::PDFOutDev( PDFDoc* pDoc ) :
+ m_pDoc( pDoc ),
+ m_aFontMap(),
+ m_pUtf8Map( new UnicodeMap("UTF-8", true, &mapUTF8) ),
+ m_bSkipImages(false)
+{
+}
+PDFOutDev::~PDFOutDev()
+{
+}
+
+void PDFOutDev::startPage(int /*pageNum*/, GfxState* state
+#if POPPLER_CHECK_VERSION(0, 23, 0) || POPPLER_CHECK_VERSION(0, 24, 0)
+ , XRef* /*xref*/
+#endif
+)
+{
+ assert(state);
+ printf("startPage %f %f\n",
+ normalize(state->getPageWidth()),
+ normalize(state->getPageHeight()));
+}
+
+void PDFOutDev::endPage()
+{
+ printf("endPage\n");
+}
+
+#if POPPLER_CHECK_VERSION(0, 19, 0)
+void PDFOutDev::processLink(AnnotLink *link)
+#elif POPPLER_CHECK_VERSION(0, 17, 0)
+void PDFOutDev::processLink(AnnotLink *link, Catalog *)
+#else
+void PDFOutDev::processLink(Link* link, Catalog*)
+#endif
+{
+ assert(link);
+
+ double x1,x2,y1,y2;
+ link->getRect( &x1, &y1, &x2, &y2 );
+
+ LinkAction* pAction = link->getAction();
+ if (!(pAction && pAction->getKind() == actionURI))
+ return;
+
+#if POPPLER_CHECK_VERSION(0, 86, 0)
+ const char* pURI = static_cast<LinkURI*>(pAction)->getURI().c_str();
+#elif POPPLER_CHECK_VERSION(0, 72, 0)
+ const char* pURI = static_cast<LinkURI*>(pAction)->getURI()->c_str();
+#else
+ const char* pURI = static_cast<LinkURI*>(pAction)->getURI()->getCString();
+#endif
+
+ std::vector<char> aEsc( lcl_escapeLineFeeds(pURI) );
+
+ printf( "drawLink %f %f %f %f %s\n",
+ normalize(x1),
+ normalize(y1),
+ normalize(x2),
+ normalize(y2),
+ aEsc.data() );
+}
+
+void PDFOutDev::saveState(GfxState*)
+{
+ printf( "saveState\n" );
+}
+
+void PDFOutDev::restoreState(GfxState*)
+{
+ printf( "restoreState\n" );
+}
+
+#if POPPLER_CHECK_VERSION(0, 71, 0)
+void PDFOutDev::setDefaultCTM(const double *pMat)
+#else
+void PDFOutDev::setDefaultCTM(double *pMat)
+#endif
+{
+ assert(pMat);
+
+ OutputDev::setDefaultCTM(pMat);
+
+ printf( "updateCtm %f %f %f %f %f %f\n",
+ normalize(pMat[0]),
+ normalize(pMat[1]),
+ normalize(pMat[2]),
+ normalize(pMat[3]),
+ normalize(pMat[4]),
+ normalize(pMat[5]) );
+}
+
+void PDFOutDev::updateCTM(GfxState* state,
+ double, double,
+ double, double,
+ double, double)
+{
+ assert(state);
+
+ const double* const pMat = state->getCTM();
+ assert(pMat);
+
+ printf( "updateCtm %f %f %f %f %f %f\n",
+ normalize(pMat[0]),
+ normalize(pMat[1]),
+ normalize(pMat[2]),
+ normalize(pMat[3]),
+ normalize(pMat[4]),
+ normalize(pMat[5]) );
+}
+
+void PDFOutDev::updateLineDash(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+
+ double* dashArray; int arrayLen; double startOffset;
+ state->getLineDash(&dashArray, &arrayLen, &startOffset);
+
+ printf( "updateLineDash" );
+ if( arrayLen && dashArray )
+ {
+ printf( " %f %d", normalize(startOffset), arrayLen );
+ for( int i=0; i<arrayLen; ++i )
+ printf( " %f", normalize(*dashArray++) );
+ }
+ printf( "\n" );
+}
+
+void PDFOutDev::updateFlatness(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+ printf( "updateFlatness %d\n", state->getFlatness() );
+}
+
+void PDFOutDev::updateLineJoin(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+ printf( "updateLineJoin %d\n", state->getLineJoin() );
+}
+
+void PDFOutDev::updateLineCap(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+ printf( "updateLineCap %d\n", state->getLineCap() );
+}
+
+void PDFOutDev::updateMiterLimit(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+ printf( "updateMiterLimit %f\n", normalize(state->getMiterLimit()) );
+}
+
+void PDFOutDev::updateLineWidth(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+ printf( "updateLineWidth %f\n", normalize(state->getLineWidth()) );
+}
+
+void PDFOutDev::updateFillColor(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+
+ GfxRGB aRGB;
+ state->getFillRGB( &aRGB );
+
+ printf( "updateFillColor %f %f %f %f\n",
+ normalize(colToDbl(aRGB.r)),
+ normalize(colToDbl(aRGB.g)),
+ normalize(colToDbl(aRGB.b)),
+ normalize(state->getFillOpacity()) );
+}
+
+void PDFOutDev::updateStrokeColor(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+
+ GfxRGB aRGB;
+ state->getStrokeRGB( &aRGB );
+
+ printf( "updateStrokeColor %f %f %f %f\n",
+ normalize(colToDbl(aRGB.r)),
+ normalize(colToDbl(aRGB.g)),
+ normalize(colToDbl(aRGB.b)),
+ normalize(state->getFillOpacity()) );
+}
+
+void PDFOutDev::updateFillOpacity(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ updateFillColor(state);
+}
+
+void PDFOutDev::updateStrokeOpacity(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ updateStrokeColor(state);
+}
+
+void PDFOutDev::updateBlendMode(GfxState*)
+{
+}
+
+void PDFOutDev::updateFont(GfxState *state)
+{
+ assert(state);
+
+ GfxFont *gfxFont = state->getFont();
+ if( !gfxFont )
+ return;
+
+ FontAttributes aFont;
+ int nEmbedSize=0;
+
+#if POPPLER_CHECK_VERSION(0, 64, 0)
+ const
+#endif
+ Ref* pID = gfxFont->getID();
+ // TODO(Q3): Portability problem
+ long long fontID = static_cast<long long>(pID->gen) << 32 | static_cast<long long>(pID->num);
+ std::unordered_map< long long, FontAttributes >::const_iterator it =
+ m_aFontMap.find( fontID );
+ if( it == m_aFontMap.end() )
+ {
+ nEmbedSize = parseFont( fontID, gfxFont, state );
+ it = m_aFontMap.find( fontID );
+ }
+
+ printf( "updateFont" );
+ if( it != m_aFontMap.end() )
+ {
+ // conflating this with printf below crashes under Windoze
+ printf( " %lld", fontID );
+
+ aFont = it->second;
+
+#if POPPLER_CHECK_VERSION(0, 72, 0)
+ std::vector<char> aEsc( lcl_escapeLineFeeds(aFont.familyName.c_str()) );
+#else
+ std::vector<char> aEsc( lcl_escapeLineFeeds(aFont.familyName.getCString()) );
+#endif
+ printf( " %d %d %d %d %f %d %s",
+ aFont.isEmbedded,
+ aFont.isBold,
+ aFont.isItalic,
+ aFont.isUnderline,
+ normalize(state->getTransformedFontSize()),
+ nEmbedSize,
+ aEsc.data() );
+ }
+ printf( "\n" );
+
+ if( nEmbedSize )
+ writeFontFile(gfxFont);
+}
+
+void PDFOutDev::updateRender(GfxState *state)
+{
+ assert(state);
+
+ printf( "setTextRenderMode %d\n", state->getRender() );
+}
+
+void PDFOutDev::stroke(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+
+ printf( "strokePath" );
+ printPath( state->getPath() );
+ printf( "\n" );
+}
+
+void PDFOutDev::fill(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+
+ printf( "fillPath" );
+ printPath( state->getPath() );
+ printf( "\n" );
+}
+
+void PDFOutDev::eoFill(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+
+ printf( "eoFillPath" );
+ printPath( state->getPath() );
+ printf( "\n" );
+}
+
+void PDFOutDev::clip(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+
+ printf( "clipPath" );
+ printPath( state->getPath() );
+ printf( "\n" );
+}
+
+void PDFOutDev::eoClip(GfxState *state)
+{
+ if (m_bSkipImages)
+ return;
+ assert(state);
+
+ printf( "eoClipPath" );
+ printPath( state->getPath() );
+ printf( "\n" );
+}
+
+/** Output one glyph
+
+
+ @param dx
+ horizontal skip for character (already scaled with font size) +
+ inter-char space: cursor is shifted by this amount for next char
+
+ @param dy
+ vertical skip for character (zero for horizontal writing mode):
+ cursor is shifted by this amount for next char
+
+ @param originX
+ local offset of character (zero for horizontal writing mode). not
+ taken into account for output pos updates. Used for vertical writing.
+
+ @param originY
+ local offset of character (zero for horizontal writing mode). not
+ taken into account for output pos updates. Used for vertical writing.
+ */
+
+#if POPPLER_CHECK_VERSION(0, 82, 0)
+void PDFOutDev::drawChar(GfxState *state, double x, double y,
+ double dx, double dy,
+ double originX, double originY,
+ CharCode, int /*nBytes*/, const Unicode *u, int uLen)
+{
+#else
+void PDFOutDev::drawChar(GfxState *state, double x, double y,
+ double dx, double dy,
+ double originX, double originY,
+ CharCode, int /*nBytes*/, Unicode *u, int uLen)
+{
+#endif
+ assert(state);
+
+ if( u == nullptr )
+ return;
+
+ // Fix for tdf#96080
+ if (uLen == 4 && u[0] == '\t' && u[1] == '\r' && u[2] == ' ' && u[3] == 0xA0)
+ {
+ u += 2;
+ uLen = 1;
+ }
+
+ double csdx = 0.0;
+ double csdy = 0.0;
+ if (state->getFont()->getWMode())
+ {
+ csdy = state->getCharSpace();
+ if (*u == ' ')
+ csdy += state->getWordSpace();
+ }
+ else
+ {
+ csdx = state->getCharSpace();
+ if (*u == ' ')
+ csdx += state->getWordSpace();
+ csdx *= state->getHorizScaling();
+ }
+
+ double cstdx = 0.0;
+ double cstdy = 0.0;
+ state->textTransformDelta(csdx, csdy, &cstdx, &cstdy);
+
+ const double fontSize = state->getFontSize();
+
+ const double aPositionX(x-originX);
+ const double aPositionY(y-originY);
+
+ const double* pTextMat=state->getTextMat();
+ printf( "drawChar %f %f %f %f %f %f %f %f %f ",
+ normalize(aPositionX),
+ normalize(aPositionY),
+ normalize(aPositionX + dx - cstdx),
+ normalize(aPositionY + dy - cstdy),
+ normalize(pTextMat[0]),
+ normalize(pTextMat[2]),
+ normalize(pTextMat[1]),
+ normalize(pTextMat[3]),
+ normalize(fontSize)
+ );
+
+ // silence spurious warning
+#if POPPLER_CHECK_VERSION(0, 62, 0)
+ (void)&mapUTF16;
+#else
+ (void)&mapUCS2;
+#endif
+
+ char buf[9];
+ for( int i=0; i<uLen; ++i )
+ {
+ buf[ m_pUtf8Map->mapUnicode(u[i], buf, sizeof(buf)-1) ] = 0;
+ std::vector<char> aEsc( lcl_escapeLineFeeds(buf) );
+ printf( "%s", aEsc.data() );
+ }
+
+ printf( "\n" );
+}
+
+#if POPPLER_CHECK_VERSION(0, 64, 0)
+void PDFOutDev::drawString(GfxState*, const GooString* /*s*/)
+#else
+void PDFOutDev::drawString(GfxState*, GooString* /*s*/)
+#endif
+{
+ // TODO(F3): NYI
+}
+
+void PDFOutDev::endTextObject(GfxState*)
+{
+ printf( "endTextObject\n" );
+}
+
+void PDFOutDev::drawImageMask(GfxState* pState, Object*, Stream* str,
+ int width, int height, poppler_bool invert,
+ poppler_bool /*interpolate*/,
+ poppler_bool /*inlineImg*/ )
+{
+ if (m_bSkipImages)
+ return;
+ OutputBuffer aBuf; initBuf(aBuf);
+
+ printf( "drawMask %d %d %d", width, height, invert );
+
+ int bitsPerComponent = 1;
+ StreamColorSpaceMode csMode = streamCSNone;
+ str->getImageParams( &bitsPerComponent, &csMode );
+ if( bitsPerComponent == 1 && (csMode == streamCSNone || csMode == streamCSDeviceGray) )
+ {
+ GfxRGB oneColor = { dblToCol( 1.0 ), dblToCol( 1.0 ), dblToCol( 1.0 ) };
+ GfxRGB zeroColor = { dblToCol( 0.0 ), dblToCol( 0.0 ), dblToCol( 0.0 ) };
+ pState->getFillColorSpace()->getRGB( pState->getFillColor(), &zeroColor );
+ if( invert )
+ writePng_( aBuf, str, width, height, oneColor, zeroColor, true );
+ else
+ writePng_( aBuf, str, width, height, zeroColor, oneColor, true );
+ }
+ else
+ writeMaskLF(aBuf, str, width, height, invert);
+ writeBinaryBuffer(aBuf);
+}
+
+#if POPPLER_CHECK_VERSION(0, 82, 0)
+void PDFOutDev::drawImage(GfxState*, Object*, Stream* str,
+ int width, int height, GfxImageColorMap* colorMap,
+ poppler_bool /*interpolate*/,
+ const int* maskColors, poppler_bool /*inlineImg*/ )
+{
+#else
+void PDFOutDev::drawImage(GfxState*, Object*, Stream* str,
+ int width, int height, GfxImageColorMap* colorMap,
+ poppler_bool /*interpolate*/,
+ int* maskColors, poppler_bool /*inlineImg*/ )
+{
+#endif
+ if (m_bSkipImages)
+ return;
+ OutputBuffer aBuf; initBuf(aBuf);
+ OutputBuffer aMaskBuf;
+
+ printf( "drawImage %d %d", width, height );
+
+ if( maskColors )
+ {
+ // write mask colors. nBytes must be even - first half is
+ // lower bound values, second half upper bound values
+ if( colorMap->getColorSpace()->getMode() == csIndexed )
+ {
+ aMaskBuf.push_back( static_cast<char>(maskColors[0]) );
+ aMaskBuf.push_back( static_cast<char>(maskColors[gfxColorMaxComps]) );
+ }
+ else
+ {
+ GfxRGB aMinRGB;
+ colorMap->getColorSpace()->getRGB(
+#if POPPLER_CHECK_VERSION(0, 82, 0)
+ reinterpret_cast<const GfxColor*>(maskColors),
+#else
+ reinterpret_cast<GfxColor*>(maskColors),
+#endif
+ &aMinRGB );
+
+ GfxRGB aMaxRGB;
+ colorMap->getColorSpace()->getRGB(
+#if POPPLER_CHECK_VERSION(0, 82, 0)
+ reinterpret_cast<const GfxColor*>(maskColors)+gfxColorMaxComps,
+#else
+ reinterpret_cast<GfxColor*>(maskColors)+gfxColorMaxComps,
+#endif
+ &aMaxRGB );
+
+ aMaskBuf.push_back( colToByte(aMinRGB.r) );
+ aMaskBuf.push_back( colToByte(aMinRGB.g) );
+ aMaskBuf.push_back( colToByte(aMinRGB.b) );
+ aMaskBuf.push_back( colToByte(aMaxRGB.r) );
+ aMaskBuf.push_back( colToByte(aMaxRGB.g) );
+ aMaskBuf.push_back( colToByte(aMaxRGB.b) );
+ }
+ }
+
+ printf( " %d", static_cast<int>(aMaskBuf.size()) );
+ writeImageLF( aBuf, str, width, height, colorMap );
+ writeBinaryBuffer(aBuf);
+ writeBinaryBuffer(aMaskBuf);
+}
+
+void PDFOutDev::drawMaskedImage(GfxState*, Object*, Stream* str,
+ int width, int height,
+ GfxImageColorMap* colorMap,
+ poppler_bool /*interpolate*/,
+ Stream* maskStr,
+ int maskWidth, int maskHeight,
+ poppler_bool maskInvert, poppler_bool /*maskInterpolate*/
+ )
+{
+ if (m_bSkipImages)
+ return;
+ OutputBuffer aBuf; initBuf(aBuf);
+ printf( "drawImage %d %d 0", width, height );
+ writePng_( aBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert );
+ writeBinaryBuffer( aBuf );
+}
+
+void PDFOutDev::drawSoftMaskedImage(GfxState*, Object*, Stream* str,
+ int width, int height,
+ GfxImageColorMap* colorMap,
+ poppler_bool /*interpolate*/,
+ Stream* maskStr,
+ int maskWidth, int maskHeight,
+ GfxImageColorMap* maskColorMap
+ , poppler_bool /*maskInterpolate*/
+ )
+{
+ if (m_bSkipImages)
+ return;
+ OutputBuffer aBuf; initBuf(aBuf);
+ printf( "drawImage %d %d 0", width, height );
+ writePng_( aBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap );
+ writeBinaryBuffer( aBuf );
+}
+
+void PDFOutDev::setPageNum( int nNumPages )
+{
+ // TODO(F3): printf might format int locale-dependent!
+ printf("setPageNum %d\n", nNumPages);
+}
+
+void PDFOutDev::setSkipImages( bool bSkipImages )
+{
+ m_bSkipImages = bSkipImages;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.hxx b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.hxx
new file mode 100644
index 000000000..2e7d2186f
--- /dev/null
+++ b/sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.hxx
@@ -0,0 +1,309 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_PDFIMPORT_XPDFWRAPPER_PDFIOUTDEV_GPL_HXX
+#define INCLUDED_SDEXT_SOURCE_PDFIMPORT_XPDFWRAPPER_PDFIOUTDEV_GPL_HXX
+
+#include <sal/types.h>
+#include <config_poppler.h>
+
+#if defined __GNUC__ || defined __clang__
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wundef"
+# pragma GCC diagnostic ignored "-Wunused-parameter"
+#elif defined _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4100) // unreferenced formal parameter
+#pragma warning(disable : 4310) // cast truncates constant value
+#endif
+
+#include <GfxState.h>
+#include <GfxFont.h>
+#include <UnicodeMap.h>
+#include <Link.h>
+#include <Object.h>
+#include <OutputDev.h>
+#include <GlobalParams.h>
+#include <PDFDoc.h>
+
+#if defined __GNUC__ || defined __clang__
+# pragma GCC diagnostic pop
+#elif defined _MSC_VER
+#pragma warning(pop)
+#endif
+
+#include <unordered_map>
+#include <vector>
+#include <memory>
+
+class GfxPath;
+class GfxFont;
+class PDFDoc;
+#if HAVE_POPPLER_VERSION_H
+#include <cpp/poppler-version.h>
+#else
+#define POPPLER_VERSION "0.12.3"
+#define POPPLER_VERSION_MAJOR 0
+#define POPPLER_VERSION_MINOR 12
+#define POPPLER_VERSION_MICRO 3
+#endif
+#define POPPLER_CHECK_VERSION(major,minor,micro) \
+ (POPPLER_VERSION_MAJOR > (major) || \
+ (POPPLER_VERSION_MAJOR == (major) && POPPLER_VERSION_MINOR > (minor)) || \
+ (POPPLER_VERSION_MAJOR == (major) && POPPLER_VERSION_MINOR == (minor) && POPPLER_VERSION_MICRO >= (micro)))
+
+namespace pdfi
+{
+ struct FontAttributes
+ {
+ FontAttributes() :
+ familyName(),
+ isEmbedded(false),
+ isBold(false),
+ isItalic(false),
+ isUnderline(false),
+ size(0.0)
+ {}
+
+ // xpdf goo stuff is so totally borked...
+ // ...need to hand-code assignment
+ FontAttributes( const FontAttributes& rSrc ) :
+ familyName(),
+ isEmbedded(rSrc.isEmbedded),
+ isBold(rSrc.isBold),
+ isItalic(rSrc.isItalic),
+ isUnderline(rSrc.isUnderline),
+ size(rSrc.size)
+ {
+ familyName.append(&rSrc.getFamilyName());
+ }
+
+ FontAttributes& operator=( const FontAttributes& rSrc )
+ {
+ familyName.clear();
+ familyName.append(&rSrc.getFamilyName());
+
+ isEmbedded = rSrc.isEmbedded;
+ isBold = rSrc.isBold;
+ isItalic = rSrc.isItalic;
+ isUnderline = rSrc.isUnderline;
+ size = rSrc.size;
+
+ return *this;
+ }
+
+ bool operator==(const FontAttributes& rFont) const
+ {
+ return getFamilyName().cmp(&rFont.getFamilyName())==0 &&
+ isEmbedded == rFont.isEmbedded &&
+ isBold == rFont.isBold &&
+ isItalic == rFont.isItalic &&
+ isUnderline == rFont.isUnderline &&
+ size == rFont.size;
+ }
+
+ GooString familyName;
+ bool isEmbedded;
+ bool isBold;
+ bool isItalic;
+ bool isUnderline;
+ double size;
+
+ private:
+ // Work around const-ness issues in the GooString API:
+ GooString & getFamilyName() const
+ { return const_cast<GooString &>(familyName); }
+ };
+
+ // Versions before 0.15 defined GBool as int; 0.15 redefined it as bool; 0.71 dropped GBool
+#if POPPLER_VERSION_MAJOR == 0 && POPPLER_VERSION_MINOR < 71
+ typedef GBool poppler_bool;
+#else
+ typedef bool poppler_bool;
+#endif
+
+ class PDFOutDev : public OutputDev
+ {
+ // not owned by this class
+ PDFDoc* m_pDoc;
+ mutable std::unordered_map< long long,
+ FontAttributes > m_aFontMap;
+ std::unique_ptr<UnicodeMap> m_pUtf8Map;
+ bool m_bSkipImages;
+
+ int parseFont( long long nNewId, GfxFont* pFont, GfxState* state ) const;
+ void writeFontFile( GfxFont* gfxFont ) const;
+#if POPPLER_CHECK_VERSION(0, 83, 0)
+ static void printPath( const GfxPath* pPath );
+#else
+ static void printPath( GfxPath* pPath );
+#endif
+
+ public:
+ explicit PDFOutDev( PDFDoc* pDoc );
+ virtual ~PDFOutDev() override;
+
+ //----- get info about output device
+
+ // Does this device use upside-down coordinates?
+ // (Upside-down means (0,0) is the top left corner of the page.)
+ virtual poppler_bool upsideDown() override { return true; }
+
+ // Does this device use drawChar() or drawString()?
+ virtual poppler_bool useDrawChar() override { return true; }
+
+ // Does this device use beginType3Char/endType3Char? Otherwise,
+ // text in Type 3 fonts will be drawn with drawChar/drawString.
+ virtual poppler_bool interpretType3Chars() override { return false; }
+
+ // Does this device need non-text content?
+ virtual poppler_bool needNonText() override { return true; }
+
+ //----- initialization and control
+
+ // Set default transform matrix.
+#if POPPLER_CHECK_VERSION(0, 71, 0)
+ virtual void setDefaultCTM(const double *ctm) override;
+#else
+ virtual void setDefaultCTM(double *ctm) override;
+#endif
+
+ // Start a page.
+ virtual void startPage(int pageNum, GfxState *state
+#if POPPLER_CHECK_VERSION(0, 23, 0) || POPPLER_CHECK_VERSION(0, 24, 0)
+ , XRef *xref
+#endif
+ ) override;
+
+ // End a page.
+ virtual void endPage() override;
+
+ //----- link borders
+ #if POPPLER_CHECK_VERSION(0, 19, 0)
+ virtual void processLink(AnnotLink *link) override;
+ #elif POPPLER_CHECK_VERSION(0, 17, 0)
+ virtual void processLink(AnnotLink *link, Catalog *catalog) override;
+ #else
+ virtual void processLink(Link *link, Catalog *catalog) override;
+ #endif
+
+ //----- save/restore graphics state
+ virtual void saveState(GfxState *state) override;
+ virtual void restoreState(GfxState *state) override;
+
+ //----- update graphics state
+ virtual void updateCTM(GfxState *state, double m11, double m12,
+ double m21, double m22, double m31, double m32) override;
+ virtual void updateLineDash(GfxState *state) override;
+ virtual void updateFlatness(GfxState *state) override;
+ virtual void updateLineJoin(GfxState *state) override;
+ virtual void updateLineCap(GfxState *state) override;
+ virtual void updateMiterLimit(GfxState *state) override;
+ virtual void updateLineWidth(GfxState *state) override;
+ virtual void updateFillColor(GfxState *state) override;
+ virtual void updateStrokeColor(GfxState *state) override;
+ virtual void updateFillOpacity(GfxState *state) override;
+ virtual void updateStrokeOpacity(GfxState *state) override;
+ virtual void updateBlendMode(GfxState *state) override;
+
+ //----- update text state
+ virtual void updateFont(GfxState *state) override;
+ virtual void updateRender(GfxState *state) override;
+
+ //----- path painting
+ virtual void stroke(GfxState *state) override;
+ virtual void fill(GfxState *state) override;
+ virtual void eoFill(GfxState *state) override;
+
+ //----- path clipping
+ virtual void clip(GfxState *state) override;
+ virtual void eoClip(GfxState *state) override;
+
+ //----- text drawing
+#if POPPLER_CHECK_VERSION(0, 82, 0)
+ virtual void drawChar(GfxState *state, double x, double y,
+ double dx, double dy,
+ double originX, double originY,
+ CharCode code, int nBytes, const Unicode *u, int uLen) override;
+#else
+ virtual void drawChar(GfxState *state, double x, double y,
+ double dx, double dy,
+ double originX, double originY,
+ CharCode code, int nBytes, Unicode *u, int uLen) override;
+#endif
+#if POPPLER_CHECK_VERSION(0, 64, 0)
+ virtual void drawString(GfxState *state, const GooString *s) override;
+#else
+ virtual void drawString(GfxState *state, GooString *s) override;
+#endif
+ virtual void endTextObject(GfxState *state) override;
+
+ //----- image drawing
+ virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
+ int width, int height, poppler_bool invert,
+ poppler_bool interpolate,
+ poppler_bool inlineImg) override;
+#if POPPLER_CHECK_VERSION(0, 82, 0)
+ virtual void drawImage(GfxState *state, Object *ref, Stream *str,
+ int width, int height, GfxImageColorMap *colorMap,
+ poppler_bool interpolate,
+ const int* maskColors, poppler_bool inlineImg) override;
+#else
+ virtual void drawImage(GfxState *state, Object *ref, Stream *str,
+ int width, int height, GfxImageColorMap *colorMap,
+ poppler_bool interpolate,
+ int* maskColors, poppler_bool inlineImg) override;
+#endif
+ virtual void drawMaskedImage(GfxState *state, Object *ref, Stream *str,
+ int width, int height,
+ GfxImageColorMap *colorMap,
+ poppler_bool interpolate,
+ Stream *maskStr, int maskWidth, int maskHeight,
+ poppler_bool maskInvert,
+ poppler_bool maskInterpolate
+ ) override;
+ virtual void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
+ int width, int height,
+ GfxImageColorMap *colorMap,
+ poppler_bool interpolate,
+ Stream *maskStr,
+ int maskWidth, int maskHeight,
+ GfxImageColorMap *maskColorMap
+ , poppler_bool maskInterpolate
+ ) override;
+
+ static void setPageNum( int nNumPages );
+ void setSkipImages ( bool bSkipImages );
+ };
+}
+
+extern FILE* g_binary_out;
+
+// note: if you ever change Output_t, please keep in mind that the current code
+// relies on it being of 8 bit size
+typedef unsigned char Output_t;
+typedef std::vector< Output_t > OutputBuffer;
+
+#if !POPPLER_CHECK_VERSION(0, 73, 0)
+static_assert(std::is_same_v<Guchar, unsigned char>, "unexpected typedef");
+#endif
+
+#endif // INCLUDED_SDEXT_SOURCE_PDFIMPORT_XPDFWRAPPER_PDFIOUTDEV_GPL_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/pdfimport/xpdfwrapper/pnghelper.cxx b/sdext/source/pdfimport/xpdfwrapper/pnghelper.cxx
new file mode 100644
index 000000000..5131838a9
--- /dev/null
+++ b/sdext/source/pdfimport/xpdfwrapper/pnghelper.cxx
@@ -0,0 +1,402 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "pnghelper.hxx"
+#include <sal/macros.h>
+
+#include <zlib.h>
+
+using namespace pdfi;
+
+// checksum helpers, courtesy of libpng.org
+
+/* Table of CRCs of all 8-bit messages. */
+sal_uInt32 PngHelper::crc_table[256];
+
+/* Flag: has the table been computed? Initially false. */
+bool PngHelper::bCRCTableInit = true;
+
+/* Make the table for a fast CRC. */
+void PngHelper::initCRCTable()
+{
+ for (sal_uInt32 n = 0; n < 256; n++)
+ {
+ sal_uInt32 c = n;
+ for (int k = 0; k < 8; k++)
+ {
+ if (c & 1)
+ c = 0xedb88320L ^ (c >> 1);
+ else
+ c = c >> 1;
+ }
+ crc_table[n] = c;
+ }
+ bCRCTableInit = false;
+}
+
+/* Update a running CRC with the bytes buf[0..len-1]--the CRC
+ should be initialized to all 1's, and the transmitted value
+ is the 1's complement of the final running CRC (see the
+ crc() routine below)). */
+
+void PngHelper::updateCRC( sal_uInt32& io_rCRC, const sal_uInt8* i_pBuf, size_t i_nLen )
+{
+ if( bCRCTableInit )
+ initCRCTable();
+
+ sal_uInt32 nCRC = io_rCRC;
+ for( size_t n = 0; n < i_nLen; n++ )
+ nCRC = crc_table[(nCRC ^ i_pBuf[n]) & 0xff] ^ (nCRC >> 8);
+ io_rCRC = nCRC;
+}
+
+sal_uInt32 PngHelper::getCRC( const sal_uInt8* i_pBuf, size_t i_nLen )
+{
+ sal_uInt32 nCRC = 0xffffffff;
+ updateCRC( nCRC, i_pBuf, i_nLen );
+ return nCRC ^ 0xffffffff;
+}
+
+sal_uInt32 PngHelper::deflateBuffer( const Output_t* i_pBuf, size_t i_nLen, OutputBuffer& o_rOut )
+{
+ size_t nOrigSize = o_rOut.size();
+
+ // prepare z stream
+ z_stream aStream;
+ aStream.zalloc = Z_NULL;
+ aStream.zfree = Z_NULL;
+ aStream.opaque = Z_NULL;
+ deflateInit( &aStream, Z_BEST_COMPRESSION );
+ aStream.avail_in = uInt(i_nLen);
+ aStream.next_in = const_cast<Bytef*>(i_pBuf);
+
+ sal_uInt8 aOutBuf[ 32768 ];
+ do
+ {
+ aStream.avail_out = sizeof( aOutBuf );
+ aStream.next_out = aOutBuf;
+
+ if( deflate( &aStream, Z_FINISH ) == Z_STREAM_ERROR )
+ {
+ deflateEnd( &aStream );
+ // scrap the data of this broken stream
+ o_rOut.resize( nOrigSize );
+ return 0;
+ }
+
+ // append compressed bytes
+ sal_uInt32 nCompressedBytes = sizeof( aOutBuf ) - aStream.avail_out;
+ if( nCompressedBytes )
+ o_rOut.insert( o_rOut.end(), aOutBuf, aOutBuf+nCompressedBytes );
+
+ } while( aStream.avail_out == 0 );
+
+ // cleanup
+ deflateEnd( &aStream );
+
+ return sal_uInt32( o_rOut.size() - nOrigSize );
+}
+
+void PngHelper::appendFileHeader( OutputBuffer& o_rOutputBuf )
+{
+ static const unsigned char aHeader[] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
+
+ o_rOutputBuf.insert( o_rOutputBuf.end(), aHeader, aHeader + SAL_N_ELEMENTS(aHeader) );
+}
+
+size_t PngHelper::startChunk( const char* pChunkName, OutputBuffer& o_rOutputBuf )
+{
+ size_t nIndex = sal_uInt32( o_rOutputBuf.size() );
+ o_rOutputBuf.insert( o_rOutputBuf.end(), 4, Output_t(0) );
+ o_rOutputBuf.push_back( pChunkName[0] );
+ o_rOutputBuf.push_back( pChunkName[1] );
+ o_rOutputBuf.push_back( pChunkName[2] );
+ o_rOutputBuf.push_back( pChunkName[3] );
+ return nIndex;
+}
+
+void PngHelper::set( sal_uInt32 i_nValue, OutputBuffer& o_rOutputBuf, size_t i_nIndex )
+{
+ o_rOutputBuf[ i_nIndex ] = (i_nValue & 0xff000000) >> 24;
+ o_rOutputBuf[ i_nIndex+1 ] = (i_nValue & 0x00ff0000) >> 16;
+ o_rOutputBuf[ i_nIndex+2 ] = (i_nValue & 0x0000ff00) >> 8;
+ o_rOutputBuf[ i_nIndex+3 ] = (i_nValue & 0x000000ff);
+}
+
+void PngHelper::endChunk( size_t nStart, OutputBuffer& o_rOutputBuf )
+{
+ if( nStart+8 > o_rOutputBuf.size() )
+ return; // something broken is going on
+
+ // update chunk length
+ size_t nLen = o_rOutputBuf.size() - nStart;
+ sal_uInt32 nDataLen = sal_uInt32(nLen)-8;
+ set( nDataLen, o_rOutputBuf, nStart );
+
+ // append chunk crc
+ sal_uInt32 nChunkCRC = getCRC( reinterpret_cast<sal_uInt8*>(&o_rOutputBuf[nStart+4]), nLen-4 );
+ append( nChunkCRC, o_rOutputBuf );
+}
+
+void PngHelper::appendIHDR( OutputBuffer& o_rOutputBuf, int width, int height, int depth, int colortype )
+{
+ size_t nStart = startChunk( "IHDR", o_rOutputBuf );
+ append( width, o_rOutputBuf );
+ append( height, o_rOutputBuf );
+ o_rOutputBuf.push_back( Output_t(depth) );
+ o_rOutputBuf.push_back( Output_t(colortype) );
+ o_rOutputBuf.push_back( 0 ); // compression method deflate
+ o_rOutputBuf.push_back( 0 ); // filtering method 0 (default)
+ o_rOutputBuf.push_back( 0 ); // no interlacing
+ endChunk( nStart, o_rOutputBuf );
+}
+
+void PngHelper::appendIEND( OutputBuffer& o_rOutputBuf )
+{
+ size_t nStart = startChunk( "IEND", o_rOutputBuf );
+ endChunk( nStart, o_rOutputBuf );
+}
+
+void PngHelper::createPng( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width,
+ int height,
+ GfxRGB const & zeroColor,
+ GfxRGB const & oneColor,
+ bool bIsMask
+ )
+{
+ appendFileHeader( o_rOutputBuf );
+ appendIHDR( o_rOutputBuf, width, height, 1, 3 );
+
+ // write palette
+ size_t nIdx = startChunk( "PLTE", o_rOutputBuf );
+ // write colors 0 and 1
+ o_rOutputBuf.push_back(colToByte(zeroColor.r));
+ o_rOutputBuf.push_back(colToByte(zeroColor.g));
+ o_rOutputBuf.push_back(colToByte(zeroColor.b));
+ o_rOutputBuf.push_back(colToByte(oneColor.r));
+ o_rOutputBuf.push_back(colToByte(oneColor.g));
+ o_rOutputBuf.push_back(colToByte(oneColor.b));
+ // end PLTE chunk
+ endChunk( nIdx, o_rOutputBuf );
+
+ if( bIsMask )
+ {
+ // write tRNS chunk
+ nIdx = startChunk( "tRNS", o_rOutputBuf );
+ o_rOutputBuf.push_back( 0xff );
+ o_rOutputBuf.push_back( 0 );
+ // end tRNS chunk
+ endChunk( nIdx, o_rOutputBuf );
+ }
+
+ // create scan line data buffer
+ OutputBuffer aScanlines;
+ int nLineSize = (width + 7)/8;
+ aScanlines.reserve( nLineSize * height + height );
+
+ str->reset();
+ for( int y = 0; y < height; y++ )
+ {
+ // determine filter type (none) for this scanline
+ aScanlines.push_back( 0 );
+ for( int x = 0; x < nLineSize; x++ )
+ aScanlines.push_back( str->getChar() );
+ }
+
+ // begin IDAT chunk for scanline data
+ nIdx = startChunk( "IDAT", o_rOutputBuf );
+ // compress scanlines
+ deflateBuffer( aScanlines.data(), aScanlines.size(), o_rOutputBuf );
+ // end IDAT chunk
+ endChunk( nIdx, o_rOutputBuf );
+
+ // output IEND
+ appendIEND( o_rOutputBuf );
+}
+
+void PngHelper::createPng( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width, int height, GfxImageColorMap* colorMap,
+ Stream* maskStr,
+ int maskWidth, int maskHeight, GfxImageColorMap* maskColorMap )
+{
+ appendFileHeader( o_rOutputBuf );
+ appendIHDR( o_rOutputBuf, width, height, 8, 6 ); // RGBA image
+
+ // initialize stream
+ unsigned char *p, *pm;
+ GfxRGB rgb;
+ GfxGray alpha;
+ std::unique_ptr<ImageStream> imgStr(
+ new ImageStream(str,
+ width,
+ colorMap->getNumPixelComps(),
+ colorMap->getBits()));
+ imgStr->reset();
+
+ // create scan line data buffer
+ OutputBuffer aScanlines;
+ aScanlines.reserve( width*height*4 + height );
+
+ for( int y=0; y<height; ++y)
+ {
+ aScanlines.push_back( 0 );
+ p = imgStr->getLine();
+ for( int x=0; x<width; ++x)
+ {
+ colorMap->getRGB(p, &rgb);
+ aScanlines.push_back(colToByte(rgb.r));
+ aScanlines.push_back(colToByte(rgb.g));
+ aScanlines.push_back(colToByte(rgb.b));
+ aScanlines.push_back( 0xff );
+
+ p +=colorMap->getNumPixelComps();
+ }
+ }
+
+
+ // now fill in the mask data
+
+ // CAUTION: originally this was done in one single loop
+ // it caused merry chaos; the reason is that maskStr and str are
+ // not independent streams, it happens that reading one advances
+ // the other, too. Hence the two passes are imperative !
+
+ // initialize mask stream
+ std::unique_ptr<ImageStream> imgStrMask(
+ new ImageStream(maskStr,
+ maskWidth,
+ maskColorMap->getNumPixelComps(),
+ maskColorMap->getBits()));
+
+ imgStrMask->reset();
+ for( int y = 0; y < maskHeight; ++y )
+ {
+ pm = imgStrMask->getLine();
+ for( int x = 0; x < maskWidth; ++x )
+ {
+ maskColorMap->getGray(pm,&alpha);
+ pm += maskColorMap->getNumPixelComps();
+ int nIndex = (y*height/maskHeight) * (width*4+1) + // mapped line
+ (x*width/maskWidth)*4 + 1 + 3 // mapped column
+ ;
+ aScanlines[ nIndex ] = colToByte(alpha);
+ }
+ }
+
+ imgStr.reset();
+ imgStrMask.reset();
+
+ // begind IDAT chunk for scanline data
+ size_t nIdx = startChunk( "IDAT", o_rOutputBuf );
+ // compress scanlines
+ deflateBuffer( aScanlines.data(), aScanlines.size(), o_rOutputBuf );
+ // end IDAT chunk
+ endChunk( nIdx, o_rOutputBuf );
+ // output IEND
+ appendIEND( o_rOutputBuf );
+}
+
+// one bit mask; 0 bits opaque
+void PngHelper::createPng( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width, int height, GfxImageColorMap* colorMap,
+ Stream* maskStr,
+ int maskWidth, int maskHeight,
+ bool maskInvert
+ )
+{
+ appendFileHeader( o_rOutputBuf );
+ appendIHDR( o_rOutputBuf, width, height, 8, 6 ); // RGBA image
+
+ // initialize stream
+ unsigned char *p;
+ GfxRGB rgb;
+ std::unique_ptr<ImageStream> imgStr(
+ new ImageStream(str,
+ width,
+ colorMap->getNumPixelComps(),
+ colorMap->getBits()));
+ imgStr->reset();
+
+ // create scan line data buffer
+ OutputBuffer aScanlines;
+ aScanlines.reserve( width*height*4 + height );
+
+ for( int y=0; y<height; ++y)
+ {
+ aScanlines.push_back( 0 );
+ p = imgStr->getLine();
+ for( int x=0; x<width; ++x)
+ {
+ colorMap->getRGB(p, &rgb);
+ aScanlines.push_back(colToByte(rgb.r));
+ aScanlines.push_back(colToByte(rgb.g));
+ aScanlines.push_back(colToByte(rgb.b));
+ aScanlines.push_back( 0xff );
+
+ p +=colorMap->getNumPixelComps();
+ }
+ }
+
+
+ // now fill in the mask data
+
+ // CAUTION: originally this was done in one single loop
+ // it caused merry chaos; the reason is that maskStr and str are
+ // not independent streams, it happens that reading one advances
+ // the other, too. Hence the two passes are imperative !
+
+ // initialize mask stream
+ std::unique_ptr<ImageStream> imgStrMask(
+ new ImageStream(maskStr, maskWidth, 1, 1));
+
+ imgStrMask->reset();
+ for( int y = 0; y < maskHeight; ++y )
+ {
+ for( int x = 0; x < maskWidth; ++x )
+ {
+ unsigned char aPixel = 0;
+ imgStrMask->getPixel( &aPixel );
+ int nIndex = (y*height/maskHeight) * (width*4+1) + // mapped line
+ (x*width/maskWidth)*4 + 1 + 3 // mapped column
+ ;
+ if( maskInvert )
+ aScanlines[ nIndex ] = aPixel ? 0xff : 0x00;
+ else
+ aScanlines[ nIndex ] = aPixel ? 0x00 : 0xff;
+ }
+ }
+
+ imgStr.reset();
+ imgStrMask.reset();
+
+ // begind IDAT chunk for scanline data
+ size_t nIdx = startChunk( "IDAT", o_rOutputBuf );
+ // compress scanlines
+ deflateBuffer( aScanlines.data(), aScanlines.size(), o_rOutputBuf );
+ // end IDAT chunk
+ endChunk( nIdx, o_rOutputBuf );
+ // output IEND
+ appendIEND( o_rOutputBuf );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/pdfimport/xpdfwrapper/pnghelper.hxx b/sdext/source/pdfimport/xpdfwrapper/pnghelper.hxx
new file mode 100644
index 000000000..e0f2ea98b
--- /dev/null
+++ b/sdext/source/pdfimport/xpdfwrapper/pnghelper.hxx
@@ -0,0 +1,84 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_PDFIMPORT_XPDFWRAPPER_PNGHELPER_HXX
+#define INCLUDED_SDEXT_SOURCE_PDFIMPORT_XPDFWRAPPER_PNGHELPER_HXX
+
+#include <sal/types.h>
+#include "pdfioutdev_gpl.hxx"
+
+
+namespace pdfi
+{
+ class PngHelper
+ {
+ static sal_uInt32 crc_table[ 256 ];
+ static bool bCRCTableInit;
+
+ static void initCRCTable();
+ static void appendFileHeader( OutputBuffer& o_rOutputBuf );
+ static size_t startChunk( const char* pChunkName, OutputBuffer& o_rOut );
+ static void endChunk( size_t nStart, OutputBuffer& o_rOut );
+
+ static void set( sal_uInt32 i_nValue, OutputBuffer& o_rOutputBuf, size_t i_nIndex );
+ static void append( sal_uInt32 i_nValue, OutputBuffer& o_rOutputBuf )
+ {
+ size_t nCur = o_rOutputBuf.size();
+ o_rOutputBuf.insert( o_rOutputBuf.end(), 4, Output_t(0) );
+ set( i_nValue, o_rOutputBuf, nCur );
+ }
+
+ static void appendIHDR( OutputBuffer& o_rOutputBuf, int width, int height, int depth, int colortype );
+ static void appendIEND( OutputBuffer& o_rOutputBuf );
+
+ public:
+ static void updateCRC( sal_uInt32& io_rCRC, const sal_uInt8* i_pBuf, size_t i_nLen );
+ static sal_uInt32 getCRC( const sal_uInt8* i_pBuf, size_t i_nLen );
+
+ // deflates the passed buff i_pBuf and appends it to the output vector
+ // returns the number of bytes added to the output
+ static sal_uInt32 deflateBuffer( const Output_t* i_pBuf, size_t i_nLen, OutputBuffer& o_rOut );
+
+ static void createPng( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width,
+ int height,
+ GfxRGB const & zeroColor,
+ GfxRGB const & oneColor,
+ bool bIsMask
+ );
+ static void createPng( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width, int height, GfxImageColorMap* colorMap,
+ Stream* maskStr,
+ int maskWidth, int maskHeight, GfxImageColorMap* maskColorMap );
+
+ // for one bit masks
+ static void createPng( OutputBuffer& o_rOutputBuf,
+ Stream* str,
+ int width, int height, GfxImageColorMap* colorMap,
+ Stream* maskStr,
+ int maskWidth, int maskHeight, bool maskInvert );
+
+ };
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/pdfimport/xpdfwrapper/wrapper_gpl.cxx b/sdext/source/pdfimport/xpdfwrapper/wrapper_gpl.cxx
new file mode 100644
index 000000000..b1a54bd09
--- /dev/null
+++ b/sdext/source/pdfimport/xpdfwrapper/wrapper_gpl.cxx
@@ -0,0 +1,159 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "pdfioutdev_gpl.hxx"
+#ifdef _WIN32
+# include <io.h>
+# include <fcntl.h> /*_O_BINARY*/
+#endif
+
+FILE* g_binary_out=stderr;
+
+static const char *ownerPassword = "\001";
+static const char *userPassword = "\001";
+static const char *outputFile = "\001";
+static const char *options = "\001";
+
+int main(int argc, char **argv)
+{
+ int k = 0;
+ while (k < argc)
+ {
+ if (!strcmp(argv[k], "-f"))
+ {
+ outputFile = argv[k+1];
+ argc -= 2;
+ for (int j = k; j < argc; ++j)
+ argv[j] = argv[j+2];
+ }
+ else if (!strcmp(argv[k], "-o"))
+ {
+ options = argv[k+1];
+ argc -= 2;
+ for (int j = k; j < argc; ++j)
+ argv[j] = argv[j+2];
+ }
+
+ else if (!strcmp(argv[k], "-opw"))
+ {
+ ownerPassword = argv[k+1];
+ argc -= 2;
+ for (int j = k; j < argc; ++j)
+ argv[j] = argv[j+2];
+ }
+ else if (!strcmp(argv[k], "-upw"))
+ {
+ userPassword = argv[k+1];
+ argc -= 2;
+ for (int j = k; j < argc; ++j)
+ argv[j] = argv[j+2];
+ }
+ ++k;
+ }
+
+ // read config file
+#if POPPLER_CHECK_VERSION(0, 83, 0)
+ globalParams = std::make_unique<GlobalParams>();
+#else
+ globalParams = new GlobalParams();
+#endif
+ globalParams->setErrQuiet(true);
+#if defined(_MSC_VER)
+ globalParams->setupBaseFonts(nullptr);
+#endif
+
+ // try to read a possible open password from stdin
+ char aPwBuf[129];
+ aPwBuf[128] = 0;
+ if( ! fgets( aPwBuf, sizeof(aPwBuf)-1, stdin ) )
+ aPwBuf[0] = 0; // mark as empty
+ else
+ {
+ for( size_t i = 0; i < sizeof(aPwBuf); i++ )
+ {
+ if( aPwBuf[i] == '\n' )
+ {
+ aPwBuf[i] = 0;
+ break;
+ }
+ }
+ }
+
+ // PDFDoc takes over ownership for all strings below
+ GooString* pFileName = new GooString(argv[1]);
+ GooString* pErrFileName = new GooString(argv[2]);
+
+ // check for password string(s)
+ GooString* pOwnerPasswordStr( aPwBuf[0] != 0
+ ? new GooString( aPwBuf )
+ : (ownerPassword[0] != '\001'
+ ? new GooString(ownerPassword)
+ : nullptr ) );
+ GooString* pUserPasswordStr( aPwBuf[0] != 0
+ ? new GooString( aPwBuf )
+ : (userPassword[0] != '\001'
+ ? new GooString(userPassword)
+ : nullptr ) );
+ if( outputFile[0] != '\001' )
+ g_binary_out = fopen(outputFile,"wb");
+
+#ifdef _WIN32
+ // Win actually modifies output for O_TEXT file mode, so need to
+ // revert to binary here
+ _setmode( _fileno( g_binary_out ), _O_BINARY );
+#endif
+
+ PDFDoc aDoc( pFileName,
+ pOwnerPasswordStr,
+ pUserPasswordStr );
+
+ PDFDoc aErrDoc( pErrFileName,
+ pOwnerPasswordStr,
+ pUserPasswordStr );
+
+ // Check various permissions for aDoc.
+ PDFDoc &rDoc = aDoc.isOk()? aDoc: aErrDoc;
+
+ pdfi::PDFOutDev aOutDev(&rDoc);
+ if (!strcmp(options, "SkipImages")) {
+ aOutDev.setSkipImages(true);
+ }
+
+ // tell the receiver early - needed for proper progress calculation
+ const int nPages = rDoc.isOk()? rDoc.getNumPages(): 0;
+ pdfi::PDFOutDev::setPageNum(nPages);
+
+ // virtual resolution of the PDF OutputDev in dpi
+ static const int PDFI_OUTDEV_RESOLUTION = 7200;
+
+ // do the conversion
+ for (int i = 1; i <= nPages; ++i)
+ {
+ rDoc.displayPage(&aOutDev,
+ i,
+ PDFI_OUTDEV_RESOLUTION,
+ PDFI_OUTDEV_RESOLUTION,
+ 0, true, true, true);
+ rDoc.processLinks(&aOutDev, i);
+ }
+
+ return 0;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */