diff options
Diffstat (limited to 'Build')
35 files changed, 0 insertions, 13437 deletions
diff --git a/Build/source/libs/poppler/poppler-src/splash/Splash.cc b/Build/source/libs/poppler/poppler-src/splash/Splash.cc deleted file mode 100644 index 129d01f02ce..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/Splash.cc +++ /dev/null @@ -1,6479 +0,0 @@ -//======================================================================== -// -// Splash.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2005-2017 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2005 Marco Pesenti Gritti <mpg@redhat.com> -// Copyright (C) 2010-2016 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com> -// Copyright (C) 2011-2013, 2015 William Bader <williambader@hotmail.com> -// Copyright (C) 2012 Markus Trippelsdorf <markus@trippelsdorf.de> -// Copyright (C) 2012, 2017 Adrian Johnson <ajohnson@redneon.com> -// Copyright (C) 2012 Matthias Kramm <kramm@quiss.org> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <stdlib.h> -#include <string.h> -#include <limits.h> -#include <assert.h> -#include <math.h> -#include "goo/gmem.h" -#include "goo/GooLikely.h" -#include "goo/GooList.h" -#include "poppler/Error.h" -#include "SplashErrorCodes.h" -#include "SplashMath.h" -#include "SplashBitmap.h" -#include "SplashState.h" -#include "SplashPath.h" -#include "SplashXPath.h" -#include "SplashXPathScanner.h" -#include "SplashPattern.h" -#include "SplashScreen.h" -#include "SplashFont.h" -#include "SplashGlyphBitmap.h" -#include "Splash.h" -#include <algorithm> - -//------------------------------------------------------------------------ - -#define splashAAGamma 1.5 - -// distance of Bezier control point from center for circle approximation -// = (4 * (sqrt(2) - 1) / 3) * r -#define bezierCircle ((SplashCoord)0.55228475) -#define bezierCircle2 ((SplashCoord)(0.5 * 0.55228475)) - -// Divide a 16-bit value (in [0, 255*255]) by 255, returning an 8-bit result. -static inline Guchar div255(int x) { - return (Guchar)((x + (x >> 8) + 0x80) >> 8); -} - -// Clip x to lie in [0, 255]. -static inline Guchar clip255(int x) { - return x < 0 ? 0 : x > 255 ? 255 : x; -} - -template<typename T> -inline void Guswap( T&a, T&b ) { T tmp = a; a=b; b=tmp; } - -// The PDF spec says that all pixels whose *centers* lie within the -// image target region get painted, so we want to round n+0.5 down to -// n. But this causes problems, e.g., with PDF files that fill a -// rectangle with black and then draw an image to the exact same -// rectangle, so we instead use the fill scan conversion rule. -// However, the correct rule works better for glyphs, so we also -// provide that option in fillImageMask. -#if 0 -static inline int imgCoordMungeLower(SplashCoord x) { - return splashCeil(x + 0.5) - 1; -} -static inline int imgCoordMungeUpper(SplashCoord x) { - return splashCeil(x + 0.5) - 1; -} -#else -static inline int imgCoordMungeLower(SplashCoord x) { - return splashFloor(x); -} -static inline int imgCoordMungeUpper(SplashCoord x) { - return splashFloor(x) + 1; -} -static inline int imgCoordMungeLowerC(SplashCoord x, GBool glyphMode) { - return glyphMode ? (splashCeil(x + 0.5) - 1) : splashFloor(x); -} -static inline int imgCoordMungeUpperC(SplashCoord x, GBool glyphMode) { - return glyphMode ? (splashCeil(x + 0.5) - 1) : (splashFloor(x) + 1); -} -#endif - -// Used by drawImage and fillImageMask to divide the target -// quadrilateral into sections. -struct ImageSection { - int y0, y1; // actual y range - int ia0, ia1; // vertex indices for edge A - int ib0, ib1; // vertex indices for edge A - SplashCoord xa0, ya0, xa1, ya1; // edge A - SplashCoord dxdya; // slope of edge A - SplashCoord xb0, yb0, xb1, yb1; // edge B - SplashCoord dxdyb; // slope of edge B -}; - -//------------------------------------------------------------------------ -// SplashPipe -//------------------------------------------------------------------------ - -#define splashPipeMaxStages 9 - -struct SplashPipe { - // pixel coordinates - int x, y; - - // source pattern - SplashPattern *pattern; - - // source alpha and color - Guchar aInput; - GBool usesShape; - SplashColorPtr cSrc; - SplashColor cSrcVal; - - // non-isolated group alpha0 - Guchar *alpha0Ptr; - - // knockout groups - GBool knockout; - Guchar knockoutOpacity; - - // soft mask - SplashColorPtr softMaskPtr; - - // destination alpha and color - SplashColorPtr destColorPtr; - int destColorMask; - Guchar *destAlphaPtr; - - // shape - Guchar shape; - - // result alpha and color - GBool noTransparency; - SplashPipeResultColorCtrl resultColorCtrl; - - // non-isolated group correction - GBool nonIsolatedGroup; - - // the "run" function - void (Splash::*run)(SplashPipe *pipe); -}; - -SplashPipeResultColorCtrl Splash::pipeResultColorNoAlphaBlend[] = { - splashPipeResultColorNoAlphaBlendMono, - splashPipeResultColorNoAlphaBlendMono, - splashPipeResultColorNoAlphaBlendRGB, - splashPipeResultColorNoAlphaBlendRGB, - splashPipeResultColorNoAlphaBlendRGB -#ifdef SPLASH_CMYK - , - splashPipeResultColorNoAlphaBlendCMYK, - splashPipeResultColorNoAlphaBlendDeviceN -#endif -}; - -SplashPipeResultColorCtrl Splash::pipeResultColorAlphaNoBlend[] = { - splashPipeResultColorAlphaNoBlendMono, - splashPipeResultColorAlphaNoBlendMono, - splashPipeResultColorAlphaNoBlendRGB, - splashPipeResultColorAlphaNoBlendRGB, - splashPipeResultColorAlphaNoBlendRGB -#ifdef SPLASH_CMYK - , - splashPipeResultColorAlphaNoBlendCMYK, - splashPipeResultColorAlphaNoBlendDeviceN -#endif -}; - -SplashPipeResultColorCtrl Splash::pipeResultColorAlphaBlend[] = { - splashPipeResultColorAlphaBlendMono, - splashPipeResultColorAlphaBlendMono, - splashPipeResultColorAlphaBlendRGB, - splashPipeResultColorAlphaBlendRGB, - splashPipeResultColorAlphaBlendRGB -#ifdef SPLASH_CMYK - , - splashPipeResultColorAlphaBlendCMYK, - splashPipeResultColorAlphaBlendDeviceN -#endif -}; - -//------------------------------------------------------------------------ - -static void blendXor(SplashColorPtr src, SplashColorPtr dest, - SplashColorPtr blend, SplashColorMode cm) { - int i; - - for (i = 0; i < splashColorModeNComps[cm]; ++i) { - blend[i] = src[i] ^ dest[i]; - } -} - -//------------------------------------------------------------------------ -// modified region -//------------------------------------------------------------------------ - -void Splash::clearModRegion() { - modXMin = bitmap->getWidth(); - modYMin = bitmap->getHeight(); - modXMax = -1; - modYMax = -1; -} - -inline void Splash::updateModX(int x) { - if (x < modXMin) { - modXMin = x; - } - if (x > modXMax) { - modXMax = x; - } -} - -inline void Splash::updateModY(int y) { - if (y < modYMin) { - modYMin = y; - } - if (y > modYMax) { - modYMax = y; - } -} - -//------------------------------------------------------------------------ -// pipeline -//------------------------------------------------------------------------ - -inline void Splash::pipeInit(SplashPipe *pipe, int x, int y, - SplashPattern *pattern, SplashColorPtr cSrc, - Guchar aInput, GBool usesShape, - GBool nonIsolatedGroup, - GBool knockout, Guchar knockoutOpacity) { - pipeSetXY(pipe, x, y); - pipe->pattern = NULL; - - // source color - if (pattern) { - if (pattern->isStatic()) { - pattern->getColor(x, y, pipe->cSrcVal); - } else { - pipe->pattern = pattern; - } - pipe->cSrc = pipe->cSrcVal; - } else { - pipe->cSrc = cSrc; - } - - // source alpha - pipe->aInput = aInput; - pipe->usesShape = usesShape; - pipe->shape = 0; - - // knockout - pipe->knockout = knockout; - pipe->knockoutOpacity = knockoutOpacity; - - // result alpha - if (aInput == 255 && !state->softMask && !usesShape && - !state->inNonIsolatedGroup && !nonIsolatedGroup) { - pipe->noTransparency = gTrue; - } else { - pipe->noTransparency = gFalse; - } - - // result color - if (pipe->noTransparency) { - // the !state->blendFunc case is handled separately in pipeRun - pipe->resultColorCtrl = pipeResultColorNoAlphaBlend[bitmap->mode]; - } else if (!state->blendFunc) { - pipe->resultColorCtrl = pipeResultColorAlphaNoBlend[bitmap->mode]; - } else { - pipe->resultColorCtrl = pipeResultColorAlphaBlend[bitmap->mode]; - } - - // non-isolated group correction - pipe->nonIsolatedGroup = nonIsolatedGroup; - - // select the 'run' function - pipe->run = &Splash::pipeRun; - if (!pipe->pattern && pipe->noTransparency && !state->blendFunc) { - if (bitmap->mode == splashModeMono1 && !pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunSimpleMono1; - } else if (bitmap->mode == splashModeMono8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunSimpleMono8; - } else if (bitmap->mode == splashModeRGB8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunSimpleRGB8; - } else if (bitmap->mode == splashModeXBGR8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunSimpleXBGR8; - } else if (bitmap->mode == splashModeBGR8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunSimpleBGR8; -#ifdef SPLASH_CMYK - } else if (bitmap->mode == splashModeCMYK8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunSimpleCMYK8; - } else if (bitmap->mode == splashModeDeviceN8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunSimpleDeviceN8; -#endif - } - } else if (!pipe->pattern && !pipe->noTransparency && !state->softMask && - pipe->usesShape && - !(state->inNonIsolatedGroup && alpha0Bitmap->alpha) && - !state->blendFunc && !pipe->nonIsolatedGroup) { - if (bitmap->mode == splashModeMono1 && !pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunAAMono1; - } else if (bitmap->mode == splashModeMono8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunAAMono8; - } else if (bitmap->mode == splashModeRGB8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunAARGB8; - } else if (bitmap->mode == splashModeXBGR8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunAAXBGR8; - } else if (bitmap->mode == splashModeBGR8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunAABGR8; -#ifdef SPLASH_CMYK - } else if (bitmap->mode == splashModeCMYK8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunAACMYK8; - } else if (bitmap->mode == splashModeDeviceN8 && pipe->destAlphaPtr) { - pipe->run = &Splash::pipeRunAADeviceN8; -#endif - } - } -} - -// general case -void Splash::pipeRun(SplashPipe *pipe) { - Guchar aSrc, aDest, alphaI, alphaIm1, alpha0, aResult; - SplashColor cSrcNonIso, cDest, cBlend; - SplashColorPtr cSrc; - Guchar cResult0, cResult1, cResult2, cResult3; - int t; -#ifdef SPLASH_CMYK - int cp, mask; - Guchar cResult[SPOT_NCOMPS+4]; -#endif - - //----- source color - - // static pattern: handled in pipeInit - // fixed color: handled in pipeInit - - // dynamic pattern - if (pipe->pattern) { - if (!pipe->pattern->getColor(pipe->x, pipe->y, pipe->cSrcVal)) { - pipeIncX(pipe); - return; - } -#ifdef SPLASH_CMYK - if (bitmap->mode == splashModeCMYK8 || bitmap->mode == splashModeDeviceN8) { - if (state->fillOverprint && state->overprintMode && pipe->pattern->isCMYK()) { - Guint mask = 15; - if (pipe->cSrcVal[0] == 0) { - mask &= ~1; - } - if (pipe->cSrcVal[1] == 0) { - mask &= ~2; - } - if (pipe->cSrcVal[2] == 0) { - mask &= ~4; - } - if (pipe->cSrcVal[3] == 0) { - mask &= ~8; - } - state->overprintMask = mask; - } - } -#endif - } - - if (pipe->noTransparency && !state->blendFunc) { - - //----- write destination pixel - - switch (bitmap->mode) { - case splashModeMono1: - cResult0 = state->grayTransfer[pipe->cSrc[0]]; - if (state->screen->test(pipe->x, pipe->y, cResult0)) { - *pipe->destColorPtr |= pipe->destColorMask; - } else { - *pipe->destColorPtr &= ~pipe->destColorMask; - } - if (!(pipe->destColorMask >>= 1)) { - pipe->destColorMask = 0x80; - ++pipe->destColorPtr; - } - break; - case splashModeMono8: - *pipe->destColorPtr++ = state->grayTransfer[pipe->cSrc[0]]; - break; - case splashModeRGB8: - *pipe->destColorPtr++ = state->rgbTransferR[pipe->cSrc[0]]; - *pipe->destColorPtr++ = state->rgbTransferG[pipe->cSrc[1]]; - *pipe->destColorPtr++ = state->rgbTransferB[pipe->cSrc[2]]; - break; - case splashModeXBGR8: - *pipe->destColorPtr++ = state->rgbTransferB[pipe->cSrc[2]]; - *pipe->destColorPtr++ = state->rgbTransferG[pipe->cSrc[1]]; - *pipe->destColorPtr++ = state->rgbTransferR[pipe->cSrc[0]]; - *pipe->destColorPtr++ = 255; - break; - case splashModeBGR8: - *pipe->destColorPtr++ = state->rgbTransferB[pipe->cSrc[2]]; - *pipe->destColorPtr++ = state->rgbTransferG[pipe->cSrc[1]]; - *pipe->destColorPtr++ = state->rgbTransferR[pipe->cSrc[0]]; - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - if (state->overprintMask & 1) { - pipe->destColorPtr[0] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[0] + state->cmykTransferC[pipe->cSrc[0]], 255) : - state->cmykTransferC[pipe->cSrc[0]]; - } - if (state->overprintMask & 2) { - pipe->destColorPtr[1] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[1] + state->cmykTransferM[pipe->cSrc[1]], 255) : - state->cmykTransferM[pipe->cSrc[1]]; - } - if (state->overprintMask & 4) { - pipe->destColorPtr[2] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[2] + state->cmykTransferY[pipe->cSrc[2]], 255) : - state->cmykTransferY[pipe->cSrc[2]]; - } - if (state->overprintMask & 8) { - pipe->destColorPtr[3] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[3] + state->cmykTransferK[pipe->cSrc[3]], 255) : - state->cmykTransferK[pipe->cSrc[3]]; - } - pipe->destColorPtr += 4; - break; - case splashModeDeviceN8: - mask = 1; - for (cp = 0; cp < SPOT_NCOMPS + 4; cp ++) { - if (state->overprintMask & mask) { - pipe->destColorPtr[cp] = state->deviceNTransfer[cp][pipe->cSrc[cp]]; - } - mask <<= 1; - } - pipe->destColorPtr += (SPOT_NCOMPS+4); - break; -#endif - } - if (pipe->destAlphaPtr) { - *pipe->destAlphaPtr++ = 255; - } - - } else { - - //----- read destination pixel - - Guchar *destColorPtr; - if (pipe->shape && state->blendFunc && pipe->knockout && alpha0Bitmap != NULL) { - destColorPtr = alpha0Bitmap->data + (alpha0Y+pipe->y)*alpha0Bitmap->rowSize; - switch (bitmap->mode) { - case splashModeMono1: - destColorPtr += (alpha0X+pipe->x) / 8; - break; - case splashModeMono8: - destColorPtr += (alpha0X+pipe->x); - break; - case splashModeRGB8: - case splashModeBGR8: - destColorPtr += (alpha0X+pipe->x) * 3; - break; - case splashModeXBGR8: -#ifdef SPLASH_CMYK - case splashModeCMYK8: -#endif - destColorPtr += (alpha0X+pipe->x) * 4; - break; -#ifdef SPLASH_CMYK - case splashModeDeviceN8: - destColorPtr += (alpha0X+pipe->x) * (SPOT_NCOMPS + 4); - break; -#endif - } - } else { - destColorPtr = pipe->destColorPtr; - } - switch (bitmap->mode) { - case splashModeMono1: - cDest[0] = (*destColorPtr & pipe->destColorMask) ? 0xff : 0x00; - break; - case splashModeMono8: - cDest[0] = *destColorPtr; - break; - case splashModeRGB8: - cDest[0] = destColorPtr[0]; - cDest[1] = destColorPtr[1]; - cDest[2] = destColorPtr[2]; - break; - case splashModeXBGR8: - cDest[0] = destColorPtr[2]; - cDest[1] = destColorPtr[1]; - cDest[2] = destColorPtr[0]; - cDest[3] = 255; - break; - case splashModeBGR8: - cDest[0] = destColorPtr[2]; - cDest[1] = destColorPtr[1]; - cDest[2] = destColorPtr[0]; - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - cDest[0] = destColorPtr[0]; - cDest[1] = destColorPtr[1]; - cDest[2] = destColorPtr[2]; - cDest[3] = destColorPtr[3]; - break; - case splashModeDeviceN8: - for (cp = 0; cp < SPOT_NCOMPS + 4; cp++) - cDest[cp] = destColorPtr[cp]; - break; -#endif - } - if (pipe->destAlphaPtr) { - aDest = *pipe->destAlphaPtr; - } else { - aDest = 0xff; - } - - //----- source alpha - - if (state->softMask) { - if (pipe->usesShape) { - aSrc = div255(div255(pipe->aInput * *pipe->softMaskPtr++) * - pipe->shape); - } else { - aSrc = div255(pipe->aInput * *pipe->softMaskPtr++); - } - } else if (pipe->usesShape) { - aSrc = div255(pipe->aInput * pipe->shape); - } else { - aSrc = pipe->aInput; - } - - //----- non-isolated group correction - - if (pipe->nonIsolatedGroup) { - // This path is only used when Splash::composite() is called to - // composite a non-isolated group onto the backdrop. In this - // case, pipe->shape is the source (group) alpha. - if (pipe->shape == 0) { - // this value will be multiplied by zero later, so it doesn't - // matter what we use - cSrc = pipe->cSrc; - } else { - t = (aDest * 255) / pipe->shape - aDest; - switch (bitmap->mode) { -#ifdef SPLASH_CMYK - case splashModeDeviceN8: - for (cp = 0; cp < SPOT_NCOMPS + 4; cp++) - cSrcNonIso[cp] = clip255(pipe->cSrc[cp] + - ((pipe->cSrc[cp] - cDest[cp]) * t) / 255); - break; - case splashModeCMYK8: - for (cp = 0; cp < 4; cp++) - cSrcNonIso[cp] = clip255(pipe->cSrc[cp] + - ((pipe->cSrc[cp] - cDest[cp]) * t) / 255); - break; -#endif - case splashModeXBGR8: - cSrcNonIso[3] = 255; - // fallthrough - case splashModeRGB8: - case splashModeBGR8: - cSrcNonIso[2] = clip255(pipe->cSrc[2] + - ((pipe->cSrc[2] - cDest[2]) * t) / 255); - cSrcNonIso[1] = clip255(pipe->cSrc[1] + - ((pipe->cSrc[1] - cDest[1]) * t) / 255); - // fallthrough - case splashModeMono1: - case splashModeMono8: - cSrcNonIso[0] = clip255(pipe->cSrc[0] + - ((pipe->cSrc[0] - cDest[0]) * t) / 255); - break; - } - cSrc = cSrcNonIso; - // knockout: remove backdrop color - if (pipe->knockout && pipe->shape >= pipe->knockoutOpacity) { - aDest = 0; - } - } - } else { - cSrc = pipe->cSrc; - } - - //----- blend function - - if (state->blendFunc) { -#ifdef SPLASH_CMYK - if (bitmap->mode == splashModeDeviceN8) { - for (int k = 4; k < 4 + SPOT_NCOMPS; k++) { - cBlend[k] = 0; - } - } -#endif - (*state->blendFunc)(cSrc, cDest, cBlend, bitmap->mode); - } - - //----- result alpha and non-isolated group element correction - - if (pipe->noTransparency) { - alphaI = alphaIm1 = aResult = 255; - } else { - aResult = aSrc + aDest - div255(aSrc * aDest); - - // alphaI = alpha_i - // alphaIm1 = alpha_(i-1) - if (pipe->alpha0Ptr) { - alpha0 = *pipe->alpha0Ptr++; - alphaI = aResult + alpha0 - div255(aResult * alpha0); - alphaIm1 = alpha0 + aDest - div255(alpha0 * aDest); - } else { - alphaI = aResult; - alphaIm1 = aDest; - } - } - - //----- result color - - cResult0 = cResult1 = cResult2 = cResult3 = 0; // make gcc happy - - switch (pipe->resultColorCtrl) { - - case splashPipeResultColorNoAlphaBlendMono: - cResult0 = state->grayTransfer[div255((255 - aDest) * cSrc[0] + - aDest * cBlend[0])]; - break; - case splashPipeResultColorNoAlphaBlendRGB: - cResult0 = state->rgbTransferR[div255((255 - aDest) * cSrc[0] + - aDest * cBlend[0])]; - cResult1 = state->rgbTransferG[div255((255 - aDest) * cSrc[1] + - aDest * cBlend[1])]; - cResult2 = state->rgbTransferB[div255((255 - aDest) * cSrc[2] + - aDest * cBlend[2])]; - break; -#ifdef SPLASH_CMYK - case splashPipeResultColorNoAlphaBlendCMYK: - cResult0 = state->cmykTransferC[div255((255 - aDest) * cSrc[0] + - aDest * cBlend[0])]; - cResult1 = state->cmykTransferM[div255((255 - aDest) * cSrc[1] + - aDest * cBlend[1])]; - cResult2 = state->cmykTransferY[div255((255 - aDest) * cSrc[2] + - aDest * cBlend[2])]; - cResult3 = state->cmykTransferK[div255((255 - aDest) * cSrc[3] + - aDest * cBlend[3])]; - break; - case splashPipeResultColorNoAlphaBlendDeviceN: - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - cResult[cp] = state->deviceNTransfer[cp][div255((255 - aDest) * cSrc[cp] + - aDest * cBlend[cp])]; - break; -#endif - - case splashPipeResultColorAlphaNoBlendMono: - if (alphaI == 0) { - cResult0 = 0; - } else { - cResult0 = state->grayTransfer[((alphaI - aSrc) * cDest[0] + - aSrc * cSrc[0]) / alphaI]; - } - break; - case splashPipeResultColorAlphaNoBlendRGB: - if (alphaI == 0) { - cResult0 = 0; - cResult1 = 0; - cResult2 = 0; - } else { - cResult0 = state->rgbTransferR[((alphaI - aSrc) * cDest[0] + - aSrc * cSrc[0]) / alphaI]; - cResult1 = state->rgbTransferG[((alphaI - aSrc) * cDest[1] + - aSrc * cSrc[1]) / alphaI]; - cResult2 = state->rgbTransferB[((alphaI - aSrc) * cDest[2] + - aSrc * cSrc[2]) / alphaI]; - } - break; -#ifdef SPLASH_CMYK - case splashPipeResultColorAlphaNoBlendCMYK: - if (alphaI == 0) { - cResult0 = 0; - cResult1 = 0; - cResult2 = 0; - cResult3 = 0; - } else { - cResult0 = state->cmykTransferC[((alphaI - aSrc) * cDest[0] + - aSrc * cSrc[0]) / alphaI]; - cResult1 = state->cmykTransferM[((alphaI - aSrc) * cDest[1] + - aSrc * cSrc[1]) / alphaI]; - cResult2 = state->cmykTransferY[((alphaI - aSrc) * cDest[2] + - aSrc * cSrc[2]) / alphaI]; - cResult3 = state->cmykTransferK[((alphaI - aSrc) * cDest[3] + - aSrc * cSrc[3]) / alphaI]; - } - break; - case splashPipeResultColorAlphaNoBlendDeviceN: - if (alphaI == 0) { - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - cResult[cp] = 0; - } else { - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - cResult[cp] = state->deviceNTransfer[cp][((alphaI - aSrc) * cDest[cp] + - aSrc * cSrc[cp]) / alphaI]; - } - break; -#endif - - case splashPipeResultColorAlphaBlendMono: - if (alphaI == 0) { - cResult0 = 0; - } else { - cResult0 = state->grayTransfer[((alphaI - aSrc) * cDest[0] + - aSrc * ((255 - alphaIm1) * cSrc[0] + - alphaIm1 * cBlend[0]) / 255) / - alphaI]; - } - break; - case splashPipeResultColorAlphaBlendRGB: - if (alphaI == 0) { - cResult0 = 0; - cResult1 = 0; - cResult2 = 0; - } else { - cResult0 = state->rgbTransferR[((alphaI - aSrc) * cDest[0] + - aSrc * ((255 - alphaIm1) * cSrc[0] + - alphaIm1 * cBlend[0]) / 255) / - alphaI]; - cResult1 = state->rgbTransferG[((alphaI - aSrc) * cDest[1] + - aSrc * ((255 - alphaIm1) * cSrc[1] + - alphaIm1 * cBlend[1]) / 255) / - alphaI]; - cResult2 = state->rgbTransferB[((alphaI - aSrc) * cDest[2] + - aSrc * ((255 - alphaIm1) * cSrc[2] + - alphaIm1 * cBlend[2]) / 255) / - alphaI]; - } - break; -#ifdef SPLASH_CMYK - case splashPipeResultColorAlphaBlendCMYK: - if (alphaI == 0) { - cResult0 = 0; - cResult1 = 0; - cResult2 = 0; - cResult3 = 0; - } else { - cResult0 = state->cmykTransferC[((alphaI - aSrc) * cDest[0] + - aSrc * ((255 - alphaIm1) * cSrc[0] + - alphaIm1 * cBlend[0]) / 255) / - alphaI]; - cResult1 = state->cmykTransferM[((alphaI - aSrc) * cDest[1] + - aSrc * ((255 - alphaIm1) * cSrc[1] + - alphaIm1 * cBlend[1]) / 255) / - alphaI]; - cResult2 = state->cmykTransferY[((alphaI - aSrc) * cDest[2] + - aSrc * ((255 - alphaIm1) * cSrc[2] + - alphaIm1 * cBlend[2]) / 255) / - alphaI]; - cResult3 = state->cmykTransferK[((alphaI - aSrc) * cDest[3] + - aSrc * ((255 - alphaIm1) * cSrc[3] + - alphaIm1 * cBlend[3]) / 255) / - alphaI]; - } - break; - case splashPipeResultColorAlphaBlendDeviceN: - if (alphaI == 0) { - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - cResult[cp] = 0; - } else { - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - cResult[cp] = state->deviceNTransfer[cp][((alphaI - aSrc) * cDest[cp] + - aSrc * ((255 - alphaIm1) * cSrc[cp] + - alphaIm1 * cBlend[cp]) / 255) / - alphaI]; - } - break; -#endif - } - - //----- write destination pixel - - switch (bitmap->mode) { - case splashModeMono1: - if (state->screen->test(pipe->x, pipe->y, cResult0)) { - *pipe->destColorPtr |= pipe->destColorMask; - } else { - *pipe->destColorPtr &= ~pipe->destColorMask; - } - if (!(pipe->destColorMask >>= 1)) { - pipe->destColorMask = 0x80; - ++pipe->destColorPtr; - } - break; - case splashModeMono8: - *pipe->destColorPtr++ = cResult0; - break; - case splashModeRGB8: - *pipe->destColorPtr++ = cResult0; - *pipe->destColorPtr++ = cResult1; - *pipe->destColorPtr++ = cResult2; - break; - case splashModeXBGR8: - *pipe->destColorPtr++ = cResult2; - *pipe->destColorPtr++ = cResult1; - *pipe->destColorPtr++ = cResult0; - *pipe->destColorPtr++ = 255; - break; - case splashModeBGR8: - *pipe->destColorPtr++ = cResult2; - *pipe->destColorPtr++ = cResult1; - *pipe->destColorPtr++ = cResult0; - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - if (state->overprintMask & 1) { - pipe->destColorPtr[0] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[0] + cResult0, 255) : - cResult0; - } - if (state->overprintMask & 2) { - pipe->destColorPtr[1] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[1] + cResult1, 255) : - cResult1; - } - if (state->overprintMask & 4) { - pipe->destColorPtr[2] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[2] + cResult2, 255) : - cResult2; - } - if (state->overprintMask & 8) { - pipe->destColorPtr[3] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[3] + cResult3, 255) : - cResult3; - } - pipe->destColorPtr += 4; - break; - case splashModeDeviceN8: - mask = 1; - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) { - if (state->overprintMask & mask) { - pipe->destColorPtr[cp] = cResult[cp]; - } - mask <<=1; - } - pipe->destColorPtr += (SPOT_NCOMPS+4); - break; -#endif - } - if (pipe->destAlphaPtr) { - *pipe->destAlphaPtr++ = aResult; - } - - } - - ++pipe->x; -} - -// special case: -// !pipe->pattern && pipe->noTransparency && !state->blendFunc && -// bitmap->mode == splashModeMono1 && !pipe->destAlphaPtr) { -void Splash::pipeRunSimpleMono1(SplashPipe *pipe) { - Guchar cResult0; - - //----- write destination pixel - cResult0 = state->grayTransfer[pipe->cSrc[0]]; - if (state->screen->test(pipe->x, pipe->y, cResult0)) { - *pipe->destColorPtr |= pipe->destColorMask; - } else { - *pipe->destColorPtr &= ~pipe->destColorMask; - } - if (!(pipe->destColorMask >>= 1)) { - pipe->destColorMask = 0x80; - ++pipe->destColorPtr; - } - - ++pipe->x; -} - -// special case: -// !pipe->pattern && pipe->noTransparency && !state->blendFunc && -// bitmap->mode == splashModeMono8 && pipe->destAlphaPtr) { -void Splash::pipeRunSimpleMono8(SplashPipe *pipe) { - //----- write destination pixel - *pipe->destColorPtr++ = state->grayTransfer[pipe->cSrc[0]]; - *pipe->destAlphaPtr++ = 255; - - ++pipe->x; -} - -// special case: -// !pipe->pattern && pipe->noTransparency && !state->blendFunc && -// bitmap->mode == splashModeRGB8 && pipe->destAlphaPtr) { -void Splash::pipeRunSimpleRGB8(SplashPipe *pipe) { - //----- write destination pixel - *pipe->destColorPtr++ = state->rgbTransferR[pipe->cSrc[0]]; - *pipe->destColorPtr++ = state->rgbTransferG[pipe->cSrc[1]]; - *pipe->destColorPtr++ = state->rgbTransferB[pipe->cSrc[2]]; - *pipe->destAlphaPtr++ = 255; - - ++pipe->x; -} - -// special case: -// !pipe->pattern && pipe->noTransparency && !state->blendFunc && -// bitmap->mode == splashModeXBGR8 && pipe->destAlphaPtr) { -void Splash::pipeRunSimpleXBGR8(SplashPipe *pipe) { - //----- write destination pixel - *pipe->destColorPtr++ = state->rgbTransferB[pipe->cSrc[2]]; - *pipe->destColorPtr++ = state->rgbTransferG[pipe->cSrc[1]]; - *pipe->destColorPtr++ = state->rgbTransferR[pipe->cSrc[0]]; - *pipe->destColorPtr++ = 255; - *pipe->destAlphaPtr++ = 255; - - ++pipe->x; -} - -// special case: -// !pipe->pattern && pipe->noTransparency && !state->blendFunc && -// bitmap->mode == splashModeBGR8 && pipe->destAlphaPtr) { -void Splash::pipeRunSimpleBGR8(SplashPipe *pipe) { - //----- write destination pixel - *pipe->destColorPtr++ = state->rgbTransferB[pipe->cSrc[2]]; - *pipe->destColorPtr++ = state->rgbTransferG[pipe->cSrc[1]]; - *pipe->destColorPtr++ = state->rgbTransferR[pipe->cSrc[0]]; - *pipe->destAlphaPtr++ = 255; - - ++pipe->x; -} - -#ifdef SPLASH_CMYK -// special case: -// !pipe->pattern && pipe->noTransparency && !state->blendFunc && -// bitmap->mode == splashModeCMYK8 && pipe->destAlphaPtr) { -void Splash::pipeRunSimpleCMYK8(SplashPipe *pipe) { - //----- write destination pixel - if (state->overprintMask & 1) { - pipe->destColorPtr[0] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[0] + state->cmykTransferC[pipe->cSrc[0]], 255) : - state->cmykTransferC[pipe->cSrc[0]]; - } - if (state->overprintMask & 2) { - pipe->destColorPtr[1] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[1] + state->cmykTransferM[pipe->cSrc[1]], 255) : - state->cmykTransferM[pipe->cSrc[1]]; - } - if (state->overprintMask & 4) { - pipe->destColorPtr[2] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[2] + state->cmykTransferY[pipe->cSrc[2]], 255) : - state->cmykTransferY[pipe->cSrc[2]]; - } - if (state->overprintMask & 8) { - pipe->destColorPtr[3] = (state->overprintAdditive) ? - std::min<int>(pipe->destColorPtr[3] + state->cmykTransferK[pipe->cSrc[3]], 255) : - state->cmykTransferK[pipe->cSrc[3]]; - } - pipe->destColorPtr += 4; - *pipe->destAlphaPtr++ = 255; - - ++pipe->x; -} - -// special case: -// !pipe->pattern && pipe->noTransparency && !state->blendFunc && -// bitmap->mode == splashModeDeviceN8 && pipe->destAlphaPtr) { -void Splash::pipeRunSimpleDeviceN8(SplashPipe *pipe) { - //----- write destination pixel - int mask = 1; - for (int cp = 0; cp < SPOT_NCOMPS+4; cp++) { - if (state->overprintMask & mask) { - pipe->destColorPtr[cp] = state->deviceNTransfer[cp][pipe->cSrc[cp]]; - } - mask <<=1; - } - pipe->destColorPtr += (SPOT_NCOMPS+4); - *pipe->destAlphaPtr++ = 255; - - ++pipe->x; -} -#endif - -// special case: -// !pipe->pattern && !pipe->noTransparency && !state->softMask && -// pipe->usesShape && !pipe->alpha0Ptr && !state->blendFunc && -// !pipe->nonIsolatedGroup && -// bitmap->mode == splashModeMono1 && !pipe->destAlphaPtr -void Splash::pipeRunAAMono1(SplashPipe *pipe) { - Guchar aSrc; - SplashColor cDest; - Guchar cResult0; - - //----- read destination pixel - cDest[0] = (*pipe->destColorPtr & pipe->destColorMask) ? 0xff : 0x00; - - //----- source alpha - aSrc = div255(pipe->aInput * pipe->shape); - - //----- result color - // note: aDest = alpha2 = aResult = 0xff - cResult0 = state->grayTransfer[(Guchar)div255((0xff - aSrc) * cDest[0] + - aSrc * pipe->cSrc[0])]; - - //----- write destination pixel - if (state->screen->test(pipe->x, pipe->y, cResult0)) { - *pipe->destColorPtr |= pipe->destColorMask; - } else { - *pipe->destColorPtr &= ~pipe->destColorMask; - } - if (!(pipe->destColorMask >>= 1)) { - pipe->destColorMask = 0x80; - ++pipe->destColorPtr; - } - - ++pipe->x; -} - -// special case: -// !pipe->pattern && !pipe->noTransparency && !state->softMask && -// pipe->usesShape && !pipe->alpha0Ptr && !state->blendFunc && -// !pipe->nonIsolatedGroup && -// bitmap->mode == splashModeMono8 && pipe->destAlphaPtr -void Splash::pipeRunAAMono8(SplashPipe *pipe) { - Guchar aSrc, aDest, alpha2, aResult; - SplashColor cDest; - Guchar cResult0; - - //----- read destination pixel - cDest[0] = *pipe->destColorPtr; - aDest = *pipe->destAlphaPtr; - - //----- source alpha - aSrc = div255(pipe->aInput * pipe->shape); - - //----- result alpha and non-isolated group element correction - aResult = aSrc + aDest - div255(aSrc * aDest); - alpha2 = aResult; - - //----- result color - if (alpha2 == 0) { - cResult0 = 0; - } else { - cResult0 = state->grayTransfer[(Guchar)(((alpha2 - aSrc) * cDest[0] + - aSrc * pipe->cSrc[0]) / alpha2)]; - } - - //----- write destination pixel - *pipe->destColorPtr++ = cResult0; - *pipe->destAlphaPtr++ = aResult; - - ++pipe->x; -} - -// special case: -// !pipe->pattern && !pipe->noTransparency && !state->softMask && -// pipe->usesShape && !pipe->alpha0Ptr && !state->blendFunc && -// !pipe->nonIsolatedGroup && -// bitmap->mode == splashModeRGB8 && pipe->destAlphaPtr -void Splash::pipeRunAARGB8(SplashPipe *pipe) { - Guchar aSrc, aDest, alpha2, aResult; - SplashColor cDest; - Guchar cResult0, cResult1, cResult2; - - //----- read destination pixel - cDest[0] = pipe->destColorPtr[0]; - cDest[1] = pipe->destColorPtr[1]; - cDest[2] = pipe->destColorPtr[2]; - aDest = *pipe->destAlphaPtr; - - //----- source alpha - aSrc = div255(pipe->aInput * pipe->shape); - - //----- result alpha and non-isolated group element correction - aResult = aSrc + aDest - div255(aSrc * aDest); - alpha2 = aResult; - - //----- result color - if (alpha2 == 0) { - cResult0 = 0; - cResult1 = 0; - cResult2 = 0; - } else { - cResult0 = state->rgbTransferR[(Guchar)(((alpha2 - aSrc) * cDest[0] + - aSrc * pipe->cSrc[0]) / alpha2)]; - cResult1 = state->rgbTransferG[(Guchar)(((alpha2 - aSrc) * cDest[1] + - aSrc * pipe->cSrc[1]) / alpha2)]; - cResult2 = state->rgbTransferB[(Guchar)(((alpha2 - aSrc) * cDest[2] + - aSrc * pipe->cSrc[2]) / alpha2)]; - } - - //----- write destination pixel - *pipe->destColorPtr++ = cResult0; - *pipe->destColorPtr++ = cResult1; - *pipe->destColorPtr++ = cResult2; - *pipe->destAlphaPtr++ = aResult; - - ++pipe->x; -} - -// special case: -// !pipe->pattern && !pipe->noTransparency && !state->softMask && -// pipe->usesShape && !pipe->alpha0Ptr && !state->blendFunc && -// !pipe->nonIsolatedGroup && -// bitmap->mode == splashModeXBGR8 && pipe->destAlphaPtr -void Splash::pipeRunAAXBGR8(SplashPipe *pipe) { - Guchar aSrc, aDest, alpha2, aResult; - SplashColor cDest; - Guchar cResult0, cResult1, cResult2; - - //----- read destination pixel - cDest[0] = pipe->destColorPtr[2]; - cDest[1] = pipe->destColorPtr[1]; - cDest[2] = pipe->destColorPtr[0]; - aDest = *pipe->destAlphaPtr; - - //----- source alpha - aSrc = div255(pipe->aInput * pipe->shape); - - //----- result alpha and non-isolated group element correction - aResult = aSrc + aDest - div255(aSrc * aDest); - alpha2 = aResult; - - //----- result color - if (alpha2 == 0) { - cResult0 = 0; - cResult1 = 0; - cResult2 = 0; - } else { - cResult0 = state->rgbTransferR[(Guchar)(((alpha2 - aSrc) * cDest[0] + - aSrc * pipe->cSrc[0]) / alpha2)]; - cResult1 = state->rgbTransferG[(Guchar)(((alpha2 - aSrc) * cDest[1] + - aSrc * pipe->cSrc[1]) / alpha2)]; - cResult2 = state->rgbTransferB[(Guchar)(((alpha2 - aSrc) * cDest[2] + - aSrc * pipe->cSrc[2]) / alpha2)]; - } - - //----- write destination pixel - *pipe->destColorPtr++ = cResult2; - *pipe->destColorPtr++ = cResult1; - *pipe->destColorPtr++ = cResult0; - *pipe->destColorPtr++ = 255; - *pipe->destAlphaPtr++ = aResult; - - ++pipe->x; -} - -// special case: -// !pipe->pattern && !pipe->noTransparency && !state->softMask && -// pipe->usesShape && !pipe->alpha0Ptr && !state->blendFunc && -// !pipe->nonIsolatedGroup && -// bitmap->mode == splashModeBGR8 && pipe->destAlphaPtr -void Splash::pipeRunAABGR8(SplashPipe *pipe) { - Guchar aSrc, aDest, alpha2, aResult; - SplashColor cDest; - Guchar cResult0, cResult1, cResult2; - - //----- read destination pixel - cDest[0] = pipe->destColorPtr[2]; - cDest[1] = pipe->destColorPtr[1]; - cDest[2] = pipe->destColorPtr[0]; - aDest = *pipe->destAlphaPtr; - - //----- source alpha - aSrc = div255(pipe->aInput * pipe->shape); - - //----- result alpha and non-isolated group element correction - aResult = aSrc + aDest - div255(aSrc * aDest); - alpha2 = aResult; - - //----- result color - if (alpha2 == 0) { - cResult0 = 0; - cResult1 = 0; - cResult2 = 0; - } else { - cResult0 = state->rgbTransferR[(Guchar)(((alpha2 - aSrc) * cDest[0] + - aSrc * pipe->cSrc[0]) / alpha2)]; - cResult1 = state->rgbTransferG[(Guchar)(((alpha2 - aSrc) * cDest[1] + - aSrc * pipe->cSrc[1]) / alpha2)]; - cResult2 = state->rgbTransferB[(Guchar)(((alpha2 - aSrc) * cDest[2] + - aSrc * pipe->cSrc[2]) / alpha2)]; - } - - //----- write destination pixel - *pipe->destColorPtr++ = cResult2; - *pipe->destColorPtr++ = cResult1; - *pipe->destColorPtr++ = cResult0; - *pipe->destAlphaPtr++ = aResult; - - ++pipe->x; -} - -#ifdef SPLASH_CMYK -// special case: -// !pipe->pattern && !pipe->noTransparency && !state->softMask && -// pipe->usesShape && !pipe->alpha0Ptr && !state->blendFunc && -// !pipe->nonIsolatedGroup && -// bitmap->mode == splashModeCMYK8 && pipe->destAlphaPtr -void Splash::pipeRunAACMYK8(SplashPipe *pipe) { - Guchar aSrc, aDest, alpha2, aResult; - SplashColor cDest; - Guchar cResult0, cResult1, cResult2, cResult3; - - //----- read destination pixel - cDest[0] = pipe->destColorPtr[0]; - cDest[1] = pipe->destColorPtr[1]; - cDest[2] = pipe->destColorPtr[2]; - cDest[3] = pipe->destColorPtr[3]; - aDest = *pipe->destAlphaPtr; - - //----- source alpha - aSrc = div255(pipe->aInput * pipe->shape); - - //----- result alpha and non-isolated group element correction - aResult = aSrc + aDest - div255(aSrc * aDest); - alpha2 = aResult; - - //----- result color - if (alpha2 == 0) { - cResult0 = 0; - cResult1 = 0; - cResult2 = 0; - cResult3 = 0; - } else { - cResult0 = state->cmykTransferC[(Guchar)(((alpha2 - aSrc) * cDest[0] + - aSrc * pipe->cSrc[0]) / alpha2)]; - cResult1 = state->cmykTransferM[(Guchar)(((alpha2 - aSrc) * cDest[1] + - aSrc * pipe->cSrc[1]) / alpha2)]; - cResult2 = state->cmykTransferY[(Guchar)(((alpha2 - aSrc) * cDest[2] + - aSrc * pipe->cSrc[2]) / alpha2)]; - cResult3 = state->cmykTransferK[(Guchar)(((alpha2 - aSrc) * cDest[3] + - aSrc * pipe->cSrc[3]) / alpha2)]; - } - - //----- write destination pixel - if (state->overprintMask & 1) { - pipe->destColorPtr[0] = (state->overprintAdditive && pipe->shape != 0) ? - std::min<int>(pipe->destColorPtr[0] + cResult0, 255) : - cResult0; - } - if (state->overprintMask & 2) { - pipe->destColorPtr[1] = (state->overprintAdditive && pipe->shape != 0) ? - std::min<int>(pipe->destColorPtr[1] + cResult1, 255) : - cResult1; - } - if (state->overprintMask & 4) { - pipe->destColorPtr[2] = (state->overprintAdditive && pipe->shape != 0) ? - std::min<int>(pipe->destColorPtr[2] + cResult2, 255) : - cResult2; - } - if (state->overprintMask & 8) { - pipe->destColorPtr[3] = (state->overprintAdditive && pipe->shape != 0) ? - std::min<int>(pipe->destColorPtr[3] + cResult3, 255) : - cResult3; - } - pipe->destColorPtr += 4; - *pipe->destAlphaPtr++ = aResult; - - ++pipe->x; -} - -// special case: -// !pipe->pattern && !pipe->noTransparency && !state->softMask && -// pipe->usesShape && !pipe->alpha0Ptr && !state->blendFunc && -// !pipe->nonIsolatedGroup && -// bitmap->mode == splashModeDeviceN8 && pipe->destAlphaPtr -void Splash::pipeRunAADeviceN8(SplashPipe *pipe) { - Guchar aSrc, aDest, alpha2, aResult; - SplashColor cDest; - Guchar cResult[SPOT_NCOMPS+4]; - int cp, mask; - - //----- read destination pixel - for (cp=0; cp < SPOT_NCOMPS+4; cp++) - cDest[cp] = pipe->destColorPtr[cp]; - aDest = *pipe->destAlphaPtr; - - //----- source alpha - aSrc = div255(pipe->aInput * pipe->shape); - - //----- result alpha and non-isolated group element correction - aResult = aSrc + aDest - div255(aSrc * aDest); - alpha2 = aResult; - - //----- result color - if (alpha2 == 0) { - for (cp=0; cp < SPOT_NCOMPS+4; cp++) - cResult[cp] = 0; - } else { - for (cp=0; cp < SPOT_NCOMPS+4; cp++) - cResult[cp] = state->deviceNTransfer[cp][(Guchar)(((alpha2 - aSrc) * cDest[cp] + - aSrc * pipe->cSrc[cp]) / alpha2)]; - } - - //----- write destination pixel - mask = 1; - for (cp=0; cp < SPOT_NCOMPS+4; cp++) { - if (state->overprintMask & mask) { - pipe->destColorPtr[cp] = cResult[cp]; - } - mask <<= 1; - } - pipe->destColorPtr += (SPOT_NCOMPS+4); - *pipe->destAlphaPtr++ = aResult; - - ++pipe->x; -} -#endif - -inline void Splash::pipeSetXY(SplashPipe *pipe, int x, int y) { - pipe->x = x; - pipe->y = y; - if (state->softMask) { - pipe->softMaskPtr = - &state->softMask->data[y * state->softMask->rowSize + x]; - } - switch (bitmap->mode) { - case splashModeMono1: - pipe->destColorPtr = &bitmap->data[y * bitmap->rowSize + (x >> 3)]; - pipe->destColorMask = 0x80 >> (x & 7); - break; - case splashModeMono8: - pipe->destColorPtr = &bitmap->data[y * bitmap->rowSize + x]; - break; - case splashModeRGB8: - case splashModeBGR8: - pipe->destColorPtr = &bitmap->data[y * bitmap->rowSize + 3 * x]; - break; - case splashModeXBGR8: - pipe->destColorPtr = &bitmap->data[y * bitmap->rowSize + 4 * x]; - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - pipe->destColorPtr = &bitmap->data[y * bitmap->rowSize + 4 * x]; - break; - case splashModeDeviceN8: - pipe->destColorPtr = &bitmap->data[y * bitmap->rowSize + (SPOT_NCOMPS + 4) * x]; - break; -#endif - } - if (bitmap->alpha) { - pipe->destAlphaPtr = &bitmap->alpha[y * bitmap->width + x]; - } else { - pipe->destAlphaPtr = NULL; - } - if (state->inNonIsolatedGroup && alpha0Bitmap->alpha) { - pipe->alpha0Ptr = - &alpha0Bitmap->alpha[(alpha0Y + y) * alpha0Bitmap->width + - (alpha0X + x)]; - } else { - pipe->alpha0Ptr = NULL; - } -} - -inline void Splash::pipeIncX(SplashPipe *pipe) { - ++pipe->x; - if (state->softMask) { - ++pipe->softMaskPtr; - } - switch (bitmap->mode) { - case splashModeMono1: - if (!(pipe->destColorMask >>= 1)) { - pipe->destColorMask = 0x80; - ++pipe->destColorPtr; - } - break; - case splashModeMono8: - ++pipe->destColorPtr; - break; - case splashModeRGB8: - case splashModeBGR8: - pipe->destColorPtr += 3; - break; - case splashModeXBGR8: - pipe->destColorPtr += 4; - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - pipe->destColorPtr += 4; - break; - case splashModeDeviceN8: - pipe->destColorPtr += (SPOT_NCOMPS+4); - break; -#endif - } - if (pipe->destAlphaPtr) { - ++pipe->destAlphaPtr; - } - if (pipe->alpha0Ptr) { - ++pipe->alpha0Ptr; - } -} - -inline void Splash::drawPixel(SplashPipe *pipe, int x, int y, GBool noClip) { - if (unlikely(y < 0)) - return; - - if (noClip || state->clip->test(x, y)) { - pipeSetXY(pipe, x, y); - (this->*pipe->run)(pipe); - updateModX(x); - updateModY(y); - } -} - -inline void Splash::drawAAPixelInit() { - aaBufY = -1; -} - -inline void Splash::drawAAPixel(SplashPipe *pipe, int x, int y) { -#if splashAASize == 4 - static int bitCount4[16] = { 0, 1, 1, 2, 1, 2, 2, 3, - 1, 2, 2, 3, 2, 3, 3, 4 }; - int w; -#else - int xx, yy; -#endif - SplashColorPtr p; - int x0, x1, t; - - if (x < 0 || x >= bitmap->width || - y < state->clip->getYMinI() || y > state->clip->getYMaxI()) { - return; - } - - // update aaBuf - if (y != aaBufY) { - memset(aaBuf->getDataPtr(), 0xff, - aaBuf->getRowSize() * aaBuf->getHeight()); - x0 = 0; - x1 = bitmap->width - 1; - state->clip->clipAALine(aaBuf, &x0, &x1, y); - aaBufY = y; - } - - // compute the shape value -#if splashAASize == 4 - p = aaBuf->getDataPtr() + (x >> 1); - w = aaBuf->getRowSize(); - if (x & 1) { - t = bitCount4[*p & 0x0f] + bitCount4[p[w] & 0x0f] + - bitCount4[p[2*w] & 0x0f] + bitCount4[p[3*w] & 0x0f]; - } else { - t = bitCount4[*p >> 4] + bitCount4[p[w] >> 4] + - bitCount4[p[2*w] >> 4] + bitCount4[p[3*w] >> 4]; - } -#else - t = 0; - for (yy = 0; yy < splashAASize; ++yy) { - for (xx = 0; xx < splashAASize; ++xx) { - p = aaBuf->getDataPtr() + yy * aaBuf->getRowSize() + - ((x * splashAASize + xx) >> 3); - t += (*p >> (7 - ((x * splashAASize + xx) & 7))) & 1; - } - } -#endif - - // draw the pixel - if (t != 0) { - pipeSetXY(pipe, x, y); - pipe->shape = div255(aaGamma[t] * pipe->shape); - (this->*pipe->run)(pipe); - updateModX(x); - updateModY(y); - } -} - -inline void Splash::drawSpan(SplashPipe *pipe, int x0, int x1, int y, - GBool noClip) { - int x; - - if (noClip) { - pipeSetXY(pipe, x0, y); - for (x = x0; x <= x1; ++x) { - (this->*pipe->run)(pipe); - } - updateModX(x0); - updateModX(x1); - updateModY(y); - } else { - if (x0 < state->clip->getXMinI()) { - x0 = state->clip->getXMinI(); - } - if (x1 > state->clip->getXMaxI()) { - x1 = state->clip->getXMaxI(); - } - pipeSetXY(pipe, x0, y); - for (x = x0; x <= x1; ++x) { - if (state->clip->test(x, y)) { - (this->*pipe->run)(pipe); - updateModX(x); - updateModY(y); - } else { - pipeIncX(pipe); - } - } - } -} - -inline void Splash::drawAALine(SplashPipe *pipe, int x0, int x1, int y, GBool adjustLine, Guchar lineOpacity) { -#if splashAASize == 4 - static int bitCount4[16] = { 0, 1, 1, 2, 1, 2, 2, 3, - 1, 2, 2, 3, 2, 3, 3, 4 }; - SplashColorPtr p0, p1, p2, p3; - int t; -#else - SplashColorPtr p; - int xx, yy, t; -#endif - int x; - -#if splashAASize == 4 - p0 = aaBuf->getDataPtr() + (x0 >> 1); - p1 = p0 + aaBuf->getRowSize(); - p2 = p1 + aaBuf->getRowSize(); - p3 = p2 + aaBuf->getRowSize(); -#endif - pipeSetXY(pipe, x0, y); - for (x = x0; x <= x1; ++x) { - - // compute the shape value -#if splashAASize == 4 - if (x & 1) { - t = bitCount4[*p0 & 0x0f] + bitCount4[*p1 & 0x0f] + - bitCount4[*p2 & 0x0f] + bitCount4[*p3 & 0x0f]; - ++p0; ++p1; ++p2; ++p3; - } else { - t = bitCount4[*p0 >> 4] + bitCount4[*p1 >> 4] + - bitCount4[*p2 >> 4] + bitCount4[*p3 >> 4]; - } -#else - t = 0; - for (yy = 0; yy < splashAASize; ++yy) { - for (xx = 0; xx < splashAASize; ++xx) { - p = aaBuf->getDataPtr() + yy * aaBuf->getRowSize() + - ((x * splashAASize + xx) >> 3); - t += (*p >> (7 - ((x * splashAASize + xx) & 7))) & 1; - } - } -#endif - - if (t != 0) { - pipe->shape = (adjustLine) ? div255((int) lineOpacity * (double)aaGamma[t]) : (double)aaGamma[t]; - (this->*pipe->run)(pipe); - updateModX(x); - updateModY(y); - } else { - pipeIncX(pipe); - } - } -} - -//------------------------------------------------------------------------ - -// Transform a point from user space to device space. -inline void Splash::transform(SplashCoord *matrix, - SplashCoord xi, SplashCoord yi, - SplashCoord *xo, SplashCoord *yo) { - // [ m[0] m[1] 0 ] - // [xo yo 1] = [xi yi 1] * [ m[2] m[3] 0 ] - // [ m[4] m[5] 1 ] - *xo = xi * matrix[0] + yi * matrix[2] + matrix[4]; - *yo = xi * matrix[1] + yi * matrix[3] + matrix[5]; -} - -//------------------------------------------------------------------------ -// Splash -//------------------------------------------------------------------------ - -Splash::Splash(SplashBitmap *bitmapA, GBool vectorAntialiasA, - SplashScreenParams *screenParams) { - int i; - - bitmap = bitmapA; - vectorAntialias = vectorAntialiasA; - inShading = gFalse; - state = new SplashState(bitmap->width, bitmap->height, vectorAntialias, - screenParams); - if (vectorAntialias) { - aaBuf = new SplashBitmap(splashAASize * bitmap->width, splashAASize, - 1, splashModeMono1, gFalse); - for (i = 0; i <= splashAASize * splashAASize; ++i) { - aaGamma[i] = (Guchar)splashRound( - splashPow((SplashCoord)i / - (SplashCoord)(splashAASize * splashAASize), - splashAAGamma) * 255); - } - } else { - aaBuf = NULL; - } - minLineWidth = 0; - thinLineMode = splashThinLineDefault; - clearModRegion(); - debugMode = gFalse; - alpha0Bitmap = NULL; -} - -Splash::Splash(SplashBitmap *bitmapA, GBool vectorAntialiasA, - SplashScreen *screenA) { - int i; - - bitmap = bitmapA; - inShading = gFalse; - vectorAntialias = vectorAntialiasA; - state = new SplashState(bitmap->width, bitmap->height, vectorAntialias, - screenA); - if (vectorAntialias) { - aaBuf = new SplashBitmap(splashAASize * bitmap->width, splashAASize, - 1, splashModeMono1, gFalse); - for (i = 0; i <= splashAASize * splashAASize; ++i) { - aaGamma[i] = (Guchar)splashRound( - splashPow((SplashCoord)i / - (SplashCoord)(splashAASize * splashAASize), - splashAAGamma) * 255); - } - } else { - aaBuf = NULL; - } - minLineWidth = 0; - thinLineMode = splashThinLineDefault; - clearModRegion(); - debugMode = gFalse; - alpha0Bitmap = NULL; -} - -Splash::~Splash() { - while (state->next) { - restoreState(); - } - delete state; - delete aaBuf; -} - -//------------------------------------------------------------------------ -// state read -//------------------------------------------------------------------------ - -SplashCoord *Splash::getMatrix() { - return state->matrix; -} - -SplashPattern *Splash::getStrokePattern() { - return state->strokePattern; -} - -SplashPattern *Splash::getFillPattern() { - return state->fillPattern; -} - -SplashScreen *Splash::getScreen() { - return state->screen; -} - -SplashBlendFunc Splash::getBlendFunc() { - return state->blendFunc; -} - -SplashCoord Splash::getStrokeAlpha() { - return state->strokeAlpha; -} - -SplashCoord Splash::getFillAlpha() { - return state->fillAlpha; -} - -SplashCoord Splash::getLineWidth() { - return state->lineWidth; -} - -int Splash::getLineCap() { - return state->lineCap; -} - -int Splash::getLineJoin() { - return state->lineJoin; -} - -SplashCoord Splash::getMiterLimit() { - return state->miterLimit; -} - -SplashCoord Splash::getFlatness() { - return state->flatness; -} - -SplashCoord *Splash::getLineDash() { - return state->lineDash; -} - -int Splash::getLineDashLength() { - return state->lineDashLength; -} - -SplashCoord Splash::getLineDashPhase() { - return state->lineDashPhase; -} - -GBool Splash::getStrokeAdjust() { - return state->strokeAdjust; -} - -SplashClip *Splash::getClip() { - return state->clip; -} - -SplashBitmap *Splash::getSoftMask() { - return state->softMask; -} - -GBool Splash::getInNonIsolatedGroup() { - return state->inNonIsolatedGroup; -} - -//------------------------------------------------------------------------ -// state write -//------------------------------------------------------------------------ - -void Splash::setMatrix(SplashCoord *matrix) { - memcpy(state->matrix, matrix, 6 * sizeof(SplashCoord)); -} - -void Splash::setStrokePattern(SplashPattern *strokePattern) { - state->setStrokePattern(strokePattern); -} - -void Splash::setFillPattern(SplashPattern *fillPattern) { - state->setFillPattern(fillPattern); -} - -void Splash::setScreen(SplashScreen *screen) { - state->setScreen(screen); -} - -void Splash::setBlendFunc(SplashBlendFunc func) { - state->blendFunc = func; -} - -void Splash::setStrokeAlpha(SplashCoord alpha) { - state->strokeAlpha = (state->multiplyPatternAlpha) ? alpha * state->patternStrokeAlpha : alpha; -} - -void Splash::setFillAlpha(SplashCoord alpha) { - state->fillAlpha = (state->multiplyPatternAlpha) ? alpha * state->patternFillAlpha : alpha; -} - -void Splash::setPatternAlpha(SplashCoord strokeAlpha, SplashCoord fillAlpha) { - state->patternStrokeAlpha = strokeAlpha; - state->patternFillAlpha = fillAlpha; - state->multiplyPatternAlpha = gTrue; -} - -void Splash::clearPatternAlpha() { - state->patternStrokeAlpha = 1; - state->patternFillAlpha = 1; - state->multiplyPatternAlpha = gFalse; -} - -void Splash::setFillOverprint(GBool fop) { - state->fillOverprint = fop; -} - -void Splash::setStrokeOverprint(GBool gop) { - state->strokeOverprint = gop; -} - -void Splash::setOverprintMode(int opm) { - state->overprintMode = opm; -} - -void Splash::setLineWidth(SplashCoord lineWidth) { - state->lineWidth = lineWidth; -} - -void Splash::setLineCap(int lineCap) { - state->lineCap = lineCap; -} - -void Splash::setLineJoin(int lineJoin) { - state->lineJoin = lineJoin; -} - -void Splash::setMiterLimit(SplashCoord miterLimit) { - state->miterLimit = miterLimit; -} - -void Splash::setFlatness(SplashCoord flatness) { - if (flatness < 1) { - state->flatness = 1; - } else { - state->flatness = flatness; - } -} - -void Splash::setLineDash(SplashCoord *lineDash, int lineDashLength, - SplashCoord lineDashPhase) { - state->setLineDash(lineDash, lineDashLength, lineDashPhase); -} - -void Splash::setStrokeAdjust(GBool strokeAdjust) { - state->strokeAdjust = strokeAdjust; -} - -void Splash::clipResetToRect(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1) { - state->clip->resetToRect(x0, y0, x1, y1); -} - -SplashError Splash::clipToRect(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1) { - return state->clip->clipToRect(x0, y0, x1, y1); -} - -SplashError Splash::clipToPath(SplashPath *path, GBool eo) { - return state->clip->clipToPath(path, state->matrix, state->flatness, eo); -} - -void Splash::setSoftMask(SplashBitmap *softMask) { - state->setSoftMask(softMask); -} - -void Splash::setInNonIsolatedGroup(SplashBitmap *alpha0BitmapA, - int alpha0XA, int alpha0YA) { - alpha0Bitmap = alpha0BitmapA; - alpha0X = alpha0XA; - alpha0Y = alpha0YA; - state->inNonIsolatedGroup = gTrue; -} - -void Splash::setTransfer(Guchar *red, Guchar *green, Guchar *blue, - Guchar *gray) { - state->setTransfer(red, green, blue, gray); -} - -void Splash::setOverprintMask(Guint overprintMask, GBool additive) { - state->overprintMask = overprintMask; - state->overprintAdditive = additive; -} - -//------------------------------------------------------------------------ -// state save/restore -//------------------------------------------------------------------------ - -void Splash::saveState() { - SplashState *newState; - - newState = state->copy(); - newState->next = state; - state = newState; -} - -SplashError Splash::restoreState() { - SplashState *oldState; - - if (!state->next) { - return splashErrNoSave; - } - oldState = state; - state = state->next; - delete oldState; - return splashOk; -} - -//------------------------------------------------------------------------ -// drawing operations -//------------------------------------------------------------------------ - -void Splash::clear(SplashColorPtr color, Guchar alpha) { - SplashColorPtr row, p; - Guchar mono; - int x, y; - - switch (bitmap->mode) { - case splashModeMono1: - mono = (color[0] & 0x80) ? 0xff : 0x00; - if (bitmap->rowSize < 0) { - memset(bitmap->data + bitmap->rowSize * (bitmap->height - 1), - mono, -bitmap->rowSize * bitmap->height); - } else { - memset(bitmap->data, mono, bitmap->rowSize * bitmap->height); - } - break; - case splashModeMono8: - if (bitmap->rowSize < 0) { - memset(bitmap->data + bitmap->rowSize * (bitmap->height - 1), - color[0], -bitmap->rowSize * bitmap->height); - } else { - memset(bitmap->data, color[0], bitmap->rowSize * bitmap->height); - } - break; - case splashModeRGB8: - if (color[0] == color[1] && color[1] == color[2]) { - if (bitmap->rowSize < 0) { - memset(bitmap->data + bitmap->rowSize * (bitmap->height - 1), - color[0], -bitmap->rowSize * bitmap->height); - } else { - memset(bitmap->data, color[0], bitmap->rowSize * bitmap->height); - } - } else { - row = bitmap->data; - for (y = 0; y < bitmap->height; ++y) { - p = row; - for (x = 0; x < bitmap->width; ++x) { - *p++ = color[2]; - *p++ = color[1]; - *p++ = color[0]; - } - row += bitmap->rowSize; - } - } - break; - case splashModeXBGR8: - if (color[0] == color[1] && color[1] == color[2]) { - if (bitmap->rowSize < 0) { - memset(bitmap->data + bitmap->rowSize * (bitmap->height - 1), - color[0], -bitmap->rowSize * bitmap->height); - } else { - memset(bitmap->data, color[0], bitmap->rowSize * bitmap->height); - } - } else { - row = bitmap->data; - for (y = 0; y < bitmap->height; ++y) { - p = row; - for (x = 0; x < bitmap->width; ++x) { - *p++ = color[0]; - *p++ = color[1]; - *p++ = color[2]; - *p++ = 255; - } - row += bitmap->rowSize; - } - } - break; - case splashModeBGR8: - if (color[0] == color[1] && color[1] == color[2]) { - if (bitmap->rowSize < 0) { - memset(bitmap->data + bitmap->rowSize * (bitmap->height - 1), - color[0], -bitmap->rowSize * bitmap->height); - } else { - memset(bitmap->data, color[0], bitmap->rowSize * bitmap->height); - } - } else { - row = bitmap->data; - for (y = 0; y < bitmap->height; ++y) { - p = row; - for (x = 0; x < bitmap->width; ++x) { - *p++ = color[0]; - *p++ = color[1]; - *p++ = color[2]; - } - row += bitmap->rowSize; - } - } - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - if (color[0] == color[1] && color[1] == color[2] && color[2] == color[3]) { - if (bitmap->rowSize < 0) { - memset(bitmap->data + bitmap->rowSize * (bitmap->height - 1), - color[0], -bitmap->rowSize * bitmap->height); - } else { - memset(bitmap->data, color[0], bitmap->rowSize * bitmap->height); - } - } else { - row = bitmap->data; - for (y = 0; y < bitmap->height; ++y) { - p = row; - for (x = 0; x < bitmap->width; ++x) { - *p++ = color[0]; - *p++ = color[1]; - *p++ = color[2]; - *p++ = color[3]; - } - row += bitmap->rowSize; - } - } - break; - case splashModeDeviceN8: - row = bitmap->data; - for (y = 0; y < bitmap->height; ++y) { - p = row; - for (x = 0; x < bitmap->width; ++x) { - for (int cp = 0; cp < SPOT_NCOMPS+4; cp++) - *p++ = color[cp]; - } - row += bitmap->rowSize; - } - break; -#endif - } - - if (bitmap->alpha) { - memset(bitmap->alpha, alpha, bitmap->width * bitmap->height); - } - - updateModX(0); - updateModY(0); - updateModX(bitmap->width - 1); - updateModY(bitmap->height - 1); -} - -SplashError Splash::stroke(SplashPath *path) { - SplashPath *path2, *dPath; - SplashCoord d1, d2, t1, t2, w; - - if (debugMode) { - printf("stroke [dash:%d] [width:%.2f]:\n", - state->lineDashLength, (double)state->lineWidth); - dumpPath(path); - } - opClipRes = splashClipAllOutside; - if (path->length == 0) { - return splashErrEmptyPath; - } - path2 = flattenPath(path, state->matrix, state->flatness); - if (state->lineDashLength > 0) { - dPath = makeDashedPath(path2); - delete path2; - path2 = dPath; - if (path2->length == 0) { - delete path2; - return splashErrEmptyPath; - } - } - - // transform a unit square, and take the half the max of the two - // diagonals; the product of this number and the line width is the - // (approximate) transformed line width - t1 = state->matrix[0] + state->matrix[2]; - t2 = state->matrix[1] + state->matrix[3]; - d1 = t1 * t1 + t2 * t2; - t1 = state->matrix[0] - state->matrix[2]; - t2 = state->matrix[1] - state->matrix[3]; - d2 = t1 * t1 + t2 * t2; - if (d2 > d1) { - d1 = d2; - } - d1 *= 0.5; - if (d1 > 0 && - d1 * state->lineWidth * state->lineWidth < minLineWidth * minLineWidth) { - w = minLineWidth / splashSqrt(d1); - strokeWide(path2, w); - } else if (bitmap->mode == splashModeMono1) { - // this gets close to Adobe's behavior in mono mode - if (d1 * state->lineWidth <= 2) { - strokeNarrow(path2); - } else { - strokeWide(path2, state->lineWidth); - } - } else { - if (state->lineWidth == 0) { - strokeNarrow(path2); - } else { - strokeWide(path2, state->lineWidth); - } - } - - delete path2; - return splashOk; -} - -void Splash::strokeNarrow(SplashPath *path) { - SplashPipe pipe; - SplashXPath *xPath; - SplashXPathSeg *seg; - int x0, x1, y0, y1, xa, xb, y; - SplashCoord dxdy; - SplashClipResult clipRes; - int nClipRes[3]; - int i; - - nClipRes[0] = nClipRes[1] = nClipRes[2] = 0; - - xPath = new SplashXPath(path, state->matrix, state->flatness, gFalse); - - pipeInit(&pipe, 0, 0, state->strokePattern, NULL, - (Guchar)splashRound(state->strokeAlpha * 255), - gFalse, gFalse); - - for (i = 0, seg = xPath->segs; i < xPath->length; ++i, ++seg) { - if (seg->y0 <= seg->y1) { - y0 = splashFloor(seg->y0); - y1 = splashFloor(seg->y1); - x0 = splashFloor(seg->x0); - x1 = splashFloor(seg->x1); - } else { - y0 = splashFloor(seg->y1); - y1 = splashFloor(seg->y0); - x0 = splashFloor(seg->x1); - x1 = splashFloor(seg->x0); - } - if ((clipRes = state->clip->testRect(x0 <= x1 ? x0 : x1, y0, - x0 <= x1 ? x1 : x0, y1)) - != splashClipAllOutside) { - if (y0 == y1) { - if (x0 <= x1) { - drawSpan(&pipe, x0, x1, y0, clipRes == splashClipAllInside); - } else { - drawSpan(&pipe, x1, x0, y0, clipRes == splashClipAllInside); - } - } else { - dxdy = seg->dxdy; - if (y0 < state->clip->getYMinI()) { - y0 = state->clip->getYMinI(); - x0 = splashFloor(seg->x0 + ((SplashCoord)y0 - seg->y0) * dxdy); - } - if (y1 > state->clip->getYMaxI()) { - y1 = state->clip->getYMaxI(); - x1 = splashFloor(seg->x0 + ((SplashCoord)y1 - seg->y0) * dxdy); - } - if (x0 <= x1) { - xa = x0; - for (y = y0; y <= y1; ++y) { - if (y < y1) { - xb = splashFloor(seg->x0 + - ((SplashCoord)y + 1 - seg->y0) * dxdy); - } else { - xb = x1 + 1; - } - if (xa == xb) { - drawPixel(&pipe, xa, y, clipRes == splashClipAllInside); - } else { - drawSpan(&pipe, xa, xb - 1, y, clipRes == splashClipAllInside); - } - xa = xb; - } - } else { - xa = x0; - for (y = y0; y <= y1; ++y) { - if (y < y1) { - xb = splashFloor(seg->x0 + - ((SplashCoord)y + 1 - seg->y0) * dxdy); - } else { - xb = x1 - 1; - } - if (xa == xb) { - drawPixel(&pipe, xa, y, clipRes == splashClipAllInside); - } else { - drawSpan(&pipe, xb + 1, xa, y, clipRes == splashClipAllInside); - } - xa = xb; - } - } - } - } - ++nClipRes[clipRes]; - } - if (nClipRes[splashClipPartial] || - (nClipRes[splashClipAllInside] && nClipRes[splashClipAllOutside])) { - opClipRes = splashClipPartial; - } else if (nClipRes[splashClipAllInside]) { - opClipRes = splashClipAllInside; - } else { - opClipRes = splashClipAllOutside; - } - - delete xPath; -} - -void Splash::strokeWide(SplashPath *path, SplashCoord w) { - SplashPath *path2; - - path2 = makeStrokePath(path, w, gFalse); - fillWithPattern(path2, gFalse, state->strokePattern, state->strokeAlpha); - delete path2; -} - -SplashPath *Splash::flattenPath(SplashPath *path, SplashCoord *matrix, - SplashCoord flatness) { - SplashPath *fPath; - SplashCoord flatness2; - Guchar flag; - int i; - - fPath = new SplashPath(); -#ifdef USE_FIXEDPOINT - flatness2 = flatness; -#else - flatness2 = flatness * flatness; -#endif - i = 0; - while (i < path->length) { - flag = path->flags[i]; - if (flag & splashPathFirst) { - fPath->moveTo(path->pts[i].x, path->pts[i].y); - ++i; - } else { - if (flag & splashPathCurve) { - flattenCurve(path->pts[i-1].x, path->pts[i-1].y, - path->pts[i ].x, path->pts[i ].y, - path->pts[i+1].x, path->pts[i+1].y, - path->pts[i+2].x, path->pts[i+2].y, - matrix, flatness2, fPath); - i += 3; - } else { - fPath->lineTo(path->pts[i].x, path->pts[i].y); - ++i; - } - if (path->flags[i-1] & splashPathClosed) { - fPath->close(); - } - } - } - return fPath; -} - -void Splash::flattenCurve(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1, - SplashCoord x2, SplashCoord y2, - SplashCoord x3, SplashCoord y3, - SplashCoord *matrix, SplashCoord flatness2, - SplashPath *fPath) { - SplashCoord cx[splashMaxCurveSplits + 1][3]; - SplashCoord cy[splashMaxCurveSplits + 1][3]; - int cNext[splashMaxCurveSplits + 1]; - SplashCoord xl0, xl1, xl2, xr0, xr1, xr2, xr3, xx1, xx2, xh; - SplashCoord yl0, yl1, yl2, yr0, yr1, yr2, yr3, yy1, yy2, yh; - SplashCoord dx, dy, mx, my, tx, ty, d1, d2; - int p1, p2, p3; - - // initial segment - p1 = 0; - p2 = splashMaxCurveSplits; - cx[p1][0] = x0; cy[p1][0] = y0; - cx[p1][1] = x1; cy[p1][1] = y1; - cx[p1][2] = x2; cy[p1][2] = y2; - cx[p2][0] = x3; cy[p2][0] = y3; - cNext[p1] = p2; - - while (p1 < splashMaxCurveSplits) { - - // get the next segment - xl0 = cx[p1][0]; yl0 = cy[p1][0]; - xx1 = cx[p1][1]; yy1 = cy[p1][1]; - xx2 = cx[p1][2]; yy2 = cy[p1][2]; - p2 = cNext[p1]; - xr3 = cx[p2][0]; yr3 = cy[p2][0]; - - // compute the distances (in device space) from the control points - // to the midpoint of the straight line (this is a bit of a hack, - // but it's much faster than computing the actual distances to the - // line) - transform(matrix, (xl0 + xr3) * 0.5, (yl0 + yr3) * 0.5, &mx, &my); - transform(matrix, xx1, yy1, &tx, &ty); -#ifdef USE_FIXEDPOINT - d1 = splashDist(tx, ty, mx, my); -#else - dx = tx - mx; - dy = ty - my; - d1 = dx*dx + dy*dy; -#endif - transform(matrix, xx2, yy2, &tx, &ty); -#ifdef USE_FIXEDPOINT - d2 = splashDist(tx, ty, mx, my); -#else - dx = tx - mx; - dy = ty - my; - d2 = dx*dx + dy*dy; -#endif - - // if the curve is flat enough, or no more subdivisions are - // allowed, add the straight line segment - if (p2 - p1 == 1 || (d1 <= flatness2 && d2 <= flatness2)) { - fPath->lineTo(xr3, yr3); - p1 = p2; - - // otherwise, subdivide the curve - } else { - xl1 = splashAvg(xl0, xx1); - yl1 = splashAvg(yl0, yy1); - xh = splashAvg(xx1, xx2); - yh = splashAvg(yy1, yy2); - xl2 = splashAvg(xl1, xh); - yl2 = splashAvg(yl1, yh); - xr2 = splashAvg(xx2, xr3); - yr2 = splashAvg(yy2, yr3); - xr1 = splashAvg(xh, xr2); - yr1 = splashAvg(yh, yr2); - xr0 = splashAvg(xl2, xr1); - yr0 = splashAvg(yl2, yr1); - // add the new subdivision points - p3 = (p1 + p2) / 2; - cx[p1][1] = xl1; cy[p1][1] = yl1; - cx[p1][2] = xl2; cy[p1][2] = yl2; - cNext[p1] = p3; - cx[p3][0] = xr0; cy[p3][0] = yr0; - cx[p3][1] = xr1; cy[p3][1] = yr1; - cx[p3][2] = xr2; cy[p3][2] = yr2; - cNext[p3] = p2; - } - } -} - -SplashPath *Splash::makeDashedPath(SplashPath *path) { - SplashPath *dPath; - SplashCoord lineDashTotal; - SplashCoord lineDashStartPhase, lineDashDist, segLen; - SplashCoord x0, y0, x1, y1, xa, ya; - GBool lineDashStartOn, lineDashOn, newPath; - int lineDashStartIdx, lineDashIdx; - int i, j, k; - - lineDashTotal = 0; - for (i = 0; i < state->lineDashLength; ++i) { - lineDashTotal += state->lineDash[i]; - } - // Acrobat simply draws nothing if the dash array is [0] - if (lineDashTotal == 0) { - return new SplashPath(); - } - lineDashStartPhase = state->lineDashPhase; - i = splashFloor(lineDashStartPhase / lineDashTotal); - lineDashStartPhase -= (SplashCoord)i * lineDashTotal; - lineDashStartOn = gTrue; - lineDashStartIdx = 0; - if (lineDashStartPhase > 0) { - while (lineDashStartIdx < state->lineDashLength && lineDashStartPhase >= state->lineDash[lineDashStartIdx]) { - lineDashStartOn = !lineDashStartOn; - lineDashStartPhase -= state->lineDash[lineDashStartIdx]; - ++lineDashStartIdx; - } - if (unlikely(lineDashStartIdx == state->lineDashLength)) { - return new SplashPath(); - } - } - - dPath = new SplashPath(); - - // process each subpath - i = 0; - while (i < path->length) { - - // find the end of the subpath - for (j = i; - j < path->length - 1 && !(path->flags[j] & splashPathLast); - ++j) ; - - // initialize the dash parameters - lineDashOn = lineDashStartOn; - lineDashIdx = lineDashStartIdx; - lineDashDist = state->lineDash[lineDashIdx] - lineDashStartPhase; - - // process each segment of the subpath - newPath = gTrue; - for (k = i; k < j; ++k) { - - // grab the segment - x0 = path->pts[k].x; - y0 = path->pts[k].y; - x1 = path->pts[k+1].x; - y1 = path->pts[k+1].y; - segLen = splashDist(x0, y0, x1, y1); - - // process the segment - while (segLen > 0) { - - if (lineDashDist >= segLen) { - if (lineDashOn) { - if (newPath) { - dPath->moveTo(x0, y0); - newPath = gFalse; - } - dPath->lineTo(x1, y1); - } - lineDashDist -= segLen; - segLen = 0; - - } else { - xa = x0 + (lineDashDist / segLen) * (x1 - x0); - ya = y0 + (lineDashDist / segLen) * (y1 - y0); - if (lineDashOn) { - if (newPath) { - dPath->moveTo(x0, y0); - newPath = gFalse; - } - dPath->lineTo(xa, ya); - } - x0 = xa; - y0 = ya; - segLen -= lineDashDist; - lineDashDist = 0; - } - - // get the next entry in the dash array - if (lineDashDist <= 0) { - lineDashOn = !lineDashOn; - if (++lineDashIdx == state->lineDashLength) { - lineDashIdx = 0; - } - lineDashDist = state->lineDash[lineDashIdx]; - newPath = gTrue; - } - } - } - i = j + 1; - } - - if (dPath->length == 0) { - GBool allSame = gTrue; - for (int i = 0; allSame && i < path->length - 1; ++i) { - allSame = path->pts[i].x == path->pts[i + 1].x && path->pts[i].y == path->pts[i + 1].y; - } - if (allSame) { - x0 = path->pts[0].x; - y0 = path->pts[0].y; - dPath->moveTo(x0, y0); - dPath->lineTo(x0, y0); - } - } - - return dPath; -} - -SplashError Splash::fill(SplashPath *path, GBool eo) { - if (debugMode) { - printf("fill [eo:%d]:\n", eo); - dumpPath(path); - } - return fillWithPattern(path, eo, state->fillPattern, state->fillAlpha); -} - -inline void Splash::getBBoxFP(SplashPath *path, SplashCoord *xMinA, SplashCoord *yMinA, - SplashCoord *xMaxA, SplashCoord *yMaxA) { - SplashCoord xMinFP, yMinFP, xMaxFP, yMaxFP, tx, ty; - - // make compiler happy: - xMinFP = xMaxFP = yMinFP = yMaxFP = 0; - for (int i = 0; i < path->length; ++i) { - transform(state->matrix, path->pts[i].x, path->pts[i].y, &tx, &ty); - if (i == 0) { - xMinFP = xMaxFP = tx; - yMinFP = yMaxFP = ty; - } else { - if (tx < xMinFP) xMinFP = tx; - if (tx > xMaxFP) xMaxFP = tx; - if (ty < yMinFP) yMinFP = ty; - if (ty > yMaxFP) yMaxFP = ty; - } - } - - *xMinA = xMinFP; - *yMinA = yMinFP; - *xMaxA = xMaxFP; - *yMaxA = yMaxFP; -} - -SplashError Splash::fillWithPattern(SplashPath *path, GBool eo, - SplashPattern *pattern, - SplashCoord alpha) { - SplashPipe pipe; - SplashXPath *xPath; - SplashXPathScanner *scanner; - int xMinI, yMinI, xMaxI, yMaxI, x0, x1, y; - SplashClipResult clipRes, clipRes2; - GBool adjustLine = gFalse; - int linePosI = 0; - - if (path->length == 0) { - return splashErrEmptyPath; - } - if (pathAllOutside(path)) { - opClipRes = splashClipAllOutside; - return splashOk; - } - - // add stroke adjustment hints for filled rectangles -- this only - // applies to paths that consist of a single subpath - // (this appears to match Acrobat's behavior) - if (state->strokeAdjust && !path->hints) { - int n; - n = path->getLength(); - if (n == 4 && - !(path->flags[0] & splashPathClosed) && - !(path->flags[1] & splashPathLast) && - !(path->flags[2] & splashPathLast)) { - path->close(gTrue); - path->addStrokeAdjustHint(0, 2, 0, 4); - path->addStrokeAdjustHint(1, 3, 0, 4); - } else if (n == 5 && - (path->flags[0] & splashPathClosed) && - !(path->flags[1] & splashPathLast) && - !(path->flags[2] & splashPathLast) && - !(path->flags[3] & splashPathLast)) { - path->addStrokeAdjustHint(0, 2, 0, 4); - path->addStrokeAdjustHint(1, 3, 0, 4); - } - } - - if (thinLineMode != splashThinLineDefault) { - if (state->clip->getXMinI() == state->clip->getXMaxI()) { - linePosI = state->clip->getXMinI(); - adjustLine = gTrue; - } else if (state->clip->getXMinI() == state->clip->getXMaxI() - 1) { - adjustLine = gTrue; - linePosI = splashFloor(state->clip->getXMin() + state->lineWidth); - } else if (state->clip->getYMinI() == state->clip->getYMaxI()) { - linePosI = state->clip->getYMinI(); - adjustLine = gTrue; - } else if (state->clip->getYMinI() == state->clip->getYMaxI() - 1) { - adjustLine = gTrue; - linePosI = splashFloor(state->clip->getYMin() + state->lineWidth); - } - } - - xPath = new SplashXPath(path, state->matrix, state->flatness, gTrue, - adjustLine, linePosI); - if (vectorAntialias && !inShading) { - xPath->aaScale(); - } - xPath->sort(); - yMinI = state->clip->getYMinI(); - yMaxI = state->clip->getYMaxI(); - if (vectorAntialias && !inShading) { - yMinI = yMinI * splashAASize; - yMaxI = (yMaxI + 1) * splashAASize - 1; - } - scanner = new SplashXPathScanner(xPath, eo, yMinI, yMaxI); - - // get the min and max x and y values - if (vectorAntialias && !inShading) { - scanner->getBBoxAA(&xMinI, &yMinI, &xMaxI, &yMaxI); - } else { - scanner->getBBox(&xMinI, &yMinI, &xMaxI, &yMaxI); - } - - if (eo && (yMinI == yMaxI || xMinI == xMaxI) && thinLineMode != splashThinLineDefault) { - SplashCoord delta, xMinFP, yMinFP, xMaxFP, yMaxFP; - getBBoxFP(path, &xMinFP, &yMinFP, &xMaxFP, &yMaxFP); - delta = (yMinI == yMaxI) ? yMaxFP - yMinFP : xMaxFP - xMinFP; - if (delta < 0.2) { - opClipRes = splashClipAllOutside; - delete scanner; - delete xPath; - return splashOk; - } - } - - // check clipping - if ((clipRes = state->clip->testRect(xMinI, yMinI, xMaxI, yMaxI)) - != splashClipAllOutside) { - if (scanner->hasPartialClip()) { - clipRes = splashClipPartial; - } - - pipeInit(&pipe, 0, yMinI, pattern, NULL, (Guchar)splashRound(alpha * 255), - vectorAntialias && !inShading, gFalse); - - // draw the spans - if (vectorAntialias && !inShading) { - for (y = yMinI; y <= yMaxI; ++y) { - scanner->renderAALine(aaBuf, &x0, &x1, y, thinLineMode != splashThinLineDefault && xMinI == xMaxI); - if (clipRes != splashClipAllInside) { - state->clip->clipAALine(aaBuf, &x0, &x1, y, thinLineMode != splashThinLineDefault && xMinI == xMaxI); - } - Guchar lineShape = 255; - GBool adjustLine = gFalse; - if (thinLineMode == splashThinLineShape && (xMinI == xMaxI || yMinI == yMaxI)) { - // compute line shape for thin lines: - SplashCoord mx, my, delta; - transform(state->matrix, 0, 0, &mx, &my); - transform(state->matrix, state->lineWidth, 0, &delta, &my); - adjustLine = gTrue; - lineShape = clip255((delta - mx) * 255); - } - drawAALine(&pipe, x0, x1, y, adjustLine, lineShape); - } - } else { - for (y = yMinI; y <= yMaxI; ++y) { - while (scanner->getNextSpan(y, &x0, &x1)) { - if (clipRes == splashClipAllInside) { - drawSpan(&pipe, x0, x1, y, gTrue); - } else { - // limit the x range - if (x0 < state->clip->getXMinI()) { - x0 = state->clip->getXMinI(); - } - if (x1 > state->clip->getXMaxI()) { - x1 = state->clip->getXMaxI(); - } - clipRes2 = state->clip->testSpan(x0, x1, y); - drawSpan(&pipe, x0, x1, y, clipRes2 == splashClipAllInside); - } - } - } - } - } - opClipRes = clipRes; - - delete scanner; - delete xPath; - return splashOk; -} - -GBool Splash::pathAllOutside(SplashPath *path) { - SplashCoord xMin1, yMin1, xMax1, yMax1; - SplashCoord xMin2, yMin2, xMax2, yMax2; - SplashCoord x, y; - int xMinI, yMinI, xMaxI, yMaxI; - int i; - - xMin1 = xMax1 = path->pts[0].x; - yMin1 = yMax1 = path->pts[0].y; - for (i = 1; i < path->length; ++i) { - if (path->pts[i].x < xMin1) { - xMin1 = path->pts[i].x; - } else if (path->pts[i].x > xMax1) { - xMax1 = path->pts[i].x; - } - if (path->pts[i].y < yMin1) { - yMin1 = path->pts[i].y; - } else if (path->pts[i].y > yMax1) { - yMax1 = path->pts[i].y; - } - } - - transform(state->matrix, xMin1, yMin1, &x, &y); - xMin2 = xMax2 = x; - yMin2 = yMax2 = y; - transform(state->matrix, xMin1, yMax1, &x, &y); - if (x < xMin2) { - xMin2 = x; - } else if (x > xMax2) { - xMax2 = x; - } - if (y < yMin2) { - yMin2 = y; - } else if (y > yMax2) { - yMax2 = y; - } - transform(state->matrix, xMax1, yMin1, &x, &y); - if (x < xMin2) { - xMin2 = x; - } else if (x > xMax2) { - xMax2 = x; - } - if (y < yMin2) { - yMin2 = y; - } else if (y > yMax2) { - yMax2 = y; - } - transform(state->matrix, xMax1, yMax1, &x, &y); - if (x < xMin2) { - xMin2 = x; - } else if (x > xMax2) { - xMax2 = x; - } - if (y < yMin2) { - yMin2 = y; - } else if (y > yMax2) { - yMax2 = y; - } - xMinI = splashFloor(xMin2); - yMinI = splashFloor(yMin2); - xMaxI = splashFloor(xMax2); - yMaxI = splashFloor(yMax2); - - return state->clip->testRect(xMinI, yMinI, xMaxI, yMaxI) == - splashClipAllOutside; -} - -SplashError Splash::xorFill(SplashPath *path, GBool eo) { - SplashPipe pipe; - SplashXPath *xPath; - SplashXPathScanner *scanner; - int xMinI, yMinI, xMaxI, yMaxI, x0, x1, y; - SplashClipResult clipRes, clipRes2; - SplashBlendFunc origBlendFunc; - - if (path->length == 0) { - return splashErrEmptyPath; - } - xPath = new SplashXPath(path, state->matrix, state->flatness, gTrue); - xPath->sort(); - scanner = new SplashXPathScanner(xPath, eo, state->clip->getYMinI(), - state->clip->getYMaxI()); - - // get the min and max x and y values - scanner->getBBox(&xMinI, &yMinI, &xMaxI, &yMaxI); - - // check clipping - if ((clipRes = state->clip->testRect(xMinI, yMinI, xMaxI, yMaxI)) - != splashClipAllOutside) { - if (scanner->hasPartialClip()) { - clipRes = splashClipPartial; - } - - origBlendFunc = state->blendFunc; - state->blendFunc = &blendXor; - pipeInit(&pipe, 0, yMinI, state->fillPattern, NULL, 255, gFalse, gFalse); - - // draw the spans - for (y = yMinI; y <= yMaxI; ++y) { - while (scanner->getNextSpan(y, &x0, &x1)) { - if (clipRes == splashClipAllInside) { - drawSpan(&pipe, x0, x1, y, gTrue); - } else { - // limit the x range - if (x0 < state->clip->getXMinI()) { - x0 = state->clip->getXMinI(); - } - if (x1 > state->clip->getXMaxI()) { - x1 = state->clip->getXMaxI(); - } - clipRes2 = state->clip->testSpan(x0, x1, y); - drawSpan(&pipe, x0, x1, y, clipRes2 == splashClipAllInside); - } - } - } - state->blendFunc = origBlendFunc; - } - opClipRes = clipRes; - - delete scanner; - delete xPath; - return splashOk; -} - -SplashError Splash::fillChar(SplashCoord x, SplashCoord y, - int c, SplashFont *font) { - SplashGlyphBitmap glyph; - SplashCoord xt, yt; - int x0, y0, xFrac, yFrac; - SplashClipResult clipRes; - - if (debugMode) { - printf("fillChar: x=%.2f y=%.2f c=%3d=0x%02x='%c'\n", - (double)x, (double)y, c, c, c); - } - transform(state->matrix, x, y, &xt, &yt); - x0 = splashFloor(xt); - xFrac = splashFloor((xt - x0) * splashFontFraction); - y0 = splashFloor(yt); - yFrac = splashFloor((yt - y0) * splashFontFraction); - if (!font->getGlyph(c, xFrac, yFrac, &glyph, x0, y0, state->clip, &clipRes)) { - return splashErrNoGlyph; - } - if (clipRes != splashClipAllOutside) { - fillGlyph2(x0, y0, &glyph, clipRes == splashClipAllInside); - } - opClipRes = clipRes; - if (glyph.freeData) { - gfree(glyph.data); - } - return splashOk; -} - -void Splash::fillGlyph(SplashCoord x, SplashCoord y, - SplashGlyphBitmap *glyph) { - SplashCoord xt, yt; - int x0, y0; - - transform(state->matrix, x, y, &xt, &yt); - x0 = splashFloor(xt); - y0 = splashFloor(yt); - SplashClipResult clipRes = state->clip->testRect(x0 - glyph->x, - y0 - glyph->y, - x0 - glyph->x + glyph->w - 1, - y0 - glyph->y + glyph->h - 1); - if (clipRes != splashClipAllOutside) { - fillGlyph2(x0, y0, glyph, clipRes == splashClipAllInside); - } - opClipRes = clipRes; -} - -void Splash::fillGlyph2(int x0, int y0, SplashGlyphBitmap *glyph, GBool noClip) { - SplashPipe pipe; - int alpha0; - Guchar alpha; - Guchar *p; - int x1, y1, xx, xx1, yy; - - p = glyph->data; - int xStart = x0 - glyph->x; - int yStart = y0 - glyph->y; - int xxLimit = glyph->w; - int yyLimit = glyph->h; - int xShift = 0; - - if (yStart < 0) - { - p += (glyph->aa ? glyph->w : splashCeil(glyph->w / 8.0)) * -yStart; // move p to the beginning of the first painted row - yyLimit += yStart; - yStart = 0; - } - - if (xStart < 0) - { - if (glyph->aa) { - p += -xStart; - } else { - p += (-xStart) / 8; - xShift = (-xStart) % 8; - } - xxLimit += xStart; - xStart = 0; - } - - if (xxLimit + xStart >= bitmap->width) xxLimit = bitmap->width - xStart; - if (yyLimit + yStart >= bitmap->height) yyLimit = bitmap->height - yStart; - - if (noClip) { - if (glyph->aa) { - pipeInit(&pipe, xStart, yStart, - state->fillPattern, NULL, (Guchar)splashRound(state->fillAlpha * 255), gTrue, gFalse); - for (yy = 0, y1 = yStart; yy < yyLimit; ++yy, ++y1) { - pipeSetXY(&pipe, xStart, y1); - for (xx = 0, x1 = xStart; xx < xxLimit; ++xx, ++x1) { - alpha = p[xx]; - if (alpha != 0) { - pipe.shape = alpha; - (this->*pipe.run)(&pipe); - updateModX(x1); - updateModY(y1); - } else { - pipeIncX(&pipe); - } - } - p += glyph->w; - } - } else { - const int widthEight = splashCeil(glyph->w / 8.0); - - pipeInit(&pipe, xStart, yStart, - state->fillPattern, NULL, (Guchar)splashRound(state->fillAlpha * 255), gFalse, gFalse); - for (yy = 0, y1 = yStart; yy < yyLimit; ++yy, ++y1) { - pipeSetXY(&pipe, xStart, y1); - for (xx = 0, x1 = xStart; xx < xxLimit; xx += 8) { - alpha0 = (xShift > 0 ? (p[xx / 8] << xShift) | (p[xx / 8 + 1] >> (8 - xShift)) : p[xx / 8]); - for (xx1 = 0; xx1 < 8 && xx + xx1 < xxLimit; ++xx1, ++x1) { - if (alpha0 & 0x80) { - (this->*pipe.run)(&pipe); - updateModX(x1); - updateModY(y1); - } else { - pipeIncX(&pipe); - } - alpha0 <<= 1; - } - } - p += widthEight; - } - } - } else { - if (glyph->aa) { - pipeInit(&pipe, xStart, yStart, - state->fillPattern, NULL, (Guchar)splashRound(state->fillAlpha * 255), gTrue, gFalse); - for (yy = 0, y1 = yStart; yy < yyLimit; ++yy, ++y1) { - pipeSetXY(&pipe, xStart, y1); - for (xx = 0, x1 = xStart; xx < xxLimit; ++xx, ++x1) { - if (state->clip->test(x1, y1)) { - alpha = p[xx]; - if (alpha != 0) { - pipe.shape = alpha; - (this->*pipe.run)(&pipe); - updateModX(x1); - updateModY(y1); - } else { - pipeIncX(&pipe); - } - } else { - pipeIncX(&pipe); - } - } - p += glyph->w; - } - } else { - const int widthEight = splashCeil(glyph->w / 8.0); - - pipeInit(&pipe, xStart, yStart, - state->fillPattern, NULL, (Guchar)splashRound(state->fillAlpha * 255), gFalse, gFalse); - for (yy = 0, y1 = yStart; yy < yyLimit; ++yy, ++y1) { - pipeSetXY(&pipe, xStart, y1); - for (xx = 0, x1 = xStart; xx < xxLimit; xx += 8) { - alpha0 = (xShift > 0 ? (p[xx / 8] << xShift) | (p[xx / 8 + 1] >> (8 - xShift)) : p[xx / 8]); - for (xx1 = 0; xx1 < 8 && xx + xx1 < xxLimit; ++xx1, ++x1) { - if (state->clip->test(x1, y1)) { - if (alpha0 & 0x80) { - (this->*pipe.run)(&pipe); - updateModX(x1); - updateModY(y1); - } else { - pipeIncX(&pipe); - } - } else { - pipeIncX(&pipe); - } - alpha0 <<= 1; - } - } - p += widthEight; - } - } - } -} - -SplashError Splash::fillImageMask(SplashImageMaskSource src, void *srcData, - int w, int h, SplashCoord *mat, - GBool glyphMode) { - SplashBitmap *scaledMask; - SplashClipResult clipRes; - GBool minorAxisZero; - int x0, y0, x1, y1, scaledWidth, scaledHeight; - int yp; - - if (debugMode) { - printf("fillImageMask: w=%d h=%d mat=[%.2f %.2f %.2f %.2f %.2f %.2f]\n", - w, h, (double)mat[0], (double)mat[1], (double)mat[2], - (double)mat[3], (double)mat[4], (double)mat[5]); - } - - if (w == 0 && h == 0) return splashErrZeroImage; - - // check for singular matrix - if (!splashCheckDet(mat[0], mat[1], mat[2], mat[3], 0.000001)) { - return splashErrSingularMatrix; - } - - minorAxisZero = mat[1] == 0 && mat[2] == 0; - - // scaling only - if (mat[0] > 0 && minorAxisZero && mat[3] > 0) { - x0 = imgCoordMungeLowerC(mat[4], glyphMode); - y0 = imgCoordMungeLowerC(mat[5], glyphMode); - x1 = imgCoordMungeUpperC(mat[0] + mat[4], glyphMode); - y1 = imgCoordMungeUpperC(mat[3] + mat[5], glyphMode); - // make sure narrow images cover at least one pixel - if (x0 == x1) { - ++x1; - } - if (y0 == y1) { - ++y1; - } - clipRes = state->clip->testRect(x0, y0, x1 - 1, y1 - 1); - opClipRes = clipRes; - if (clipRes != splashClipAllOutside) { - scaledWidth = x1 - x0; - scaledHeight = y1 - y0; - yp = h / scaledHeight; - if (yp < 0 || yp > INT_MAX - 1) { - return splashErrBadArg; - } - scaledMask = scaleMask(src, srcData, w, h, scaledWidth, scaledHeight); - blitMask(scaledMask, x0, y0, clipRes); - delete scaledMask; - } - - // scaling plus vertical flip - } else if (mat[0] > 0 && minorAxisZero && mat[3] < 0) { - x0 = imgCoordMungeLowerC(mat[4], glyphMode); - y0 = imgCoordMungeLowerC(mat[3] + mat[5], glyphMode); - x1 = imgCoordMungeUpperC(mat[0] + mat[4], glyphMode); - y1 = imgCoordMungeUpperC(mat[5], glyphMode); - // make sure narrow images cover at least one pixel - if (x0 == x1) { - ++x1; - } - if (y0 == y1) { - ++y1; - } - clipRes = state->clip->testRect(x0, y0, x1 - 1, y1 - 1); - opClipRes = clipRes; - if (clipRes != splashClipAllOutside) { - scaledWidth = x1 - x0; - scaledHeight = y1 - y0; - yp = h / scaledHeight; - if (yp < 0 || yp > INT_MAX - 1) { - return splashErrBadArg; - } - scaledMask = scaleMask(src, srcData, w, h, scaledWidth, scaledHeight); - vertFlipImage(scaledMask, scaledWidth, scaledHeight, 1); - blitMask(scaledMask, x0, y0, clipRes); - delete scaledMask; - } - - // all other cases - } else { - arbitraryTransformMask(src, srcData, w, h, mat, glyphMode); - } - - return splashOk; -} - -void Splash::arbitraryTransformMask(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - SplashCoord *mat, GBool glyphMode) { - SplashBitmap *scaledMask; - SplashClipResult clipRes, clipRes2; - SplashPipe pipe; - int scaledWidth, scaledHeight, t0, t1; - SplashCoord r00, r01, r10, r11, det, ir00, ir01, ir10, ir11; - SplashCoord vx[4], vy[4]; - int xMin, yMin, xMax, yMax; - ImageSection section[3]; - int nSections; - int y, xa, xb, x, i, xx, yy; - - // compute the four vertices of the target quadrilateral - vx[0] = mat[4]; vy[0] = mat[5]; - vx[1] = mat[2] + mat[4]; vy[1] = mat[3] + mat[5]; - vx[2] = mat[0] + mat[2] + mat[4]; vy[2] = mat[1] + mat[3] + mat[5]; - vx[3] = mat[0] + mat[4]; vy[3] = mat[1] + mat[5]; - - // clipping - xMin = imgCoordMungeLowerC(vx[0], glyphMode); - xMax = imgCoordMungeUpperC(vx[0], glyphMode); - yMin = imgCoordMungeLowerC(vy[0], glyphMode); - yMax = imgCoordMungeUpperC(vy[0], glyphMode); - for (i = 1; i < 4; ++i) { - t0 = imgCoordMungeLowerC(vx[i], glyphMode); - if (t0 < xMin) { - xMin = t0; - } - t0 = imgCoordMungeUpperC(vx[i], glyphMode); - if (t0 > xMax) { - xMax = t0; - } - t1 = imgCoordMungeLowerC(vy[i], glyphMode); - if (t1 < yMin) { - yMin = t1; - } - t1 = imgCoordMungeUpperC(vy[i], glyphMode); - if (t1 > yMax) { - yMax = t1; - } - } - clipRes = state->clip->testRect(xMin, yMin, xMax - 1, yMax - 1); - opClipRes = clipRes; - if (clipRes == splashClipAllOutside) { - return; - } - - // compute the scale factors - if (mat[0] >= 0) { - t0 = imgCoordMungeUpperC(mat[0] + mat[4], glyphMode) - - imgCoordMungeLowerC(mat[4], glyphMode); - } else { - t0 = imgCoordMungeUpperC(mat[4], glyphMode) - - imgCoordMungeLowerC(mat[0] + mat[4], glyphMode); - } - if (mat[1] >= 0) { - t1 = imgCoordMungeUpperC(mat[1] + mat[5], glyphMode) - - imgCoordMungeLowerC(mat[5], glyphMode); - } else { - t1 = imgCoordMungeUpperC(mat[5], glyphMode) - - imgCoordMungeLowerC(mat[1] + mat[5], glyphMode); - } - scaledWidth = t0 > t1 ? t0 : t1; - if (mat[2] >= 0) { - t0 = imgCoordMungeUpperC(mat[2] + mat[4], glyphMode) - - imgCoordMungeLowerC(mat[4], glyphMode); - } else { - t0 = imgCoordMungeUpperC(mat[4], glyphMode) - - imgCoordMungeLowerC(mat[2] + mat[4], glyphMode); - } - if (mat[3] >= 0) { - t1 = imgCoordMungeUpperC(mat[3] + mat[5], glyphMode) - - imgCoordMungeLowerC(mat[5], glyphMode); - } else { - t1 = imgCoordMungeUpperC(mat[5], glyphMode) - - imgCoordMungeLowerC(mat[3] + mat[5], glyphMode); - } - scaledHeight = t0 > t1 ? t0 : t1; - if (scaledWidth == 0) { - scaledWidth = 1; - } - if (scaledHeight == 0) { - scaledHeight = 1; - } - - // compute the inverse transform (after scaling) matrix - r00 = mat[0] / scaledWidth; - r01 = mat[1] / scaledWidth; - r10 = mat[2] / scaledHeight; - r11 = mat[3] / scaledHeight; - det = r00 * r11 - r01 * r10; - if (splashAbs(det) < 1e-6) { - // this should be caught by the singular matrix check in fillImageMask - return; - } - ir00 = r11 / det; - ir01 = -r01 / det; - ir10 = -r10 / det; - ir11 = r00 / det; - - // scale the input image - scaledMask = scaleMask(src, srcData, srcWidth, srcHeight, - scaledWidth, scaledHeight); - if (scaledMask->data == NULL) { - error(errInternal, -1, "scaledMask->data is NULL in Splash::arbitraryTransformMask"); - delete scaledMask; - return; - } - - // construct the three sections - i = (vy[2] <= vy[3]) ? 2 : 3; - if (vy[1] <= vy[i]) { - i = 1; - } - if (vy[0] < vy[i] || (i != 3 && vy[0] == vy[i])) { - i = 0; - } - if (vy[i] == vy[(i+1) & 3]) { - section[0].y0 = imgCoordMungeLowerC(vy[i], glyphMode); - section[0].y1 = imgCoordMungeUpperC(vy[(i+2) & 3], glyphMode) - 1; - if (vx[i] < vx[(i+1) & 3]) { - section[0].ia0 = i; - section[0].ia1 = (i+3) & 3; - section[0].ib0 = (i+1) & 3; - section[0].ib1 = (i+2) & 3; - } else { - section[0].ia0 = (i+1) & 3; - section[0].ia1 = (i+2) & 3; - section[0].ib0 = i; - section[0].ib1 = (i+3) & 3; - } - nSections = 1; - } else { - section[0].y0 = imgCoordMungeLowerC(vy[i], glyphMode); - section[2].y1 = imgCoordMungeUpperC(vy[(i+2) & 3], glyphMode) - 1; - section[0].ia0 = section[0].ib0 = i; - section[2].ia1 = section[2].ib1 = (i+2) & 3; - if (vx[(i+1) & 3] < vx[(i+3) & 3]) { - section[0].ia1 = section[2].ia0 = (i+1) & 3; - section[0].ib1 = section[2].ib0 = (i+3) & 3; - } else { - section[0].ia1 = section[2].ia0 = (i+3) & 3; - section[0].ib1 = section[2].ib0 = (i+1) & 3; - } - if (vy[(i+1) & 3] < vy[(i+3) & 3]) { - section[1].y0 = imgCoordMungeLowerC(vy[(i+1) & 3], glyphMode); - section[2].y0 = imgCoordMungeUpperC(vy[(i+3) & 3], glyphMode); - if (vx[(i+1) & 3] < vx[(i+3) & 3]) { - section[1].ia0 = (i+1) & 3; - section[1].ia1 = (i+2) & 3; - section[1].ib0 = i; - section[1].ib1 = (i+3) & 3; - } else { - section[1].ia0 = i; - section[1].ia1 = (i+3) & 3; - section[1].ib0 = (i+1) & 3; - section[1].ib1 = (i+2) & 3; - } - } else { - section[1].y0 = imgCoordMungeLowerC(vy[(i+3) & 3], glyphMode); - section[2].y0 = imgCoordMungeUpperC(vy[(i+1) & 3], glyphMode); - if (vx[(i+1) & 3] < vx[(i+3) & 3]) { - section[1].ia0 = i; - section[1].ia1 = (i+1) & 3; - section[1].ib0 = (i+3) & 3; - section[1].ib1 = (i+2) & 3; - } else { - section[1].ia0 = (i+3) & 3; - section[1].ia1 = (i+2) & 3; - section[1].ib0 = i; - section[1].ib1 = (i+1) & 3; - } - } - section[0].y1 = section[1].y0 - 1; - section[1].y1 = section[2].y0 - 1; - nSections = 3; - } - for (i = 0; i < nSections; ++i) { - section[i].xa0 = vx[section[i].ia0]; - section[i].ya0 = vy[section[i].ia0]; - section[i].xa1 = vx[section[i].ia1]; - section[i].ya1 = vy[section[i].ia1]; - section[i].xb0 = vx[section[i].ib0]; - section[i].yb0 = vy[section[i].ib0]; - section[i].xb1 = vx[section[i].ib1]; - section[i].yb1 = vy[section[i].ib1]; - section[i].dxdya = (section[i].xa1 - section[i].xa0) / - (section[i].ya1 - section[i].ya0); - section[i].dxdyb = (section[i].xb1 - section[i].xb0) / - (section[i].yb1 - section[i].yb0); - } - - // initialize the pixel pipe - pipeInit(&pipe, 0, 0, state->fillPattern, NULL, - (Guchar)splashRound(state->fillAlpha * 255), gTrue, gFalse); - if (vectorAntialias) { - drawAAPixelInit(); - } - - // make sure narrow images cover at least one pixel - if (nSections == 1) { - if (section[0].y0 == section[0].y1) { - ++section[0].y1; - clipRes = opClipRes = splashClipPartial; - } - } else { - if (section[0].y0 == section[2].y1) { - ++section[1].y1; - clipRes = opClipRes = splashClipPartial; - } - } - - // scan all pixels inside the target region - for (i = 0; i < nSections; ++i) { - for (y = section[i].y0; y <= section[i].y1; ++y) { - xa = imgCoordMungeLowerC(section[i].xa0 + - ((SplashCoord)y + 0.5 - section[i].ya0) * - section[i].dxdya, - glyphMode); - xb = imgCoordMungeUpperC(section[i].xb0 + - ((SplashCoord)y + 0.5 - section[i].yb0) * - section[i].dxdyb, - glyphMode); - if (unlikely(xa < 0)) - xa = 0; - // make sure narrow images cover at least one pixel - if (xa == xb) { - ++xb; - } - if (clipRes != splashClipAllInside) { - clipRes2 = state->clip->testSpan(xa, xb - 1, y); - } else { - clipRes2 = clipRes; - } - for (x = xa; x < xb; ++x) { - // map (x+0.5, y+0.5) back to the scaled image - xx = splashFloor(((SplashCoord)x + 0.5 - mat[4]) * ir00 + - ((SplashCoord)y + 0.5 - mat[5]) * ir10); - yy = splashFloor(((SplashCoord)x + 0.5 - mat[4]) * ir01 + - ((SplashCoord)y + 0.5 - mat[5]) * ir11); - // xx should always be within bounds, but floating point - // inaccuracy can cause problems - if (xx < 0) { - xx = 0; - } else if (xx >= scaledWidth) { - xx = scaledWidth - 1; - } - if (yy < 0) { - yy = 0; - } else if (yy >= scaledHeight) { - yy = scaledHeight - 1; - } - pipe.shape = scaledMask->data[yy * scaledWidth + xx]; - if (vectorAntialias && clipRes2 != splashClipAllInside) { - drawAAPixel(&pipe, x, y); - } else { - drawPixel(&pipe, x, y, clipRes2 == splashClipAllInside); - } - } - } - } - - delete scaledMask; -} - -// Scale an image mask into a SplashBitmap. -SplashBitmap *Splash::scaleMask(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight) { - SplashBitmap *dest; - - dest = new SplashBitmap(scaledWidth, scaledHeight, 1, splashModeMono8, - gFalse); - if (scaledHeight < srcHeight) { - if (scaledWidth < srcWidth) { - scaleMaskYdXd(src, srcData, srcWidth, srcHeight, - scaledWidth, scaledHeight, dest); - } else { - scaleMaskYdXu(src, srcData, srcWidth, srcHeight, - scaledWidth, scaledHeight, dest); - } - } else { - if (scaledWidth < srcWidth) { - scaleMaskYuXd(src, srcData, srcWidth, srcHeight, - scaledWidth, scaledHeight, dest); - } else { - scaleMaskYuXu(src, srcData, srcWidth, srcHeight, - scaledWidth, scaledHeight, dest); - } - } - return dest; -} - -void Splash::scaleMaskYdXd(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest) { - Guchar *lineBuf; - Guint *pixBuf; - Guint pix; - Guchar *destPtr; - int yp, yq, xp, xq, yt, y, yStep, xt, x, xStep, xx, d, d0, d1; - int i, j; - - // Bresenham parameters for y scale - yp = srcHeight / scaledHeight; - yq = srcHeight % scaledHeight; - - // Bresenham parameters for x scale - xp = srcWidth / scaledWidth; - xq = srcWidth % scaledWidth; - - // allocate buffers - lineBuf = (Guchar *)gmalloc(srcWidth); - pixBuf = (Guint *)gmallocn(srcWidth, sizeof(int)); - - // init y scale Bresenham - yt = 0; - - destPtr = dest->data; - for (y = 0; y < scaledHeight; ++y) { - - // y scale Bresenham - if ((yt += yq) >= scaledHeight) { - yt -= scaledHeight; - yStep = yp + 1; - } else { - yStep = yp; - } - - // read rows from image - memset(pixBuf, 0, srcWidth * sizeof(int)); - for (i = 0; i < yStep; ++i) { - (*src)(srcData, lineBuf); - for (j = 0; j < srcWidth; ++j) { - pixBuf[j] += lineBuf[j]; - } - } - - // init x scale Bresenham - xt = 0; - d0 = (255 << 23) / (yStep * xp); - d1 = (255 << 23) / (yStep * (xp + 1)); - - xx = 0; - for (x = 0; x < scaledWidth; ++x) { - - // x scale Bresenham - if ((xt += xq) >= scaledWidth) { - xt -= scaledWidth; - xStep = xp + 1; - d = d1; - } else { - xStep = xp; - d = d0; - } - - // compute the final pixel - pix = 0; - for (i = 0; i < xStep; ++i) { - pix += pixBuf[xx++]; - } - // (255 * pix) / xStep * yStep - pix = (pix * d) >> 23; - - // store the pixel - *destPtr++ = (Guchar)pix; - } - } - - gfree(pixBuf); - gfree(lineBuf); -} - -void Splash::scaleMaskYdXu(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest) { - Guchar *lineBuf; - Guint *pixBuf; - Guint pix; - Guchar *destPtr; - int yp, yq, xp, xq, yt, y, yStep, xt, x, xStep, d; - int i, j; - - destPtr = dest->data; - if (destPtr == NULL) { - error(errInternal, -1, "dest->data is NULL in Splash::scaleMaskYdXu"); - return; - } - - // Bresenham parameters for y scale - yp = srcHeight / scaledHeight; - yq = srcHeight % scaledHeight; - - // Bresenham parameters for x scale - xp = scaledWidth / srcWidth; - xq = scaledWidth % srcWidth; - - // allocate buffers - lineBuf = (Guchar *)gmalloc(srcWidth); - pixBuf = (Guint *)gmallocn(srcWidth, sizeof(int)); - - // init y scale Bresenham - yt = 0; - - for (y = 0; y < scaledHeight; ++y) { - - // y scale Bresenham - if ((yt += yq) >= scaledHeight) { - yt -= scaledHeight; - yStep = yp + 1; - } else { - yStep = yp; - } - - // read rows from image - memset(pixBuf, 0, srcWidth * sizeof(int)); - for (i = 0; i < yStep; ++i) { - (*src)(srcData, lineBuf); - for (j = 0; j < srcWidth; ++j) { - pixBuf[j] += lineBuf[j]; - } - } - - // init x scale Bresenham - xt = 0; - d = (255 << 23) / yStep; - - for (x = 0; x < srcWidth; ++x) { - - // x scale Bresenham - if ((xt += xq) >= srcWidth) { - xt -= srcWidth; - xStep = xp + 1; - } else { - xStep = xp; - } - - // compute the final pixel - pix = pixBuf[x]; - // (255 * pix) / yStep - pix = (pix * d) >> 23; - - // store the pixel - for (i = 0; i < xStep; ++i) { - *destPtr++ = (Guchar)pix; - } - } - } - - gfree(pixBuf); - gfree(lineBuf); -} - -void Splash::scaleMaskYuXd(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest) { - Guchar *lineBuf; - Guint pix; - Guchar *destPtr0, *destPtr; - int yp, yq, xp, xq, yt, y, yStep, xt, x, xStep, xx, d, d0, d1; - int i; - - destPtr0 = dest->data; - if (destPtr0 == NULL) { - error(errInternal, -1, "dest->data is NULL in Splash::scaleMaskYuXd"); - return; - } - - // Bresenham parameters for y scale - yp = scaledHeight / srcHeight; - yq = scaledHeight % srcHeight; - - // Bresenham parameters for x scale - xp = srcWidth / scaledWidth; - xq = srcWidth % scaledWidth; - - // allocate buffers - lineBuf = (Guchar *)gmalloc(srcWidth); - - // init y scale Bresenham - yt = 0; - - for (y = 0; y < srcHeight; ++y) { - - // y scale Bresenham - if ((yt += yq) >= srcHeight) { - yt -= srcHeight; - yStep = yp + 1; - } else { - yStep = yp; - } - - // read row from image - (*src)(srcData, lineBuf); - - // init x scale Bresenham - xt = 0; - d0 = (255 << 23) / xp; - d1 = (255 << 23) / (xp + 1); - - xx = 0; - for (x = 0; x < scaledWidth; ++x) { - - // x scale Bresenham - if ((xt += xq) >= scaledWidth) { - xt -= scaledWidth; - xStep = xp + 1; - d = d1; - } else { - xStep = xp; - d = d0; - } - - // compute the final pixel - pix = 0; - for (i = 0; i < xStep; ++i) { - pix += lineBuf[xx++]; - } - // (255 * pix) / xStep - pix = (pix * d) >> 23; - - // store the pixel - for (i = 0; i < yStep; ++i) { - destPtr = destPtr0 + i * scaledWidth + x; - *destPtr = (Guchar)pix; - } - } - - destPtr0 += yStep * scaledWidth; - } - - gfree(lineBuf); -} - -void Splash::scaleMaskYuXu(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest) { - Guchar *lineBuf; - Guint pix; - Guchar *destPtr0, *destPtr; - int yp, yq, xp, xq, yt, y, yStep, xt, x, xStep, xx; - int i, j; - - destPtr0 = dest->data; - if (destPtr0 == NULL) { - error(errInternal, -1, "dest->data is NULL in Splash::scaleMaskYuXu"); - return; - } - - // Bresenham parameters for y scale - yp = scaledHeight / srcHeight; - yq = scaledHeight % srcHeight; - - // Bresenham parameters for x scale - xp = scaledWidth / srcWidth; - xq = scaledWidth % srcWidth; - - // allocate buffers - lineBuf = (Guchar *)gmalloc(srcWidth); - - // init y scale Bresenham - yt = 0; - - for (y = 0; y < srcHeight; ++y) { - - // y scale Bresenham - if ((yt += yq) >= srcHeight) { - yt -= srcHeight; - yStep = yp + 1; - } else { - yStep = yp; - } - - // read row from image - (*src)(srcData, lineBuf); - - // init x scale Bresenham - xt = 0; - - xx = 0; - for (x = 0; x < srcWidth; ++x) { - - // x scale Bresenham - if ((xt += xq) >= srcWidth) { - xt -= srcWidth; - xStep = xp + 1; - } else { - xStep = xp; - } - - // compute the final pixel - pix = lineBuf[x] ? 255 : 0; - - // store the pixel - for (i = 0; i < yStep; ++i) { - for (j = 0; j < xStep; ++j) { - destPtr = destPtr0 + i * scaledWidth + xx + j; - *destPtr++ = (Guchar)pix; - } - } - - xx += xStep; - } - - destPtr0 += yStep * scaledWidth; - } - - gfree(lineBuf); -} - -void Splash::blitMask(SplashBitmap *src, int xDest, int yDest, - SplashClipResult clipRes) { - SplashPipe pipe; - Guchar *p; - int w, h, x, y; - - w = src->getWidth(); - h = src->getHeight(); - p = src->getDataPtr(); - if (p == NULL) { - error(errInternal, -1, "src->getDataPtr() is NULL in Splash::blitMask"); - return; - } - if (vectorAntialias && clipRes != splashClipAllInside) { - pipeInit(&pipe, xDest, yDest, state->fillPattern, NULL, - (Guchar)splashRound(state->fillAlpha * 255), gTrue, gFalse); - drawAAPixelInit(); - for (y = 0; y < h; ++y) { - for (x = 0; x < w; ++x) { - pipe.shape = *p++; - drawAAPixel(&pipe, xDest + x, yDest + y); - } - } - } else { - pipeInit(&pipe, xDest, yDest, state->fillPattern, NULL, - (Guchar)splashRound(state->fillAlpha * 255), gTrue, gFalse); - if (clipRes == splashClipAllInside) { - for (y = 0; y < h; ++y) { - pipeSetXY(&pipe, xDest, yDest + y); - for (x = 0; x < w; ++x) { - if (*p) { - pipe.shape = *p; - (this->*pipe.run)(&pipe); - } else { - pipeIncX(&pipe); - } - ++p; - } - } - updateModX(xDest); - updateModX(xDest + w - 1); - updateModY(yDest); - updateModY(yDest + h - 1); - } else { - for (y = 0; y < h; ++y) { - pipeSetXY(&pipe, xDest, yDest + y); - for (x = 0; x < w; ++x) { - if (*p && state->clip->test(xDest + x, yDest + y)) { - pipe.shape = *p; - (this->*pipe.run)(&pipe); - updateModX(xDest + x); - updateModY(yDest + y); - } else { - pipeIncX(&pipe); - } - ++p; - } - } - } - } -} - -SplashError Splash::drawImage(SplashImageSource src, SplashICCTransform tf, void *srcData, - SplashColorMode srcMode, GBool srcAlpha, - int w, int h, SplashCoord *mat, GBool interpolate, - GBool tilingPattern) { - GBool ok; - SplashBitmap *scaledImg; - SplashClipResult clipRes; - GBool minorAxisZero; - int x0, y0, x1, y1, scaledWidth, scaledHeight; - int nComps; - int yp; - - if (debugMode) { - printf("drawImage: srcMode=%d srcAlpha=%d w=%d h=%d mat=[%.2f %.2f %.2f %.2f %.2f %.2f]\n", - srcMode, srcAlpha, w, h, (double)mat[0], (double)mat[1], (double)mat[2], - (double)mat[3], (double)mat[4], (double)mat[5]); - } - - // check color modes - ok = gFalse; // make gcc happy - nComps = 0; // make gcc happy - switch (bitmap->mode) { - case splashModeMono1: - case splashModeMono8: - ok = srcMode == splashModeMono8; - nComps = 1; - break; - case splashModeRGB8: - ok = srcMode == splashModeRGB8; - nComps = 3; - break; - case splashModeXBGR8: - ok = srcMode == splashModeXBGR8; - nComps = 4; - break; - case splashModeBGR8: - ok = srcMode == splashModeBGR8; - nComps = 3; - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - ok = srcMode == splashModeCMYK8; - nComps = 4; - break; - case splashModeDeviceN8: - ok = srcMode == splashModeDeviceN8; - nComps = SPOT_NCOMPS+4; - break; -#endif - default: - ok = gFalse; - break; - } - if (!ok) { - return splashErrModeMismatch; - } - - // check for singular matrix - if (!splashCheckDet(mat[0], mat[1], mat[2], mat[3], 0.000001)) { - return splashErrSingularMatrix; - } - - minorAxisZero = mat[1] == 0 && mat[2] == 0; - - // scaling only - if (mat[0] > 0 && minorAxisZero && mat[3] > 0) { - x0 = imgCoordMungeLower(mat[4]); - y0 = imgCoordMungeLower(mat[5]); - x1 = imgCoordMungeUpper(mat[0] + mat[4]); - y1 = imgCoordMungeUpper(mat[3] + mat[5]); - // make sure narrow images cover at least one pixel - if (x0 == x1) { - ++x1; - } - if (y0 == y1) { - ++y1; - } - clipRes = state->clip->testRect(x0, y0, x1 - 1, y1 - 1); - opClipRes = clipRes; - if (clipRes != splashClipAllOutside) { - scaledWidth = x1 - x0; - scaledHeight = y1 - y0; - yp = h / scaledHeight; - if (yp < 0 || yp > INT_MAX - 1) { - return splashErrBadArg; - } - scaledImg = scaleImage(src, srcData, srcMode, nComps, srcAlpha, w, h, - scaledWidth, scaledHeight, interpolate, tilingPattern); - if (scaledImg == NULL) { - return splashErrBadArg; - } - if (tf != NULL) { - (*tf)(srcData, scaledImg); - } - blitImage(scaledImg, srcAlpha, x0, y0, clipRes); - delete scaledImg; - } - - // scaling plus vertical flip - } else if (mat[0] > 0 && minorAxisZero && mat[3] < 0) { - x0 = imgCoordMungeLower(mat[4]); - y0 = imgCoordMungeLower(mat[3] + mat[5]); - x1 = imgCoordMungeUpper(mat[0] + mat[4]); - y1 = imgCoordMungeUpper(mat[5]); - if (x0 == x1) { - if (mat[4] + mat[0] * 0.5 < x0) { - --x0; - } else { - ++x1; - } - } - if (y0 == y1) { - if (mat[5] + mat[1] * 0.5 < y0) { - --y0; - } else { - ++y1; - } - } - clipRes = state->clip->testRect(x0, y0, x1 - 1, y1 - 1); - opClipRes = clipRes; - if (clipRes != splashClipAllOutside) { - scaledWidth = x1 - x0; - scaledHeight = y1 - y0; - yp = h / scaledHeight; - if (yp < 0 || yp > INT_MAX - 1) { - return splashErrBadArg; - } - scaledImg = scaleImage(src, srcData, srcMode, nComps, srcAlpha, w, h, - scaledWidth, scaledHeight, interpolate, tilingPattern); - if (scaledImg == NULL) { - return splashErrBadArg; - } - if (tf != NULL) { - (*tf)(srcData, scaledImg); - } - vertFlipImage(scaledImg, scaledWidth, scaledHeight, nComps); - blitImage(scaledImg, srcAlpha, x0, y0, clipRes); - delete scaledImg; - } - - // all other cases - } else { - return arbitraryTransformImage(src, tf, srcData, srcMode, nComps, srcAlpha, - w, h, mat, interpolate, tilingPattern); - } - - return splashOk; -} - -SplashError Splash::arbitraryTransformImage(SplashImageSource src, SplashICCTransform tf, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, - int srcWidth, int srcHeight, - SplashCoord *mat, GBool interpolate, - GBool tilingPattern) { - SplashBitmap *scaledImg; - SplashClipResult clipRes, clipRes2; - SplashPipe pipe; - SplashColor pixel; - int scaledWidth, scaledHeight, t0, t1, th; - SplashCoord r00, r01, r10, r11, det, ir00, ir01, ir10, ir11; - SplashCoord vx[4], vy[4]; - int xMin, yMin, xMax, yMax; - ImageSection section[3]; - int nSections; - int y, xa, xb, x, i, xx, yy, yp; - - // compute the four vertices of the target quadrilateral - vx[0] = mat[4]; vy[0] = mat[5]; - vx[1] = mat[2] + mat[4]; vy[1] = mat[3] + mat[5]; - vx[2] = mat[0] + mat[2] + mat[4]; vy[2] = mat[1] + mat[3] + mat[5]; - vx[3] = mat[0] + mat[4]; vy[3] = mat[1] + mat[5]; - - // clipping - xMin = imgCoordMungeLower(vx[0]); - xMax = imgCoordMungeUpper(vx[0]); - yMin = imgCoordMungeLower(vy[0]); - yMax = imgCoordMungeUpper(vy[0]); - for (i = 1; i < 4; ++i) { - t0 = imgCoordMungeLower(vx[i]); - if (t0 < xMin) { - xMin = t0; - } - t0 = imgCoordMungeUpper(vx[i]); - if (t0 > xMax) { - xMax = t0; - } - t1 = imgCoordMungeLower(vy[i]); - if (t1 < yMin) { - yMin = t1; - } - t1 = imgCoordMungeUpper(vy[i]); - if (t1 > yMax) { - yMax = t1; - } - } - clipRes = state->clip->testRect(xMin, yMin, xMax, yMax); - opClipRes = clipRes; - if (clipRes == splashClipAllOutside) { - return splashOk; - } - - // compute the scale factors - if (splashAbs(mat[0]) >= splashAbs(mat[1])) { - scaledWidth = xMax - xMin; - scaledHeight = yMax - yMin; - } else { - scaledWidth = yMax - yMin; - scaledHeight = xMax - xMin; - } - if (scaledHeight <= 1 || scaledWidth <= 1 || tilingPattern) { - if (mat[0] >= 0) { - t0 = imgCoordMungeUpper(mat[0] + mat[4]) - imgCoordMungeLower(mat[4]); - } else { - t0 = imgCoordMungeUpper(mat[4]) - imgCoordMungeLower(mat[0] + mat[4]); - } - if (mat[1] >= 0) { - t1 = imgCoordMungeUpper(mat[1] + mat[5]) - imgCoordMungeLower(mat[5]); - } else { - t1 = imgCoordMungeUpper(mat[5]) - imgCoordMungeLower(mat[1] + mat[5]); - } - scaledWidth = t0 > t1 ? t0 : t1; - if (mat[2] >= 0) { - t0 = imgCoordMungeUpper(mat[2] + mat[4]) - imgCoordMungeLower(mat[4]); - if (splashAbs(mat[1]) >= 1) { - th = imgCoordMungeUpper(mat[2]) - imgCoordMungeLower(mat[0] * mat[3] / mat[1]); - if (th > t0) t0 = th; - } - } else { - t0 = imgCoordMungeUpper(mat[4]) - imgCoordMungeLower(mat[2] + mat[4]); - if (splashAbs(mat[1]) >= 1) { - th = imgCoordMungeUpper(mat[0] * mat[3] / mat[1]) - imgCoordMungeLower(mat[2]); - if (th > t0) t0 = th; - } - } - if (mat[3] >= 0) { - t1 = imgCoordMungeUpper(mat[3] + mat[5]) - imgCoordMungeLower(mat[5]); - if (splashAbs(mat[0]) >= 1) { - th = imgCoordMungeUpper(mat[3]) - imgCoordMungeLower(mat[1] * mat[2] / mat[0]); - if (th > t1) t1 = th; - } - } else { - t1 = imgCoordMungeUpper(mat[5]) - imgCoordMungeLower(mat[3] + mat[5]); - if (splashAbs(mat[0]) >= 1) { - th = imgCoordMungeUpper(mat[1] * mat[2] / mat[0]) - imgCoordMungeLower(mat[3]); - if (th > t1) t1 = th; - } - } - scaledHeight = t0 > t1 ? t0 : t1; - } - if (scaledWidth == 0) { - scaledWidth = 1; - } - if (scaledHeight == 0) { - scaledHeight = 1; - } - - // compute the inverse transform (after scaling) matrix - r00 = mat[0] / scaledWidth; - r01 = mat[1] / scaledWidth; - r10 = mat[2] / scaledHeight; - r11 = mat[3] / scaledHeight; - det = r00 * r11 - r01 * r10; - if (splashAbs(det) < 1e-6) { - // this should be caught by the singular matrix check in drawImage - return splashErrBadArg; - } - ir00 = r11 / det; - ir01 = -r01 / det; - ir10 = -r10 / det; - ir11 = r00 / det; - - // scale the input image - yp = srcHeight / scaledHeight; - if (yp < 0 || yp > INT_MAX - 1) { - return splashErrBadArg; - } - scaledImg = scaleImage(src, srcData, srcMode, nComps, srcAlpha, - srcWidth, srcHeight, scaledWidth, scaledHeight, interpolate); - - if (scaledImg == NULL) { - return splashErrBadArg; - } - - if (tf != NULL) { - (*tf)(srcData, scaledImg); - } - // construct the three sections - i = 0; - if (vy[1] < vy[i]) { - i = 1; - } - if (vy[2] < vy[i]) { - i = 2; - } - if (vy[3] < vy[i]) { - i = 3; - } - // NB: if using fixed point, 0.000001 will be truncated to zero, - // so these two comparisons must be <=, not < - if (splashAbs(vy[i] - vy[(i-1) & 3]) <= 0.000001 && - vy[(i-1) & 3] < vy[(i+1) & 3]) { - i = (i-1) & 3; - } - if (splashAbs(vy[i] - vy[(i+1) & 3]) <= 0.000001) { - section[0].y0 = imgCoordMungeLower(vy[i]); - section[0].y1 = imgCoordMungeUpper(vy[(i+2) & 3]) - 1; - if (vx[i] < vx[(i+1) & 3]) { - section[0].ia0 = i; - section[0].ia1 = (i+3) & 3; - section[0].ib0 = (i+1) & 3; - section[0].ib1 = (i+2) & 3; - } else { - section[0].ia0 = (i+1) & 3; - section[0].ia1 = (i+2) & 3; - section[0].ib0 = i; - section[0].ib1 = (i+3) & 3; - } - nSections = 1; - } else { - section[0].y0 = imgCoordMungeLower(vy[i]); - section[2].y1 = imgCoordMungeUpper(vy[(i+2) & 3]) - 1; - section[0].ia0 = section[0].ib0 = i; - section[2].ia1 = section[2].ib1 = (i+2) & 3; - if (vx[(i+1) & 3] < vx[(i+3) & 3]) { - section[0].ia1 = section[2].ia0 = (i+1) & 3; - section[0].ib1 = section[2].ib0 = (i+3) & 3; - } else { - section[0].ia1 = section[2].ia0 = (i+3) & 3; - section[0].ib1 = section[2].ib0 = (i+1) & 3; - } - if (vy[(i+1) & 3] < vy[(i+3) & 3]) { - section[1].y0 = imgCoordMungeLower(vy[(i+1) & 3]); - section[2].y0 = imgCoordMungeUpper(vy[(i+3) & 3]); - if (vx[(i+1) & 3] < vx[(i+3) & 3]) { - section[1].ia0 = (i+1) & 3; - section[1].ia1 = (i+2) & 3; - section[1].ib0 = i; - section[1].ib1 = (i+3) & 3; - } else { - section[1].ia0 = i; - section[1].ia1 = (i+3) & 3; - section[1].ib0 = (i+1) & 3; - section[1].ib1 = (i+2) & 3; - } - } else { - section[1].y0 = imgCoordMungeLower(vy[(i+3) & 3]); - section[2].y0 = imgCoordMungeUpper(vy[(i+1) & 3]); - if (vx[(i+1) & 3] < vx[(i+3) & 3]) { - section[1].ia0 = i; - section[1].ia1 = (i+1) & 3; - section[1].ib0 = (i+3) & 3; - section[1].ib1 = (i+2) & 3; - } else { - section[1].ia0 = (i+3) & 3; - section[1].ia1 = (i+2) & 3; - section[1].ib0 = i; - section[1].ib1 = (i+1) & 3; - } - } - section[0].y1 = section[1].y0 - 1; - section[1].y1 = section[2].y0 - 1; - nSections = 3; - } - for (i = 0; i < nSections; ++i) { - section[i].xa0 = vx[section[i].ia0]; - section[i].ya0 = vy[section[i].ia0]; - section[i].xa1 = vx[section[i].ia1]; - section[i].ya1 = vy[section[i].ia1]; - section[i].xb0 = vx[section[i].ib0]; - section[i].yb0 = vy[section[i].ib0]; - section[i].xb1 = vx[section[i].ib1]; - section[i].yb1 = vy[section[i].ib1]; - section[i].dxdya = (section[i].xa1 - section[i].xa0) / - (section[i].ya1 - section[i].ya0); - section[i].dxdyb = (section[i].xb1 - section[i].xb0) / - (section[i].yb1 - section[i].yb0); - } - - // initialize the pixel pipe - pipeInit(&pipe, 0, 0, NULL, pixel, - (Guchar)splashRound(state->fillAlpha * 255), - srcAlpha || (vectorAntialias && clipRes != splashClipAllInside), - gFalse); - if (vectorAntialias) { - drawAAPixelInit(); - } - - // make sure narrow images cover at least one pixel - if (nSections == 1) { - if (section[0].y0 == section[0].y1) { - ++section[0].y1; - clipRes = opClipRes = splashClipPartial; - } - } else { - if (section[0].y0 == section[2].y1) { - ++section[1].y1; - clipRes = opClipRes = splashClipPartial; - } - } - - // scan all pixels inside the target region - for (i = 0; i < nSections; ++i) { - for (y = section[i].y0; y <= section[i].y1; ++y) { - xa = imgCoordMungeLower(section[i].xa0 + - ((SplashCoord)y + 0.5 - section[i].ya0) * - section[i].dxdya); - if (unlikely(xa < 0)) - xa = 0; - xb = imgCoordMungeUpper(section[i].xb0 + - ((SplashCoord)y + 0.5 - section[i].yb0) * - section[i].dxdyb); - // make sure narrow images cover at least one pixel - if (xa == xb) { - ++xb; - } - if (clipRes != splashClipAllInside) { - clipRes2 = state->clip->testSpan(xa, xb - 1, y); - } else { - clipRes2 = clipRes; - } - for (x = xa; x < xb; ++x) { - // map (x+0.5, y+0.5) back to the scaled image - xx = splashFloor(((SplashCoord)x + 0.5 - mat[4]) * ir00 + - ((SplashCoord)y + 0.5 - mat[5]) * ir10); - yy = splashFloor(((SplashCoord)x + 0.5 - mat[4]) * ir01 + - ((SplashCoord)y + 0.5 - mat[5]) * ir11); - // xx should always be within bounds, but floating point - // inaccuracy can cause problems - if (xx < 0) { - xx = 0; - } else if (xx >= scaledWidth) { - xx = scaledWidth - 1; - } - if (yy < 0) { - yy = 0; - } else if (yy >= scaledHeight) { - yy = scaledHeight - 1; - } - scaledImg->getPixel(xx, yy, pixel); - if (srcAlpha) { - pipe.shape = scaledImg->alpha[yy * scaledWidth + xx]; - } else { - pipe.shape = 255; - } - if (vectorAntialias && clipRes2 != splashClipAllInside) { - drawAAPixel(&pipe, x, y); - } else { - drawPixel(&pipe, x, y, clipRes2 == splashClipAllInside); - } - } - } - } - - delete scaledImg; - return splashOk; -} - -// determine if a scaled image requires interpolation based on the scale and -// the interpolate flag from the image dictionary -static GBool isImageInterpolationRequired(int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - GBool interpolate) { - if (interpolate || srcWidth == 0 || srcHeight == 0) - return gTrue; - - /* When scale factor is >= 400% we don't interpolate. See bugs #25268, #9860 */ - if (scaledWidth / srcWidth >= 4 || scaledHeight / srcHeight >= 4) - return gFalse; - - return gTrue; -} - -// Scale an image into a SplashBitmap. -SplashBitmap *Splash::scaleImage(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, GBool interpolate, GBool tilingPattern) { - SplashBitmap *dest; - - dest = new SplashBitmap(scaledWidth, scaledHeight, 1, srcMode, srcAlpha, gTrue, bitmap->getSeparationList()); - if (dest->getDataPtr() != NULL && srcHeight > 0 && srcWidth > 0) { - if (scaledHeight < srcHeight) { - if (scaledWidth < srcWidth) { - scaleImageYdXd(src, srcData, srcMode, nComps, srcAlpha, - srcWidth, srcHeight, scaledWidth, scaledHeight, dest); - } else { - scaleImageYdXu(src, srcData, srcMode, nComps, srcAlpha, - srcWidth, srcHeight, scaledWidth, scaledHeight, dest); - } - } else { - if (scaledWidth < srcWidth) { - scaleImageYuXd(src, srcData, srcMode, nComps, srcAlpha, - srcWidth, srcHeight, scaledWidth, scaledHeight, dest); - } else { - if (!tilingPattern && isImageInterpolationRequired(srcWidth, srcHeight, scaledWidth, scaledHeight, interpolate)) { - scaleImageYuXuBilinear(src, srcData, srcMode, nComps, srcAlpha, - srcWidth, srcHeight, scaledWidth, scaledHeight, dest); - } else { - scaleImageYuXu(src, srcData, srcMode, nComps, srcAlpha, - srcWidth, srcHeight, scaledWidth, scaledHeight, dest); - } - } - } - } else { - delete dest; - dest = NULL; - } - return dest; -} - -void Splash::scaleImageYdXd(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest) { - Guchar *lineBuf, *alphaLineBuf; - Guint *pixBuf, *alphaPixBuf; - Guint pix0, pix1, pix2; -#ifdef SPLASH_CMYK - Guint pix3; - Guint pix[SPOT_NCOMPS+4], cp; -#endif - Guint alpha; - Guchar *destPtr, *destAlphaPtr; - int yp, yq, xp, xq, yt, y, yStep, xt, x, xStep, xx, xxa, d, d0, d1; - int i, j; - - // Bresenham parameters for y scale - yp = srcHeight / scaledHeight; - yq = srcHeight % scaledHeight; - - // Bresenham parameters for x scale - xp = srcWidth / scaledWidth; - xq = srcWidth % scaledWidth; - - // allocate buffers - lineBuf = (Guchar *)gmallocn(srcWidth, nComps); - pixBuf = (Guint *)gmallocn(srcWidth, nComps * sizeof(int)); - if (srcAlpha) { - alphaLineBuf = (Guchar *)gmalloc(srcWidth); - alphaPixBuf = (Guint *)gmallocn(srcWidth, sizeof(int)); - } else { - alphaLineBuf = NULL; - alphaPixBuf = NULL; - } - - // init y scale Bresenham - yt = 0; - - destPtr = dest->data; - destAlphaPtr = dest->alpha; - for (y = 0; y < scaledHeight; ++y) { - - // y scale Bresenham - if ((yt += yq) >= scaledHeight) { - yt -= scaledHeight; - yStep = yp + 1; - } else { - yStep = yp; - } - - // read rows from image - memset(pixBuf, 0, srcWidth * nComps * sizeof(int)); - if (srcAlpha) { - memset(alphaPixBuf, 0, srcWidth * sizeof(int)); - } - for (i = 0; i < yStep; ++i) { - (*src)(srcData, lineBuf, alphaLineBuf); - for (j = 0; j < srcWidth * nComps; ++j) { - pixBuf[j] += lineBuf[j]; - } - if (srcAlpha) { - for (j = 0; j < srcWidth; ++j) { - alphaPixBuf[j] += alphaLineBuf[j]; - } - } - } - - // init x scale Bresenham - xt = 0; - d0 = (1 << 23) / (yStep * xp); - d1 = (1 << 23) / (yStep * (xp + 1)); - - xx = xxa = 0; - for (x = 0; x < scaledWidth; ++x) { - - // x scale Bresenham - if ((xt += xq) >= scaledWidth) { - xt -= scaledWidth; - xStep = xp + 1; - d = d1; - } else { - xStep = xp; - d = d0; - } - - switch (srcMode) { - - case splashModeMono8: - - // compute the final pixel - pix0 = 0; - for (i = 0; i < xStep; ++i) { - pix0 += pixBuf[xx++]; - } - // pix / xStep * yStep - pix0 = (pix0 * d) >> 23; - - // store the pixel - *destPtr++ = (Guchar)pix0; - break; - - case splashModeRGB8: - - // compute the final pixel - pix0 = pix1 = pix2 = 0; - for (i = 0; i < xStep; ++i) { - pix0 += pixBuf[xx]; - pix1 += pixBuf[xx+1]; - pix2 += pixBuf[xx+2]; - xx += 3; - } - // pix / xStep * yStep - pix0 = (pix0 * d) >> 23; - pix1 = (pix1 * d) >> 23; - pix2 = (pix2 * d) >> 23; - - // store the pixel - *destPtr++ = (Guchar)pix0; - *destPtr++ = (Guchar)pix1; - *destPtr++ = (Guchar)pix2; - break; - - case splashModeXBGR8: - - // compute the final pixel - pix0 = pix1 = pix2 = 0; - for (i = 0; i < xStep; ++i) { - pix0 += pixBuf[xx]; - pix1 += pixBuf[xx+1]; - pix2 += pixBuf[xx+2]; - xx += 4; - } - // pix / xStep * yStep - pix0 = (pix0 * d) >> 23; - pix1 = (pix1 * d) >> 23; - pix2 = (pix2 * d) >> 23; - - // store the pixel - *destPtr++ = (Guchar)pix2; - *destPtr++ = (Guchar)pix1; - *destPtr++ = (Guchar)pix0; - *destPtr++ = (Guchar)255; - break; - - case splashModeBGR8: - - // compute the final pixel - pix0 = pix1 = pix2 = 0; - for (i = 0; i < xStep; ++i) { - pix0 += pixBuf[xx]; - pix1 += pixBuf[xx+1]; - pix2 += pixBuf[xx+2]; - xx += 3; - } - // pix / xStep * yStep - pix0 = (pix0 * d) >> 23; - pix1 = (pix1 * d) >> 23; - pix2 = (pix2 * d) >> 23; - - // store the pixel - *destPtr++ = (Guchar)pix2; - *destPtr++ = (Guchar)pix1; - *destPtr++ = (Guchar)pix0; - break; - -#ifdef SPLASH_CMYK - case splashModeCMYK8: - - // compute the final pixel - pix0 = pix1 = pix2 = pix3 = 0; - for (i = 0; i < xStep; ++i) { - pix0 += pixBuf[xx]; - pix1 += pixBuf[xx+1]; - pix2 += pixBuf[xx+2]; - pix3 += pixBuf[xx+3]; - xx += 4; - } - // pix / xStep * yStep - pix0 = (pix0 * d) >> 23; - pix1 = (pix1 * d) >> 23; - pix2 = (pix2 * d) >> 23; - pix3 = (pix3 * d) >> 23; - - // store the pixel - *destPtr++ = (Guchar)pix0; - *destPtr++ = (Guchar)pix1; - *destPtr++ = (Guchar)pix2; - *destPtr++ = (Guchar)pix3; - break; - case splashModeDeviceN8: - - // compute the final pixel - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - pix[cp] = 0; - for (i = 0; i < xStep; ++i) { - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) { - pix[cp] += pixBuf[xx + cp]; - } - xx += (SPOT_NCOMPS+4); - } - // pix / xStep * yStep - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - pix[cp] = (pix[cp] * d) >> 23; - - // store the pixel - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - *destPtr++ = (Guchar)pix[cp]; - break; -#endif - - - case splashModeMono1: // mono1 is not allowed - default: - break; - } - - // process alpha - if (srcAlpha) { - alpha = 0; - for (i = 0; i < xStep; ++i, ++xxa) { - alpha += alphaPixBuf[xxa]; - } - // alpha / xStep * yStep - alpha = (alpha * d) >> 23; - *destAlphaPtr++ = (Guchar)alpha; - } - } - } - - gfree(alphaPixBuf); - gfree(alphaLineBuf); - gfree(pixBuf); - gfree(lineBuf); -} - -void Splash::scaleImageYdXu(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest) { - Guchar *lineBuf, *alphaLineBuf; - Guint *pixBuf, *alphaPixBuf; - Guint pix[splashMaxColorComps]; - Guint alpha; - Guchar *destPtr, *destAlphaPtr; - int yp, yq, xp, xq, yt, y, yStep, xt, x, xStep, d; - int i, j; - - // Bresenham parameters for y scale - yp = srcHeight / scaledHeight; - yq = srcHeight % scaledHeight; - - // Bresenham parameters for x scale - xp = scaledWidth / srcWidth; - xq = scaledWidth % srcWidth; - - // allocate buffers - lineBuf = (Guchar *)gmallocn(srcWidth, nComps); - pixBuf = (Guint *)gmallocn(srcWidth, nComps * sizeof(int)); - if (srcAlpha) { - alphaLineBuf = (Guchar *)gmalloc(srcWidth); - alphaPixBuf = (Guint *)gmallocn(srcWidth, sizeof(int)); - } else { - alphaLineBuf = NULL; - alphaPixBuf = NULL; - } - - // init y scale Bresenham - yt = 0; - - destPtr = dest->data; - destAlphaPtr = dest->alpha; - for (y = 0; y < scaledHeight; ++y) { - - // y scale Bresenham - if ((yt += yq) >= scaledHeight) { - yt -= scaledHeight; - yStep = yp + 1; - } else { - yStep = yp; - } - - // read rows from image - memset(pixBuf, 0, srcWidth * nComps * sizeof(int)); - if (srcAlpha) { - memset(alphaPixBuf, 0, srcWidth * sizeof(int)); - } - for (i = 0; i < yStep; ++i) { - (*src)(srcData, lineBuf, alphaLineBuf); - for (j = 0; j < srcWidth * nComps; ++j) { - pixBuf[j] += lineBuf[j]; - } - if (srcAlpha) { - for (j = 0; j < srcWidth; ++j) { - alphaPixBuf[j] += alphaLineBuf[j]; - } - } - } - - // init x scale Bresenham - xt = 0; - d = (1 << 23) / yStep; - - for (x = 0; x < srcWidth; ++x) { - - // x scale Bresenham - if ((xt += xq) >= srcWidth) { - xt -= srcWidth; - xStep = xp + 1; - } else { - xStep = xp; - } - - // compute the final pixel - for (i = 0; i < nComps; ++i) { - // pixBuf[] / yStep - pix[i] = (pixBuf[x * nComps + i] * d) >> 23; - } - - // store the pixel - switch (srcMode) { - case splashModeMono1: // mono1 is not allowed - break; - case splashModeMono8: - for (i = 0; i < xStep; ++i) { - *destPtr++ = (Guchar)pix[0]; - } - break; - case splashModeRGB8: - for (i = 0; i < xStep; ++i) { - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[2]; - } - break; - case splashModeXBGR8: - for (i = 0; i < xStep; ++i) { - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)255; - } - break; - case splashModeBGR8: - for (i = 0; i < xStep; ++i) { - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[0]; - } - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - for (i = 0; i < xStep; ++i) { - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[3]; - } - break; - case splashModeDeviceN8: - for (i = 0; i < xStep; ++i) { - for (int cp = 0; cp < SPOT_NCOMPS+4; cp++) - *destPtr++ = (Guchar)pix[cp]; - } - break; -#endif - } - - // process alpha - if (srcAlpha) { - // alphaPixBuf[] / yStep - alpha = (alphaPixBuf[x] * d) >> 23; - for (i = 0; i < xStep; ++i) { - *destAlphaPtr++ = (Guchar)alpha; - } - } - } - } - - gfree(alphaPixBuf); - gfree(alphaLineBuf); - gfree(pixBuf); - gfree(lineBuf); -} - -void Splash::scaleImageYuXd(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest) { - Guchar *lineBuf, *alphaLineBuf; - Guint pix[splashMaxColorComps]; - Guint alpha; - Guchar *destPtr0, *destPtr, *destAlphaPtr0, *destAlphaPtr; - int yp, yq, xp, xq, yt, y, yStep, xt, x, xStep, xx, xxa, d, d0, d1; - int i, j; - - // Bresenham parameters for y scale - yp = scaledHeight / srcHeight; - yq = scaledHeight % srcHeight; - - // Bresenham parameters for x scale - xp = srcWidth / scaledWidth; - xq = srcWidth % scaledWidth; - - // allocate buffers - lineBuf = (Guchar *)gmallocn_checkoverflow(srcWidth, nComps); - if (unlikely(!lineBuf)) - return; - if (srcAlpha) { - alphaLineBuf = (Guchar *)gmalloc(srcWidth); - } else { - alphaLineBuf = NULL; - } - - // init y scale Bresenham - yt = 0; - - destPtr0 = dest->data; - destAlphaPtr0 = dest->alpha; - for (y = 0; y < srcHeight; ++y) { - - // y scale Bresenham - if ((yt += yq) >= srcHeight) { - yt -= srcHeight; - yStep = yp + 1; - } else { - yStep = yp; - } - - // read row from image - (*src)(srcData, lineBuf, alphaLineBuf); - - // init x scale Bresenham - xt = 0; - d0 = (1 << 23) / xp; - d1 = (1 << 23) / (xp + 1); - - xx = xxa = 0; - for (x = 0; x < scaledWidth; ++x) { - - // x scale Bresenham - if ((xt += xq) >= scaledWidth) { - xt -= scaledWidth; - xStep = xp + 1; - d = d1; - } else { - xStep = xp; - d = d0; - } - - // compute the final pixel - for (i = 0; i < nComps; ++i) { - pix[i] = 0; - } - for (i = 0; i < xStep; ++i) { - for (j = 0; j < nComps; ++j, ++xx) { - pix[j] += lineBuf[xx]; - } - } - for (i = 0; i < nComps; ++i) { - // pix[] / xStep - pix[i] = (pix[i] * d) >> 23; - } - - // store the pixel - switch (srcMode) { - case splashModeMono1: // mono1 is not allowed - break; - case splashModeMono8: - for (i = 0; i < yStep; ++i) { - destPtr = destPtr0 + (i * scaledWidth + x) * nComps; - *destPtr++ = (Guchar)pix[0]; - } - break; - case splashModeRGB8: - for (i = 0; i < yStep; ++i) { - destPtr = destPtr0 + (i * scaledWidth + x) * nComps; - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[2]; - } - break; - case splashModeXBGR8: - for (i = 0; i < yStep; ++i) { - destPtr = destPtr0 + (i * scaledWidth + x) * nComps; - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)255; - } - break; - case splashModeBGR8: - for (i = 0; i < yStep; ++i) { - destPtr = destPtr0 + (i * scaledWidth + x) * nComps; - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[0]; - } - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - for (i = 0; i < yStep; ++i) { - destPtr = destPtr0 + (i * scaledWidth + x) * nComps; - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[3]; - } - break; - case splashModeDeviceN8: - for (i = 0; i < yStep; ++i) { - destPtr = destPtr0 + (i * scaledWidth + x) * nComps; - for (int cp = 0; cp < SPOT_NCOMPS+4; cp++) - *destPtr++ = (Guchar)pix[cp]; - } - break; -#endif - } - - // process alpha - if (srcAlpha) { - alpha = 0; - for (i = 0; i < xStep; ++i, ++xxa) { - alpha += alphaLineBuf[xxa]; - } - // alpha / xStep - alpha = (alpha * d) >> 23; - for (i = 0; i < yStep; ++i) { - destAlphaPtr = destAlphaPtr0 + i * scaledWidth + x; - *destAlphaPtr = (Guchar)alpha; - } - } - } - - destPtr0 += yStep * scaledWidth * nComps; - if (srcAlpha) { - destAlphaPtr0 += yStep * scaledWidth; - } - } - - gfree(alphaLineBuf); - gfree(lineBuf); -} - -void Splash::scaleImageYuXu(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest) { - Guchar *lineBuf, *alphaLineBuf; - Guint pix[splashMaxColorComps]; - Guint alpha; - Guchar *destPtr0, *destPtr, *destAlphaPtr0, *destAlphaPtr; - int yp, yq, xp, xq, yt, y, yStep, xt, x, xStep, xx; - int i, j; - - // Bresenham parameters for y scale - yp = scaledHeight / srcHeight; - yq = scaledHeight % srcHeight; - - // Bresenham parameters for x scale - xp = scaledWidth / srcWidth; - xq = scaledWidth % srcWidth; - - // allocate buffers - lineBuf = (Guchar *)gmallocn(srcWidth, nComps); - if (srcAlpha) { - alphaLineBuf = (Guchar *)gmalloc(srcWidth); - } else { - alphaLineBuf = NULL; - } - - // init y scale Bresenham - yt = 0; - - destPtr0 = dest->data; - destAlphaPtr0 = dest->alpha; - for (y = 0; y < srcHeight; ++y) { - - // y scale Bresenham - if ((yt += yq) >= srcHeight) { - yt -= srcHeight; - yStep = yp + 1; - } else { - yStep = yp; - } - - // read row from image - (*src)(srcData, lineBuf, alphaLineBuf); - - // init x scale Bresenham - xt = 0; - - xx = 0; - for (x = 0; x < srcWidth; ++x) { - - // x scale Bresenham - if ((xt += xq) >= srcWidth) { - xt -= srcWidth; - xStep = xp + 1; - } else { - xStep = xp; - } - - // compute the final pixel - for (i = 0; i < nComps; ++i) { - pix[i] = lineBuf[x * nComps + i]; - } - - // store the pixel - switch (srcMode) { - case splashModeMono1: // mono1 is not allowed - break; - case splashModeMono8: - for (i = 0; i < yStep; ++i) { - for (j = 0; j < xStep; ++j) { - destPtr = destPtr0 + (i * scaledWidth + xx + j) * nComps; - *destPtr++ = (Guchar)pix[0]; - } - } - break; - case splashModeRGB8: - for (i = 0; i < yStep; ++i) { - for (j = 0; j < xStep; ++j) { - destPtr = destPtr0 + (i * scaledWidth + xx + j) * nComps; - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[2]; - } - } - break; - case splashModeXBGR8: - for (i = 0; i < yStep; ++i) { - for (j = 0; j < xStep; ++j) { - destPtr = destPtr0 + (i * scaledWidth + xx + j) * nComps; - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)255; - } - } - break; - case splashModeBGR8: - for (i = 0; i < yStep; ++i) { - for (j = 0; j < xStep; ++j) { - destPtr = destPtr0 + (i * scaledWidth + xx + j) * nComps; - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[0]; - } - } - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - for (i = 0; i < yStep; ++i) { - for (j = 0; j < xStep; ++j) { - destPtr = destPtr0 + (i * scaledWidth + xx + j) * nComps; - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[3]; - } - } - break; - case splashModeDeviceN8: - for (i = 0; i < yStep; ++i) { - for (j = 0; j < xStep; ++j) { - destPtr = destPtr0 + (i * scaledWidth + xx + j) * nComps; - for (int cp = 0; cp < SPOT_NCOMPS+4; cp++) - *destPtr++ = (Guchar)pix[cp]; - } - } - break; -#endif - } - - // process alpha - if (srcAlpha) { - alpha = alphaLineBuf[x]; - for (i = 0; i < yStep; ++i) { - for (j = 0; j < xStep; ++j) { - destAlphaPtr = destAlphaPtr0 + i * scaledWidth + xx + j; - *destAlphaPtr = (Guchar)alpha; - } - } - } - - xx += xStep; - } - - destPtr0 += yStep * scaledWidth * nComps; - if (srcAlpha) { - destAlphaPtr0 += yStep * scaledWidth; - } - } - - gfree(alphaLineBuf); - gfree(lineBuf); -} - -// expand source row to scaledWidth using linear interpolation -static void expandRow(Guchar *srcBuf, Guchar *dstBuf, int srcWidth, int scaledWidth, int nComps) -{ - double xStep = (double)srcWidth/scaledWidth; - double xSrc = 0.0; - double xFrac, xInt; - int p; - - // pad the source with an extra pixel equal to the last pixel - // so that when xStep is inside the last pixel we still have two - // pixels to interpolate between. - for (int i = 0; i < nComps; i++) - srcBuf[srcWidth*nComps + i] = srcBuf[(srcWidth-1)*nComps + i]; - - for (int x = 0; x < scaledWidth; x++) { - xFrac = modf(xSrc, &xInt); - p = (int)xInt; - for (int c = 0; c < nComps; c++) { - dstBuf[nComps*x + c] = srcBuf[nComps*p + c]*(1.0 - xFrac) + srcBuf[nComps*(p+1) + c]*xFrac; - } - xSrc += xStep; - } -} - -// Scale up image using bilinear interpolation -void Splash::scaleImageYuXuBilinear(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest) { - Guchar *srcBuf, *lineBuf1, *lineBuf2, *alphaSrcBuf, *alphaLineBuf1, *alphaLineBuf2; - Guint pix[splashMaxColorComps]; - Guchar *destPtr0, *destPtr, *destAlphaPtr0, *destAlphaPtr; - int i; - - if (srcWidth < 1 || srcHeight < 1) - return; - - // allocate buffers - srcBuf = (Guchar *)gmallocn(srcWidth+1, nComps); // + 1 pixel of padding - lineBuf1 = (Guchar *)gmallocn(scaledWidth, nComps); - lineBuf2 = (Guchar *)gmallocn(scaledWidth, nComps); - if (srcAlpha) { - alphaSrcBuf = (Guchar *)gmalloc(srcWidth+1); // + 1 pixel of padding - alphaLineBuf1 = (Guchar *)gmalloc(scaledWidth); - alphaLineBuf2 = (Guchar *)gmalloc(scaledWidth); - } else { - alphaSrcBuf = NULL; - alphaLineBuf1 = NULL; - alphaLineBuf2 = NULL; - } - - double ySrc = 0.0; - double yStep = (double)srcHeight/scaledHeight; - double yFrac, yInt; - int currentSrcRow = -1; - (*src)(srcData, srcBuf, alphaSrcBuf); - expandRow(srcBuf, lineBuf2, srcWidth, scaledWidth, nComps); - if (srcAlpha) - expandRow(alphaSrcBuf, alphaLineBuf2, srcWidth, scaledWidth, 1); - - destPtr0 = dest->data; - destAlphaPtr0 = dest->alpha; - for (int y = 0; y < scaledHeight; y++) { - yFrac = modf(ySrc, &yInt); - if ((int)yInt > currentSrcRow) { - currentSrcRow++; - // Copy line2 data to line1 and get next line2 data. - // If line2 already contains the last source row we don't touch it. - // This effectively adds an extra row of padding for interpolating the - // last source row with. - memcpy(lineBuf1, lineBuf2, scaledWidth * nComps); - if (srcAlpha) - memcpy(alphaLineBuf1, alphaLineBuf2, scaledWidth); - if (currentSrcRow < srcHeight) { - (*src)(srcData, srcBuf, alphaSrcBuf); - expandRow(srcBuf, lineBuf2, srcWidth, scaledWidth, nComps); - if (srcAlpha) - expandRow(alphaSrcBuf, alphaLineBuf2, srcWidth, scaledWidth, 1); - } - } - - // write row y using linear interpolation on lineBuf1 and lineBuf2 - for (int x = 0; x < scaledWidth; ++x) { - // compute the final pixel - for (i = 0; i < nComps; ++i) { - pix[i] = lineBuf1[x*nComps + i]*(1.0 - yFrac) + lineBuf2[x*nComps + i]*yFrac; - } - - // store the pixel - destPtr = destPtr0 + (y * scaledWidth + x) * nComps; - switch (srcMode) { - case splashModeMono1: // mono1 is not allowed - break; - case splashModeMono8: - *destPtr++ = (Guchar)pix[0]; - break; - case splashModeRGB8: - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[2]; - break; - case splashModeXBGR8: - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)255; - break; - case splashModeBGR8: - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[0]; - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - *destPtr++ = (Guchar)pix[0]; - *destPtr++ = (Guchar)pix[1]; - *destPtr++ = (Guchar)pix[2]; - *destPtr++ = (Guchar)pix[3]; - break; - case splashModeDeviceN8: - for (int cp = 0; cp < SPOT_NCOMPS+4; cp++) - *destPtr++ = (Guchar)pix[cp]; - break; -#endif - } - - // process alpha - if (srcAlpha) { - destAlphaPtr = destAlphaPtr0 + y*scaledWidth + x; - *destAlphaPtr = alphaLineBuf1[x]*(1.0 - yFrac) + alphaLineBuf2[x]*yFrac; - } - } - - ySrc += yStep; - } - - gfree(alphaSrcBuf); - gfree(alphaLineBuf1); - gfree(alphaLineBuf2); - gfree(srcBuf); - gfree(lineBuf1); - gfree(lineBuf2); -} - -void Splash::vertFlipImage(SplashBitmap *img, int width, int height, - int nComps) { - Guchar *lineBuf; - Guchar *p0, *p1; - int w; - - if (unlikely(img->data == NULL)) { - error(errInternal, -1, "img->data is NULL in Splash::vertFlipImage"); - return; - } - - w = width * nComps; - lineBuf = (Guchar *)gmalloc(w); - for (p0 = img->data, p1 = img->data + (height - 1) * w; - p0 < p1; - p0 += w, p1 -= w) { - memcpy(lineBuf, p0, w); - memcpy(p0, p1, w); - memcpy(p1, lineBuf, w); - } - if (img->alpha) { - for (p0 = img->alpha, p1 = img->alpha + (height - 1) * width; - p0 < p1; - p0 += width, p1 -= width) { - memcpy(lineBuf, p0, width); - memcpy(p0, p1, width); - memcpy(p1, lineBuf, width); - } - } - gfree(lineBuf); -} - -void Splash::blitImage(SplashBitmap *src, GBool srcAlpha, int xDest, int yDest) { - SplashClipResult clipRes = state->clip->testRect(xDest, yDest, xDest + src->getWidth() - 1, yDest + src->getHeight() - 1); - if (clipRes != splashClipAllOutside) { - blitImage(src, srcAlpha, xDest, yDest, clipRes); - } -} - -void Splash::blitImage(SplashBitmap *src, GBool srcAlpha, int xDest, int yDest, - SplashClipResult clipRes) { - SplashPipe pipe; - SplashColor pixel; - Guchar *ap; - int w, h, x0, y0, x1, y1, x, y; - - // split the image into clipped and unclipped regions - w = src->getWidth(); - h = src->getHeight(); - if (clipRes == splashClipAllInside) { - x0 = 0; - y0 = 0; - x1 = w; - y1 = h; - } else { - if (state->clip->getNumPaths()) { - x0 = x1 = w; - y0 = y1 = h; - } else { - if ((x0 = splashCeil(state->clip->getXMin()) - xDest) < 0) { - x0 = 0; - } - if ((y0 = splashCeil(state->clip->getYMin()) - yDest) < 0) { - y0 = 0; - } - if ((x1 = splashFloor(state->clip->getXMax()) - xDest) > w) { - x1 = w; - } - if (x1 < x0) { - x1 = x0; - } - if ((y1 = splashFloor(state->clip->getYMax()) - yDest) > h) { - y1 = h; - } - if (y1 < y0) { - y1 = y0; - } - } - } - - // draw the unclipped region - if (x0 < w && y0 < h && x0 < x1 && y0 < y1) { - pipeInit(&pipe, xDest + x0, yDest + y0, NULL, pixel, - (Guchar)splashRound(state->fillAlpha * 255), srcAlpha, gFalse); - if (srcAlpha) { - for (y = y0; y < y1; ++y) { - pipeSetXY(&pipe, xDest + x0, yDest + y); - ap = src->getAlphaPtr() + y * w + x0; - for (x = x0; x < x1; ++x) { - src->getPixel(x, y, pixel); - pipe.shape = *ap++; - (this->*pipe.run)(&pipe); - } - } - } else { - for (y = y0; y < y1; ++y) { - pipeSetXY(&pipe, xDest + x0, yDest + y); - for (x = x0; x < x1; ++x) { - src->getPixel(x, y, pixel); - (this->*pipe.run)(&pipe); - } - } - } - updateModX(xDest + x0); - updateModX(xDest + x1 - 1); - updateModY(yDest + y0); - updateModY(yDest + y1 - 1); - } - - // draw the clipped regions - if (y0 > 0) { - blitImageClipped(src, srcAlpha, 0, 0, xDest, yDest, w, y0); - } - if (y1 < h) { - blitImageClipped(src, srcAlpha, 0, y1, xDest, yDest + y1, w, h - y1); - } - if (x0 > 0 && y0 < y1) { - blitImageClipped(src, srcAlpha, 0, y0, xDest, yDest + y0, x0, y1 - y0); - } - if (x1 < w && y0 < y1) { - blitImageClipped(src, srcAlpha, x1, y0, xDest + x1, yDest + y0, - w - x1, y1 - y0); - } -} - -void Splash::blitImageClipped(SplashBitmap *src, GBool srcAlpha, - int xSrc, int ySrc, int xDest, int yDest, - int w, int h) { - SplashPipe pipe; - SplashColor pixel; - Guchar *ap; - int x, y; - - if (vectorAntialias) { - pipeInit(&pipe, xDest, yDest, NULL, pixel, - (Guchar)splashRound(state->fillAlpha * 255), gTrue, gFalse); - drawAAPixelInit(); - if (srcAlpha) { - for (y = 0; y < h; ++y) { - ap = src->getAlphaPtr() + (ySrc + y) * src->getWidth() + xSrc; - for (x = 0; x < w; ++x) { - src->getPixel(xSrc + x, ySrc + y, pixel); - pipe.shape = *ap++; - drawAAPixel(&pipe, xDest + x, yDest + y); - } - } - } else { - for (y = 0; y < h; ++y) { - for (x = 0; x < w; ++x) { - src->getPixel(xSrc + x, ySrc + y, pixel); - pipe.shape = 255; - drawAAPixel(&pipe, xDest + x, yDest + y); - } - } - } - } else { - pipeInit(&pipe, xDest, yDest, NULL, pixel, - (Guchar)splashRound(state->fillAlpha * 255), srcAlpha, gFalse); - if (srcAlpha) { - for (y = 0; y < h; ++y) { - ap = src->getAlphaPtr() + (ySrc + y) * src->getWidth() + xSrc; - pipeSetXY(&pipe, xDest, yDest + y); - for (x = 0; x < w; ++x) { - if (state->clip->test(xDest + x, yDest + y)) { - src->getPixel(xSrc + x, ySrc + y, pixel); - pipe.shape = *ap++; - (this->*pipe.run)(&pipe); - updateModX(xDest + x); - updateModY(yDest + y); - } else { - pipeIncX(&pipe); - ++ap; - } - } - } - } else { - for (y = 0; y < h; ++y) { - pipeSetXY(&pipe, xDest, yDest + y); - for (x = 0; x < w; ++x) { - if (state->clip->test(xDest + x, yDest + y)) { - src->getPixel(xSrc + x, ySrc + y, pixel); - (this->*pipe.run)(&pipe); - updateModX(xDest + x); - updateModY(yDest + y); - } else { - pipeIncX(&pipe); - } - } - } - } - } -} - -SplashError Splash::composite(SplashBitmap *src, int xSrc, int ySrc, - int xDest, int yDest, int w, int h, - GBool noClip, GBool nonIsolated, - GBool knockout, SplashCoord knockoutOpacity) { - SplashPipe pipe; - SplashColor pixel; - Guchar alpha; - Guchar *ap; - int x, y; - - if (src->mode != bitmap->mode) { - return splashErrModeMismatch; - } - - if (unlikely(!bitmap->data)) { - return splashErrZeroImage; - } - - if(src->getSeparationList()->getLength() > bitmap->getSeparationList()->getLength()) { - for (x = bitmap->getSeparationList()->getLength(); x < src->getSeparationList()->getLength(); x++) - bitmap->getSeparationList()->append(((GfxSeparationColorSpace *)src->getSeparationList()->get(x))->copy()); - } - if (src->alpha) { - pipeInit(&pipe, xDest, yDest, NULL, pixel, - (Guchar)splashRound(state->fillAlpha * 255), gTrue, nonIsolated, - knockout, (Guchar)splashRound(knockoutOpacity * 255)); - if (noClip) { - for (y = 0; y < h; ++y) { - pipeSetXY(&pipe, xDest, yDest + y); - ap = src->getAlphaPtr() + (ySrc + y) * src->getWidth() + xSrc; - for (x = 0; x < w; ++x) { - src->getPixel(xSrc + x, ySrc + y, pixel); - alpha = *ap++; - // this uses shape instead of alpha, which isn't technically - // correct, but works out the same - pipe.shape = alpha; - (this->*pipe.run)(&pipe); - } - } - updateModX(xDest); - updateModX(xDest + w - 1); - updateModY(yDest); - updateModY(yDest + h - 1); - } else { - for (y = 0; y < h; ++y) { - pipeSetXY(&pipe, xDest, yDest + y); - ap = src->getAlphaPtr() + (ySrc + y) * src->getWidth() + xSrc; - for (x = 0; x < w; ++x) { - src->getPixel(xSrc + x, ySrc + y, pixel); - alpha = *ap++; - if (state->clip->test(xDest + x, yDest + y)) { - // this uses shape instead of alpha, which isn't technically - // correct, but works out the same - pipe.shape = alpha; - (this->*pipe.run)(&pipe); - updateModX(xDest + x); - updateModY(yDest + y); - } else { - pipeIncX(&pipe); - } - } - } - } - } else { - pipeInit(&pipe, xDest, yDest, NULL, pixel, - (Guchar)splashRound(state->fillAlpha * 255), gFalse, nonIsolated); - if (noClip) { - for (y = 0; y < h; ++y) { - pipeSetXY(&pipe, xDest, yDest + y); - for (x = 0; x < w; ++x) { - src->getPixel(xSrc + x, ySrc + y, pixel); - (this->*pipe.run)(&pipe); - } - } - updateModX(xDest); - updateModX(xDest + w - 1); - updateModY(yDest); - updateModY(yDest + h - 1); - } else { - for (y = 0; y < h; ++y) { - pipeSetXY(&pipe, xDest, yDest + y); - for (x = 0; x < w; ++x) { - src->getPixel(xSrc + x, ySrc + y, pixel); - if (state->clip->test(xDest + x, yDest + y)) { - (this->*pipe.run)(&pipe); - updateModX(xDest + x); - updateModY(yDest + y); - } else { - pipeIncX(&pipe); - } - } - } - } - } - - return splashOk; -} - -void Splash::compositeBackground(SplashColorPtr color) { - SplashColorPtr p; - Guchar *q; - Guchar alpha, alpha1, c, color0, color1, color2; -#ifdef SPLASH_CMYK - Guchar color3; - Guchar colorsp[SPOT_NCOMPS+4], cp; -#endif - int x, y, mask; - - if (unlikely(bitmap->alpha == NULL)) { - error(errInternal, -1, "bitmap->alpha is NULL in Splash::compositeBackground"); - return; - } - - switch (bitmap->mode) { - case splashModeMono1: - color0 = color[0]; - for (y = 0; y < bitmap->height; ++y) { - p = &bitmap->data[y * bitmap->rowSize]; - q = &bitmap->alpha[y * bitmap->width]; - mask = 0x80; - for (x = 0; x < bitmap->width; ++x) { - alpha = *q++; - alpha1 = 255 - alpha; - c = (*p & mask) ? 0xff : 0x00; - c = div255(alpha1 * color0 + alpha * c); - if (c & 0x80) { - *p |= mask; - } else { - *p &= ~mask; - } - if (!(mask >>= 1)) { - mask = 0x80; - ++p; - } - } - } - break; - case splashModeMono8: - color0 = color[0]; - for (y = 0; y < bitmap->height; ++y) { - p = &bitmap->data[y * bitmap->rowSize]; - q = &bitmap->alpha[y * bitmap->width]; - for (x = 0; x < bitmap->width; ++x) { - alpha = *q++; - alpha1 = 255 - alpha; - p[0] = div255(alpha1 * color0 + alpha * p[0]); - ++p; - } - } - break; - case splashModeRGB8: - case splashModeBGR8: - color0 = color[0]; - color1 = color[1]; - color2 = color[2]; - for (y = 0; y < bitmap->height; ++y) { - p = &bitmap->data[y * bitmap->rowSize]; - q = &bitmap->alpha[y * bitmap->width]; - for (x = 0; x < bitmap->width; ++x) { - alpha = *q++; - if (alpha == 0) - { - p[0] = color0; - p[1] = color1; - p[2] = color2; - } - else if (alpha != 255) - { - alpha1 = 255 - alpha; - p[0] = div255(alpha1 * color0 + alpha * p[0]); - p[1] = div255(alpha1 * color1 + alpha * p[1]); - p[2] = div255(alpha1 * color2 + alpha * p[2]); - } - p += 3; - } - } - break; - case splashModeXBGR8: - color0 = color[0]; - color1 = color[1]; - color2 = color[2]; - for (y = 0; y < bitmap->height; ++y) { - p = &bitmap->data[y * bitmap->rowSize]; - q = &bitmap->alpha[y * bitmap->width]; - for (x = 0; x < bitmap->width; ++x) { - alpha = *q++; - if (alpha == 0) - { - p[0] = color0; - p[1] = color1; - p[2] = color2; - } - else if (alpha != 255) - { - alpha1 = 255 - alpha; - p[0] = div255(alpha1 * color0 + alpha * p[0]); - p[1] = div255(alpha1 * color1 + alpha * p[1]); - p[2] = div255(alpha1 * color2 + alpha * p[2]); - } - p[3] = 255; - p += 4; - } - } - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - color0 = color[0]; - color1 = color[1]; - color2 = color[2]; - color3 = color[3]; - for (y = 0; y < bitmap->height; ++y) { - p = &bitmap->data[y * bitmap->rowSize]; - q = &bitmap->alpha[y * bitmap->width]; - for (x = 0; x < bitmap->width; ++x) { - alpha = *q++; - if (alpha == 0) - { - p[0] = color0; - p[1] = color1; - p[2] = color2; - p[3] = color3; - } - else if (alpha != 255) - { - alpha1 = 255 - alpha; - p[0] = div255(alpha1 * color0 + alpha * p[0]); - p[1] = div255(alpha1 * color1 + alpha * p[1]); - p[2] = div255(alpha1 * color2 + alpha * p[2]); - p[3] = div255(alpha1 * color3 + alpha * p[3]); - } - p += 4; - } - } - break; - case splashModeDeviceN8: - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - colorsp[cp] = color[cp]; - for (y = 0; y < bitmap->height; ++y) { - p = &bitmap->data[y * bitmap->rowSize]; - q = &bitmap->alpha[y * bitmap->width]; - for (x = 0; x < bitmap->width; ++x) { - alpha = *q++; - if (alpha == 0) - { - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - p[cp] = colorsp[cp]; - } - else if (alpha != 255) - { - alpha1 = 255 - alpha; - for (cp = 0; cp < SPOT_NCOMPS+4; cp++) - p[cp] = div255(alpha1 * colorsp[cp] + alpha * p[cp]); - } - p += (SPOT_NCOMPS+4); - } - } - break; -#endif - } - memset(bitmap->alpha, 255, bitmap->width * bitmap->height); -} - -GBool Splash::gouraudTriangleShadedFill(SplashGouraudColor *shading) -{ - double xdbl[3] = {0., 0., 0.}; - double ydbl[3] = {0., 0., 0.}; - int x[3] = {0, 0, 0}; - int y[3] = {0, 0, 0}; - double xt=0., xa=0., yt=0.; - double ca=0., ct=0.; - - // triangle interpolation: - // - double scanLimitMapL[2] = {0., 0.}; - double scanLimitMapR[2] = {0., 0.}; - double scanColorMapL[2] = {0., 0.}; - double scanColorMapR[2] = {0., 0.}; - double scanColorMap[2] = {0., 0.}; - int scanEdgeL[2] = { 0, 0 }; - int scanEdgeR[2] = { 0, 0 }; - GBool hasFurtherSegment = gFalse; - - int scanLineOff = 0; - int bitmapOff = 0; - int scanLimitR = 0, scanLimitL = 0; - - int bitmapWidth = bitmap->getWidth(); - SplashClip* clip = getClip(); - SplashBitmap *blitTarget = bitmap; - SplashColorPtr bitmapData = bitmap->getDataPtr(); - int bitmapOffLimit = bitmap->getHeight() * bitmap->getRowSize(); - SplashColorPtr bitmapAlpha = bitmap->getAlphaPtr(); - SplashColorPtr cur = NULL; - SplashCoord* userToCanvasMatrix = getMatrix(); - SplashColorMode bitmapMode = bitmap->getMode(); - GBool hasAlpha = (bitmapAlpha != NULL); - int rowSize = bitmap->getRowSize(); - int colorComps = 0; - switch (bitmapMode) { - case splashModeMono1: - break; - case splashModeMono8: - colorComps=1; - break; - case splashModeRGB8: - colorComps=3; - break; - case splashModeBGR8: - colorComps=3; - break; - case splashModeXBGR8: - colorComps=4; - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - colorComps=4; - break; - case splashModeDeviceN8: - colorComps=SPOT_NCOMPS+4; - break; -#endif - } - - SplashPipe pipe; - SplashColor cSrcVal; - - pipeInit(&pipe, 0, 0, NULL, cSrcVal, (Guchar)splashRound(state->strokeAlpha * 255), gFalse, gFalse); - - if (vectorAntialias) { - if (aaBuf == NULL) - return gFalse; // fall back to old behaviour - drawAAPixelInit(); - } - - // idea: - // 1. If pipe->noTransparency && !state->blendFunc - // -> blit directly into the drawing surface! - // -> disable alpha manually. - // 2. Otherwise: - // - blit also directly, but into an intermediate surface. - // Afterwards, blit the intermediate surface using the drawing pipeline. - // This is necessary because triangle elements can be on top of each - // other, so the complete shading needs to be drawn before opacity is - // applied. - // - the final step, is performed using a SplashPipe: - // - assign the actual color into cSrcVal: pipe uses cSrcVal by reference - // - invoke drawPixel(&pipe,X,Y,bNoClip); - GBool bDirectBlit = vectorAntialias ? gFalse : pipe.noTransparency && !state->blendFunc; - if (!bDirectBlit) { - blitTarget = new SplashBitmap(bitmap->getWidth(), - bitmap->getHeight(), - bitmap->getRowPad(), - bitmap->getMode(), - gTrue, - bitmap->getRowSize() >= 0); - bitmapData = blitTarget->getDataPtr(); - bitmapAlpha = blitTarget->getAlphaPtr(); - - // initialisation seems to be necessary: - int S = bitmap->getWidth() * bitmap->getHeight(); - for (int i = 0; i < S; ++i) - bitmapAlpha[i] = 0; - hasAlpha = gTrue; - } - - if (shading->isParameterized()) { - double color[3]; - double colorinterp; - - for (int i = 0; i < shading->getNTriangles(); ++i) { - shading->getTriangle(i, - xdbl + 0, ydbl + 0, color + 0, - xdbl + 1, ydbl + 1, color + 1, - xdbl + 2, ydbl + 2, color + 2); - for (int m = 0; m < 3; ++m) { - xt = xdbl[m] * (double)userToCanvasMatrix[0] + ydbl[m] * (double)userToCanvasMatrix[2] + (double)userToCanvasMatrix[4]; - yt = xdbl[m] * (double)userToCanvasMatrix[1] + ydbl[m] * (double)userToCanvasMatrix[3] + (double)userToCanvasMatrix[5]; - xdbl[m] = xt; - ydbl[m] = yt; - // we operate on scanlines which are integer offsets into the - // raster image. The double offsets are of no use here. - x[m] = splashRound(xt); - y[m] = splashRound(yt); - } - // sort according to y coordinate to simplify sweep through scanlines: - // INSERTION SORT. - if (y[0] > y[1]) { - Guswap(x[0], x[1]); - Guswap(y[0], y[1]); - Guswap(color[0], color[1]); - } - // first two are sorted. - assert(y[0] <= y[1]); - if (y[1] > y[2]) { - int tmpX = x[2]; - int tmpY = y[2]; - double tmpC = color[2]; - x[2] = x[1]; y[2] = y[1]; color[2] = color[1]; - - if (y[0] > tmpY) { - x[1] = x[0]; y[1] = y[0]; color[1] = color[0]; - x[0] = tmpX; y[0] = tmpY; color[0] = tmpC; - } else { - x[1] = tmpX; y[1] = tmpY; color[1] = tmpC; - } - } - // first three are sorted - assert(y[0] <= y[1]); - assert(y[1] <= y[2]); - ///// - - // this here is det( T ) == 0 - // where T is the matrix to map to barycentric coordinates. - if ((x[0] - x[2]) * (y[1] - y[2]) - (x[1] - x[2]) * (y[0] - y[2]) == 0) - continue; // degenerate triangle. - - // this here initialises the scanline generation. - // We start with low Y coordinates and sweep up to the large Y - // coordinates. - // - // scanEdgeL[m] in {0,1,2} m=0,1 - // scanEdgeR[m] in {0,1,2} m=0,1 - // - // are the two edges between which scanlines are (currently) - // sweeped. The values {0,1,2} are indices into 'x' and 'y'. - // scanEdgeL[0] = 0 means: the left scan edge has (x[0],y[0]) as vertex. - // - scanEdgeL[0] = 0; - scanEdgeR[0] = 0; - if (y[0] == y[1]) { - scanEdgeL[0] = 1; - scanEdgeL[1] = scanEdgeR[1] = 2; - - } else { - scanEdgeL[1] = 1; scanEdgeR[1] = 2; - } - assert(y[scanEdgeL[0]] < y[scanEdgeL[1]]); - assert(y[scanEdgeR[0]] < y[scanEdgeR[1]]); - - // Ok. Now prepare the linear maps which map the y coordinate of - // the current scanline to the corresponding LEFT and RIGHT x - // coordinate (which define the scanline). - scanLimitMapL[0] = double(x[scanEdgeL[1]] - x[scanEdgeL[0]]) / (y[scanEdgeL[1]] - y[scanEdgeL[0]]); - scanLimitMapL[1] = x[scanEdgeL[0]] - y[scanEdgeL[0]] * scanLimitMapL[0]; - scanLimitMapR[0] = double(x[scanEdgeR[1]] - x[scanEdgeR[0]]) / (y[scanEdgeR[1]] - y[scanEdgeR[0]]); - scanLimitMapR[1] = x[scanEdgeR[0]] - y[scanEdgeR[0]] * scanLimitMapR[0]; - - xa = y[1] * scanLimitMapL[0] + scanLimitMapL[1]; - xt = y[1] * scanLimitMapR[0] + scanLimitMapR[1]; - if (xa > xt) { - // I have "left" is to the right of "right". - // Exchange sides! - Guswap(scanEdgeL[0], scanEdgeR[0]); - Guswap(scanEdgeL[1], scanEdgeR[1]); - Guswap(scanLimitMapL[0], scanLimitMapR[0]); - Guswap(scanLimitMapL[1], scanLimitMapR[1]); - // FIXME I'm sure there is a more efficient way to check this. - } - - // Same game: we can linearly interpolate the color based on the - // current y coordinate (that's correct for triangle - // interpolation due to linearity. We could also have done it in - // barycentric coordinates, but that's slightly more involved) - scanColorMapL[0] = (color[scanEdgeL[1]] - color[scanEdgeL[0]]) / (y[scanEdgeL[1]] - y[scanEdgeL[0]]); - scanColorMapL[1] = color[scanEdgeL[0]] - y[scanEdgeL[0]] * scanColorMapL[0]; - scanColorMapR[0] = (color[scanEdgeR[1]] - color[scanEdgeR[0]]) / (y[scanEdgeR[1]] - y[scanEdgeR[0]]); - scanColorMapR[1] = color[scanEdgeR[0]] - y[scanEdgeR[0]] * scanColorMapR[0]; - - hasFurtherSegment = (y[1] < y[2]); - scanLineOff = y[0] * rowSize; - - for (int Y = y[0]; Y <= y[2]; ++Y, scanLineOff += rowSize) { - if (hasFurtherSegment && Y == y[1]) { - // SWEEP EVENT: we encountered the next segment. - // - // switch to next segment, either at left end or at right - // end: - if (scanEdgeL[1] == 1) { - scanEdgeL[0] = 1; - scanEdgeL[1] = 2; - scanLimitMapL[0] = double(x[scanEdgeL[1]] - x[scanEdgeL[0]]) / (y[scanEdgeL[1]] - y[scanEdgeL[0]]); - scanLimitMapL[1] = x[scanEdgeL[0]] - y[scanEdgeL[0]] * scanLimitMapL[0]; - - scanColorMapL[0] = (color[scanEdgeL[1]] - color[scanEdgeL[0]]) / (y[scanEdgeL[1]] - y[scanEdgeL[0]]); - scanColorMapL[1] = color[scanEdgeL[0]] - y[scanEdgeL[0]] * scanColorMapL[0]; - } else if (scanEdgeR[1] == 1) { - scanEdgeR[0] = 1; - scanEdgeR[1] = 2; - scanLimitMapR[0] = double(x[scanEdgeR[1]] - x[scanEdgeR[0]]) / (y[scanEdgeR[1]] - y[scanEdgeR[0]]); - scanLimitMapR[1] = x[scanEdgeR[0]] - y[scanEdgeR[0]] * scanLimitMapR[0]; - - scanColorMapR[0] = (color[scanEdgeR[1]] - color[scanEdgeR[0]]) / (y[scanEdgeR[1]] - y[scanEdgeR[0]]); - scanColorMapR[1] = color[scanEdgeR[0]] - y[scanEdgeR[0]] * scanColorMapR[0]; - } - assert( y[scanEdgeL[0]] < y[scanEdgeL[1]] ); - assert( y[scanEdgeR[0]] < y[scanEdgeR[1]] ); - hasFurtherSegment = gFalse; - } - - yt = Y; - - xa = yt * scanLimitMapL[0] + scanLimitMapL[1]; - xt = yt * scanLimitMapR[0] + scanLimitMapR[1]; - - ca = yt * scanColorMapL[0] + scanColorMapL[1]; - ct = yt * scanColorMapR[0] + scanColorMapR[1]; - - scanLimitL = splashRound(xa); - scanLimitR = splashRound(xt); - - // Ok. Now: init the color interpolation depending on the X - // coordinate inside of the current scanline: - scanColorMap[0] = (scanLimitR == scanLimitL) ? 0. : ((ct - ca) / (scanLimitR - scanLimitL)); - scanColorMap[1] = ca - scanLimitL * scanColorMap[0]; - - // handled by clipping: - // assert( scanLimitL >= 0 && scanLimitR < bitmap->getWidth() ); - assert(scanLimitL <= scanLimitR || abs(scanLimitL - scanLimitR) <= 2); // allow rounding inaccuracies - assert(scanLineOff == Y * rowSize); - - colorinterp = scanColorMap[0] * scanLimitL + scanColorMap[1]; - - bitmapOff = scanLineOff + scanLimitL * colorComps; - if (likely(bitmapOff >= 0)) { - for (int X = scanLimitL; X <= scanLimitR && bitmapOff + colorComps <= bitmapOffLimit; ++X, colorinterp += scanColorMap[0], bitmapOff += colorComps) { - // FIXME : standard rectangular clipping can be done for a - // complete scanline which is faster - // --> see SplashClip and its methods - if (!clip->test(X, Y)) - continue; - - assert(fabs(colorinterp - (scanColorMap[0] * X + scanColorMap[1])) < 1e-10); - assert(bitmapOff == Y * rowSize + colorComps * X && scanLineOff == Y * rowSize); - - shading->getParameterizedColor(colorinterp, bitmapMode, &bitmapData[bitmapOff]); - - // make the shading visible. - // Note that opacity is handled by the bDirectBlit stuff, see - // above for comments and below for implementation. - if (hasAlpha) - bitmapAlpha[Y * bitmapWidth + X] = 255; - } - } - } - } - } else { - if (!bDirectBlit) { - delete blitTarget; - } - return gFalse; - } - - if (!bDirectBlit) { - // ok. Finalize the stuff by blitting the shading into the final - // geometry, this time respecting the rendering pipe. - int W = blitTarget->getWidth(); - int H = blitTarget->getHeight(); - cur = cSrcVal; - - for (int X = 0; X < W; ++X) { - for (int Y = 0; Y < H; ++Y) { - if (!bitmapAlpha[Y * bitmapWidth + X]) - continue; // draw only parts of the shading! - bitmapOff = Y * rowSize + colorComps * X; - - for (int m = 0; m < colorComps; ++m) - cur[m] = bitmapData[bitmapOff + m]; - if (vectorAntialias) { - drawAAPixel(&pipe, X, Y); - } else { - drawPixel(&pipe, X, Y, gTrue); // no clipping - has already been done. - } - } - } - - delete blitTarget; - blitTarget = NULL; - } - - return gTrue; -} - -SplashError Splash::blitTransparent(SplashBitmap *src, int xSrc, int ySrc, - int xDest, int yDest, int w, int h) { - SplashColorPtr p, sp; - Guchar *q; - int x, y, mask, srcMask; - - if (src->mode != bitmap->mode) { - return splashErrModeMismatch; - } - - if (unlikely(!bitmap->data)) { - return splashErrZeroImage; - } - - switch (bitmap->mode) { - case splashModeMono1: - for (y = 0; y < h; ++y) { - p = &bitmap->data[(yDest + y) * bitmap->rowSize + (xDest >> 3)]; - mask = 0x80 >> (xDest & 7); - sp = &src->data[(ySrc + y) * src->rowSize + (xSrc >> 3)]; - srcMask = 0x80 >> (xSrc & 7); - for (x = 0; x < w; ++x) { - if (*sp & srcMask) { - *p |= mask; - } else { - *p &= ~mask; - } - if (!(mask >>= 1)) { - mask = 0x80; - ++p; - } - if (!(srcMask >>= 1)) { - srcMask = 0x80; - ++sp; - } - } - } - break; - case splashModeMono8: - for (y = 0; y < h; ++y) { - p = &bitmap->data[(yDest + y) * bitmap->rowSize + xDest]; - sp = &src->data[(ySrc + y) * bitmap->rowSize + xSrc]; - for (x = 0; x < w; ++x) { - *p++ = *sp++; - } - } - break; - case splashModeRGB8: - case splashModeBGR8: - for (y = 0; y < h; ++y) { - p = &bitmap->data[(yDest + y) * bitmap->rowSize + 3 * xDest]; - sp = &src->data[(ySrc + y) * src->rowSize + 3 * xSrc]; - for (x = 0; x < w; ++x) { - *p++ = *sp++; - *p++ = *sp++; - *p++ = *sp++; - } - } - break; - case splashModeXBGR8: - for (y = 0; y < h; ++y) { - p = &bitmap->data[(yDest + y) * bitmap->rowSize + 4 * xDest]; - sp = &src->data[(ySrc + y) * src->rowSize + 4 * xSrc]; - for (x = 0; x < w; ++x) { - *p++ = *sp++; - *p++ = *sp++; - *p++ = *sp++; - *p++ = 255; - sp++; - } - } - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - for (y = 0; y < h; ++y) { - p = &bitmap->data[(yDest + y) * bitmap->rowSize + 4 * xDest]; - sp = &src->data[(ySrc + y) * src->rowSize + 4 * xSrc]; - for (x = 0; x < w; ++x) { - *p++ = *sp++; - *p++ = *sp++; - *p++ = *sp++; - *p++ = *sp++; - } - } - break; - case splashModeDeviceN8: - for (y = 0; y < h; ++y) { - p = &bitmap->data[(yDest + y) * bitmap->rowSize + (SPOT_NCOMPS+4) * xDest]; - sp = &src->data[(ySrc + y) * src->rowSize + (SPOT_NCOMPS+4) * xSrc]; - for (x = 0; x < w; ++x) { - for (int cp=0; cp < SPOT_NCOMPS+4; cp++) - *p++ = *sp++; - } - } - break; -#endif - } - - if (bitmap->alpha) { - for (y = 0; y < h; ++y) { - q = &bitmap->alpha[(yDest + y) * bitmap->width + xDest]; - memset(q, 0x00, w); - } - } - - return splashOk; -} - -SplashPath *Splash::makeStrokePath(SplashPath *path, SplashCoord w, - GBool flatten) { -SplashPath *pathIn, *dashPath, *pathOut; - SplashCoord d, dx, dy, wdx, wdy, dxNext, dyNext, wdxNext, wdyNext; - SplashCoord crossprod, dotprod, miter, m; - GBool first, last, closed, hasangle; - int subpathStart0, subpathStart1, seg, i0, i1, j0, j1, k0, k1; - int left0, left1, left2, right0, right1, right2, join0, join1, join2; - int leftFirst, rightFirst, firstPt; - - pathOut = new SplashPath(); - - if (path->length == 0) { - return pathOut; - } - - if (flatten) { - pathIn = flattenPath(path, state->matrix, state->flatness); - if (state->lineDashLength > 0) { - dashPath = makeDashedPath(pathIn); - delete pathIn; - pathIn = dashPath; - if (pathIn->length == 0) { - delete pathIn; - return pathOut; - } - } - } else { - pathIn = path; - } - - subpathStart0 = subpathStart1 = 0; // make gcc happy - seg = 0; // make gcc happy - closed = gFalse; // make gcc happy - left0 = left1 = right0 = right1 = join0 = join1 = 0; // make gcc happy - leftFirst = rightFirst = firstPt = 0; // make gcc happy - - i0 = 0; - for (i1 = i0; - !(pathIn->flags[i1] & splashPathLast) && - i1 + 1 < pathIn->length && - pathIn->pts[i1+1].x == pathIn->pts[i1].x && - pathIn->pts[i1+1].y == pathIn->pts[i1].y; - ++i1) ; - - while (i1 < pathIn->length) { - if ((first = pathIn->flags[i0] & splashPathFirst)) { - subpathStart0 = i0; - subpathStart1 = i1; - seg = 0; - closed = pathIn->flags[i0] & splashPathClosed; - } - j0 = i1 + 1; - if (j0 < pathIn->length) { - for (j1 = j0; - !(pathIn->flags[j1] & splashPathLast) && - j1 + 1 < pathIn->length && - pathIn->pts[j1+1].x == pathIn->pts[j1].x && - pathIn->pts[j1+1].y == pathIn->pts[j1].y; - ++j1) ; - } else { - j1 = j0; - } - if (pathIn->flags[i1] & splashPathLast) { - if (first && state->lineCap == splashLineCapRound) { - // special case: zero-length subpath with round line caps --> - // draw a circle - pathOut->moveTo(pathIn->pts[i0].x + (SplashCoord)0.5 * w, - pathIn->pts[i0].y); - pathOut->curveTo(pathIn->pts[i0].x + (SplashCoord)0.5 * w, - pathIn->pts[i0].y + bezierCircle2 * w, - pathIn->pts[i0].x + bezierCircle2 * w, - pathIn->pts[i0].y + (SplashCoord)0.5 * w, - pathIn->pts[i0].x, - pathIn->pts[i0].y + (SplashCoord)0.5 * w); - pathOut->curveTo(pathIn->pts[i0].x - bezierCircle2 * w, - pathIn->pts[i0].y + (SplashCoord)0.5 * w, - pathIn->pts[i0].x - (SplashCoord)0.5 * w, - pathIn->pts[i0].y + bezierCircle2 * w, - pathIn->pts[i0].x - (SplashCoord)0.5 * w, - pathIn->pts[i0].y); - pathOut->curveTo(pathIn->pts[i0].x - (SplashCoord)0.5 * w, - pathIn->pts[i0].y - bezierCircle2 * w, - pathIn->pts[i0].x - bezierCircle2 * w, - pathIn->pts[i0].y - (SplashCoord)0.5 * w, - pathIn->pts[i0].x, - pathIn->pts[i0].y - (SplashCoord)0.5 * w); - pathOut->curveTo(pathIn->pts[i0].x + bezierCircle2 * w, - pathIn->pts[i0].y - (SplashCoord)0.5 * w, - pathIn->pts[i0].x + (SplashCoord)0.5 * w, - pathIn->pts[i0].y - bezierCircle2 * w, - pathIn->pts[i0].x + (SplashCoord)0.5 * w, - pathIn->pts[i0].y); - pathOut->close(); - } - i0 = j0; - i1 = j1; - continue; - } - last = pathIn->flags[j1] & splashPathLast; - if (last) { - k0 = subpathStart1 + 1; - } else { - k0 = j1 + 1; - } - for (k1 = k0; - !(pathIn->flags[k1] & splashPathLast) && - k1 + 1 < pathIn->length && - pathIn->pts[k1+1].x == pathIn->pts[k1].x && - pathIn->pts[k1+1].y == pathIn->pts[k1].y; - ++k1) ; - - // compute the deltas for segment (i1, j0) -#ifdef USE_FIXEDPOINT - // the 1/d value can be small, which introduces significant - // inaccuracies in fixed point mode - d = splashDist(pathIn->pts[i1].x, pathIn->pts[i1].y, - pathIn->pts[j0].x, pathIn->pts[j0].y); - dx = (pathIn->pts[j0].x - pathIn->pts[i1].x) / d; - dy = (pathIn->pts[j0].y - pathIn->pts[i1].y) / d; -#else - d = (SplashCoord)1 / splashDist(pathIn->pts[i1].x, pathIn->pts[i1].y, - pathIn->pts[j0].x, pathIn->pts[j0].y); - dx = d * (pathIn->pts[j0].x - pathIn->pts[i1].x); - dy = d * (pathIn->pts[j0].y - pathIn->pts[i1].y); -#endif - wdx = (SplashCoord)0.5 * w * dx; - wdy = (SplashCoord)0.5 * w * dy; - - // draw the start cap - pathOut->moveTo(pathIn->pts[i0].x - wdy, pathIn->pts[i0].y + wdx); - if (i0 == subpathStart0) { - firstPt = pathOut->length - 1; - } - if (first && !closed) { - switch (state->lineCap) { - case splashLineCapButt: - pathOut->lineTo(pathIn->pts[i0].x + wdy, pathIn->pts[i0].y - wdx); - break; - case splashLineCapRound: - pathOut->curveTo(pathIn->pts[i0].x - wdy - bezierCircle * wdx, - pathIn->pts[i0].y + wdx - bezierCircle * wdy, - pathIn->pts[i0].x - wdx - bezierCircle * wdy, - pathIn->pts[i0].y - wdy + bezierCircle * wdx, - pathIn->pts[i0].x - wdx, - pathIn->pts[i0].y - wdy); - pathOut->curveTo(pathIn->pts[i0].x - wdx + bezierCircle * wdy, - pathIn->pts[i0].y - wdy - bezierCircle * wdx, - pathIn->pts[i0].x + wdy - bezierCircle * wdx, - pathIn->pts[i0].y - wdx - bezierCircle * wdy, - pathIn->pts[i0].x + wdy, - pathIn->pts[i0].y - wdx); - break; - case splashLineCapProjecting: - pathOut->lineTo(pathIn->pts[i0].x - wdx - wdy, - pathIn->pts[i0].y + wdx - wdy); - pathOut->lineTo(pathIn->pts[i0].x - wdx + wdy, - pathIn->pts[i0].y - wdx - wdy); - pathOut->lineTo(pathIn->pts[i0].x + wdy, - pathIn->pts[i0].y - wdx); - break; - } - } else { - pathOut->lineTo(pathIn->pts[i0].x + wdy, pathIn->pts[i0].y - wdx); - } - - // draw the left side of the segment rectangle - left2 = pathOut->length - 1; - pathOut->lineTo(pathIn->pts[j0].x + wdy, pathIn->pts[j0].y - wdx); - - // draw the end cap - if (last && !closed) { - switch (state->lineCap) { - case splashLineCapButt: - pathOut->lineTo(pathIn->pts[j0].x - wdy, pathIn->pts[j0].y + wdx); - break; - case splashLineCapRound: - pathOut->curveTo(pathIn->pts[j0].x + wdy + bezierCircle * wdx, - pathIn->pts[j0].y - wdx + bezierCircle * wdy, - pathIn->pts[j0].x + wdx + bezierCircle * wdy, - pathIn->pts[j0].y + wdy - bezierCircle * wdx, - pathIn->pts[j0].x + wdx, - pathIn->pts[j0].y + wdy); - pathOut->curveTo(pathIn->pts[j0].x + wdx - bezierCircle * wdy, - pathIn->pts[j0].y + wdy + bezierCircle * wdx, - pathIn->pts[j0].x - wdy + bezierCircle * wdx, - pathIn->pts[j0].y + wdx + bezierCircle * wdy, - pathIn->pts[j0].x - wdy, - pathIn->pts[j0].y + wdx); - break; - case splashLineCapProjecting: - pathOut->lineTo(pathIn->pts[j0].x + wdy + wdx, - pathIn->pts[j0].y - wdx + wdy); - pathOut->lineTo(pathIn->pts[j0].x - wdy + wdx, - pathIn->pts[j0].y + wdx + wdy); - pathOut->lineTo(pathIn->pts[j0].x - wdy, - pathIn->pts[j0].y + wdx); - break; - } - } else { - pathOut->lineTo(pathIn->pts[j0].x - wdy, pathIn->pts[j0].y + wdx); - } - - // draw the right side of the segment rectangle - // (NB: if stroke adjustment is enabled, the closepath operation MUST - // add a segment because this segment is used for a hint) - right2 = pathOut->length - 1; - pathOut->close(state->strokeAdjust); - - // draw the join - join2 = pathOut->length; - if (!last || closed) { - - // compute the deltas for segment (j1, k0) -#ifdef USE_FIXEDPOINT - // the 1/d value can be small, which introduces significant - // inaccuracies in fixed point mode - d = splashDist(pathIn->pts[j1].x, pathIn->pts[j1].y, - pathIn->pts[k0].x, pathIn->pts[k0].y); - dxNext = (pathIn->pts[k0].x - pathIn->pts[j1].x) / d; - dyNext = (pathIn->pts[k0].y - pathIn->pts[j1].y) / d; -#else - d = (SplashCoord)1 / splashDist(pathIn->pts[j1].x, pathIn->pts[j1].y, - pathIn->pts[k0].x, pathIn->pts[k0].y); - dxNext = d * (pathIn->pts[k0].x - pathIn->pts[j1].x); - dyNext = d * (pathIn->pts[k0].y - pathIn->pts[j1].y); -#endif - wdxNext = (SplashCoord)0.5 * w * dxNext; - wdyNext = (SplashCoord)0.5 * w * dyNext; - - // compute the join parameters - crossprod = dx * dyNext - dy * dxNext; - dotprod = -(dx * dxNext + dy * dyNext); - hasangle = crossprod != 0 || dx * dxNext < 0 || dy * dyNext < 0; - if (dotprod > 0.9999) { - // avoid a divide-by-zero -- set miter to something arbitrary - // such that sqrt(miter) will exceed miterLimit (and m is never - // used in that situation) - // (note: the comparison value (0.9999) has to be less than - // 1-epsilon, where epsilon is the smallest value - // representable in the fixed point format) - miter = (state->miterLimit + 1) * (state->miterLimit + 1); - m = 0; - } else { - miter = (SplashCoord)2 / ((SplashCoord)1 - dotprod); - if (miter < 1) { - // this can happen because of floating point inaccuracies - miter = 1; - } - m = splashSqrt(miter - 1); - } - - // round join - if (hasangle && state->lineJoin == splashLineJoinRound) { - pathOut->moveTo(pathIn->pts[j0].x + (SplashCoord)0.5 * w, - pathIn->pts[j0].y); - pathOut->curveTo(pathIn->pts[j0].x + (SplashCoord)0.5 * w, - pathIn->pts[j0].y + bezierCircle2 * w, - pathIn->pts[j0].x + bezierCircle2 * w, - pathIn->pts[j0].y + (SplashCoord)0.5 * w, - pathIn->pts[j0].x, - pathIn->pts[j0].y + (SplashCoord)0.5 * w); - pathOut->curveTo(pathIn->pts[j0].x - bezierCircle2 * w, - pathIn->pts[j0].y + (SplashCoord)0.5 * w, - pathIn->pts[j0].x - (SplashCoord)0.5 * w, - pathIn->pts[j0].y + bezierCircle2 * w, - pathIn->pts[j0].x - (SplashCoord)0.5 * w, - pathIn->pts[j0].y); - pathOut->curveTo(pathIn->pts[j0].x - (SplashCoord)0.5 * w, - pathIn->pts[j0].y - bezierCircle2 * w, - pathIn->pts[j0].x - bezierCircle2 * w, - pathIn->pts[j0].y - (SplashCoord)0.5 * w, - pathIn->pts[j0].x, - pathIn->pts[j0].y - (SplashCoord)0.5 * w); - pathOut->curveTo(pathIn->pts[j0].x + bezierCircle2 * w, - pathIn->pts[j0].y - (SplashCoord)0.5 * w, - pathIn->pts[j0].x + (SplashCoord)0.5 * w, - pathIn->pts[j0].y - bezierCircle2 * w, - pathIn->pts[j0].x + (SplashCoord)0.5 * w, - pathIn->pts[j0].y); - - } else if (hasangle) { - pathOut->moveTo(pathIn->pts[j0].x, pathIn->pts[j0].y); - - // angle < 180 - if (crossprod < 0) { - pathOut->lineTo(pathIn->pts[j0].x - wdyNext, - pathIn->pts[j0].y + wdxNext); - // miter join inside limit - if (state->lineJoin == splashLineJoinMiter && - splashSqrt(miter) <= state->miterLimit) { - pathOut->lineTo(pathIn->pts[j0].x - wdy + wdx * m, - pathIn->pts[j0].y + wdx + wdy * m); - pathOut->lineTo(pathIn->pts[j0].x - wdy, - pathIn->pts[j0].y + wdx); - // bevel join or miter join outside limit - } else { - pathOut->lineTo(pathIn->pts[j0].x - wdy, - pathIn->pts[j0].y + wdx); - } - - // angle >= 180 - } else { - pathOut->lineTo(pathIn->pts[j0].x + wdy, - pathIn->pts[j0].y - wdx); - // miter join inside limit - if (state->lineJoin == splashLineJoinMiter && - splashSqrt(miter) <= state->miterLimit) { - pathOut->lineTo(pathIn->pts[j0].x + wdy + wdx * m, - pathIn->pts[j0].y - wdx + wdy * m); - pathOut->lineTo(pathIn->pts[j0].x + wdyNext, - pathIn->pts[j0].y - wdxNext); - // bevel join or miter join outside limit - } else { - pathOut->lineTo(pathIn->pts[j0].x + wdyNext, - pathIn->pts[j0].y - wdxNext); - } - } - } - - pathOut->close(); - } - - // add stroke adjustment hints - if (state->strokeAdjust) { - if (seg == 0 && !closed) { - if (state->lineCap == splashLineCapButt) { - pathOut->addStrokeAdjustHint(firstPt, left2 + 1, - firstPt, firstPt + 1); - if (last) { - pathOut->addStrokeAdjustHint(firstPt, left2 + 1, - left2 + 1, left2 + 2); - } - } else if (state->lineCap == splashLineCapProjecting) { - if (last) { - pathOut->addStrokeAdjustHint(firstPt + 1, left2 + 2, - firstPt + 1, firstPt + 2); - pathOut->addStrokeAdjustHint(firstPt + 1, left2 + 2, - left2 + 2, left2 + 3); - } else { - pathOut->addStrokeAdjustHint(firstPt + 1, left2 + 1, - firstPt + 1, firstPt + 2); - } - } - } - if (seg >= 1) { - if (seg >= 2) { - pathOut->addStrokeAdjustHint(left1, right1, left0 + 1, right0); - pathOut->addStrokeAdjustHint(left1, right1, join0, left2); - } else { - pathOut->addStrokeAdjustHint(left1, right1, firstPt, left2); - } - pathOut->addStrokeAdjustHint(left1, right1, right2 + 1, right2 + 1); - } - left0 = left1; - left1 = left2; - right0 = right1; - right1 = right2; - join0 = join1; - join1 = join2; - if (seg == 0) { - leftFirst = left2; - rightFirst = right2; - } - if (last) { - if (seg >= 2) { - pathOut->addStrokeAdjustHint(left1, right1, left0 + 1, right0); - pathOut->addStrokeAdjustHint(left1, right1, - join0, pathOut->length - 1); - } else { - pathOut->addStrokeAdjustHint(left1, right1, - firstPt, pathOut->length - 1); - } - if (closed) { - pathOut->addStrokeAdjustHint(left1, right1, firstPt, leftFirst); - pathOut->addStrokeAdjustHint(left1, right1, - rightFirst + 1, rightFirst + 1); - pathOut->addStrokeAdjustHint(leftFirst, rightFirst, - left1 + 1, right1); - pathOut->addStrokeAdjustHint(leftFirst, rightFirst, - join1, pathOut->length - 1); - } - if (!closed && seg > 0) { - if (state->lineCap == splashLineCapButt) { - pathOut->addStrokeAdjustHint(left1 - 1, left1 + 1, - left1 + 1, left1 + 2); - } else if (state->lineCap == splashLineCapProjecting) { - pathOut->addStrokeAdjustHint(left1 - 1, left1 + 2, - left1 + 2, left1 + 3); - } - } - } - } - - i0 = j0; - i1 = j1; - ++seg; - } - - if (pathIn != path) { - delete pathIn; - } - - return pathOut; -} - -void Splash::dumpPath(SplashPath *path) { - int i; - - for (i = 0; i < path->length; ++i) { - printf(" %3d: x=%8.2f y=%8.2f%s%s%s%s\n", - i, (double)path->pts[i].x, (double)path->pts[i].y, - (path->flags[i] & splashPathFirst) ? " first" : "", - (path->flags[i] & splashPathLast) ? " last" : "", - (path->flags[i] & splashPathClosed) ? " closed" : "", - (path->flags[i] & splashPathCurve) ? " curve" : ""); - } -} - -void Splash::dumpXPath(SplashXPath *path) { - int i; - - for (i = 0; i < path->length; ++i) { - printf(" %4d: x0=%8.2f y0=%8.2f x1=%8.2f y1=%8.2f %s%s%s\n", - i, (double)path->segs[i].x0, (double)path->segs[i].y0, - (double)path->segs[i].x1, (double)path->segs[i].y1, - (path->segs[i].flags & splashXPathHoriz) ? "H" : " ", - (path->segs[i].flags & splashXPathVert) ? "V" : " ", - (path->segs[i].flags & splashXPathFlip) ? "P" : " "); - } -} - -SplashError Splash::shadedFill(SplashPath *path, GBool hasBBox, - SplashPattern *pattern) { - SplashPipe pipe; - SplashXPath *xPath; - SplashXPathScanner *scanner; - int xMinI, yMinI, xMaxI, yMaxI, x0, x1, y; - SplashClipResult clipRes; - - if (vectorAntialias && aaBuf == NULL) { // should not happen, but to be secure - return splashErrGeneric; - } - if (path->length == 0) { - return splashErrEmptyPath; - } - xPath = new SplashXPath(path, state->matrix, state->flatness, gTrue); - if (vectorAntialias) { - xPath->aaScale(); - } - xPath->sort(); - yMinI = state->clip->getYMinI(); - yMaxI = state->clip->getYMaxI(); - if (vectorAntialias && !inShading) { - yMinI = yMinI * splashAASize; - yMaxI = (yMaxI + 1) * splashAASize - 1; - } - scanner = new SplashXPathScanner(xPath, gFalse, yMinI, yMaxI); - - // get the min and max x and y values - if (vectorAntialias) { - scanner->getBBoxAA(&xMinI, &yMinI, &xMaxI, &yMaxI); - } else { - scanner->getBBox(&xMinI, &yMinI, &xMaxI, &yMaxI); - } - - // check clipping - if ((clipRes = state->clip->testRect(xMinI, yMinI, xMaxI, yMaxI)) != splashClipAllOutside) { - // limit the y range - if (yMinI < state->clip->getYMinI()) { - yMinI = state->clip->getYMinI(); - } - if (yMaxI > state->clip->getYMaxI()) { - yMaxI = state->clip->getYMaxI(); - } - - pipeInit(&pipe, 0, yMinI, pattern, NULL, (Guchar)splashRound(state->fillAlpha * 255), vectorAntialias && !hasBBox, gFalse); - - // draw the spans - if (vectorAntialias) { - for (y = yMinI; y <= yMaxI; ++y) { - scanner->renderAALine(aaBuf, &x0, &x1, y); - if (clipRes != splashClipAllInside) { - state->clip->clipAALine(aaBuf, &x0, &x1, y); - } -#if splashAASize == 4 - if (!hasBBox && y > yMinI && y < yMaxI) { - // correct shape on left side if clip is - // vertical through the middle of shading: - Guchar *p0, *p1, *p2, *p3; - Guchar c1, c2, c3, c4; - p0 = aaBuf->getDataPtr() + (x0 >> 1); - p1 = p0 + aaBuf->getRowSize(); - p2 = p1 + aaBuf->getRowSize(); - p3 = p2 + aaBuf->getRowSize(); - if (x0 & 1) { - c1 = (*p0 & 0x0f); c2 =(*p1 & 0x0f); c3 = (*p2 & 0x0f) ; c4 = (*p3 & 0x0f); - } else { - c1 = (*p0 >> 4); c2 = (*p1 >> 4); c3 = (*p2 >> 4); c4 = (*p3 >> 4); - } - if ( (c1 & 0x03) == 0x03 && (c2 & 0x03) == 0x03 && (c3 & 0x03) == 0x03 && (c4 & 0x03) == 0x03 - && c1 == c2 && c2 == c3 && c3 == c4 && - pattern->testPosition(x0 - 1, y) ) - { - Guchar shapeCorrection = (x0 & 1) ? 0x0f : 0xf0; - *p0 |= shapeCorrection; - *p1 |= shapeCorrection; - *p2 |= shapeCorrection; - *p3 |= shapeCorrection; - } - // correct shape on right side if clip is - // through the middle of shading: - p0 = aaBuf->getDataPtr() + (x1 >> 1); - p1 = p0 + aaBuf->getRowSize(); - p2 = p1 + aaBuf->getRowSize(); - p3 = p2 + aaBuf->getRowSize(); - if (x1 & 1) { - c1 = (*p0 & 0x0f); c2 =(*p1 & 0x0f); c3 = (*p2 & 0x0f) ; c4 = (*p3 & 0x0f); - } else { - c1 = (*p0 >> 4); c2 = (*p1 >> 4); c3 = (*p2 >> 4); c4 = (*p3 >> 4); - } - - if ( (c1 & 0xc) == 0x0c && (c2 & 0x0c) == 0x0c && (c3 & 0x0c) == 0x0c && (c4 & 0x0c) == 0x0c - && c1 == c2 && c2 == c3 && c3 == c4 && - pattern->testPosition(x1 + 1, y) ) - { - Guchar shapeCorrection = (x1 & 1) ? 0x0f : 0xf0; - *p0 |= shapeCorrection; - *p1 |= shapeCorrection; - *p2 |= shapeCorrection; - *p3 |= shapeCorrection; - } - } -#endif - drawAALine(&pipe, x0, x1, y); - } - } else { - SplashClipResult clipRes2; - for (y = yMinI; y <= yMaxI; ++y) { - while (scanner->getNextSpan(y, &x0, &x1)) { - if (clipRes == splashClipAllInside) { - drawSpan(&pipe, x0, x1, y, gTrue); - } else { - // limit the x range - if (x0 < state->clip->getXMinI()) { - x0 = state->clip->getXMinI(); - } - if (x1 > state->clip->getXMaxI()) { - x1 = state->clip->getXMaxI(); - } - clipRes2 = state->clip->testSpan(x0, x1, y); - drawSpan(&pipe, x0, x1, y, clipRes2 == splashClipAllInside); - } - } - } - } - } - opClipRes = clipRes; - - delete scanner; - delete xPath; - return splashOk; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/Splash.h b/Build/source/libs/poppler/poppler-src/splash/Splash.h deleted file mode 100644 index 907e4c3b6ee..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/Splash.h +++ /dev/null @@ -1,431 +0,0 @@ -//======================================================================== -// -// Splash.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2005 Marco Pesenti Gritti <mpg@redhat.com> -// Copyright (C) 2007, 2011 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2010-2013, 2015 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com> -// Copyright (C) 2012, 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASH_H -#define SPLASH_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include <stddef.h> -#include "SplashTypes.h" -#include "SplashClip.h" -#include "SplashPattern.h" - -class SplashBitmap; -struct SplashGlyphBitmap; -class SplashState; -class SplashScreen; -class SplashPath; -class SplashXPath; -class SplashFont; -struct SplashPipe; - -//------------------------------------------------------------------------ - -// Retrieves the next line of pixels in an image mask. Normally, -// fills in *<line> and returns true. If the image stream is -// exhausted, returns false. -typedef GBool (*SplashImageMaskSource)(void *data, SplashColorPtr pixel); - -// Retrieves the next line of pixels in an image. Normally, fills in -// *<line> and returns true. If the image stream is exhausted, -// returns false. -typedef GBool (*SplashImageSource)(void *data, SplashColorPtr colorLine, - Guchar *alphaLine); - -// Use ICCColorSpace to transform a bitmap -typedef void (*SplashICCTransform)(void *data, SplashBitmap *bitmap); - -//------------------------------------------------------------------------ - -enum SplashPipeResultColorCtrl { -#ifdef SPLASH_CMYK - splashPipeResultColorNoAlphaBlendCMYK, - splashPipeResultColorNoAlphaBlendDeviceN, -#endif - splashPipeResultColorNoAlphaBlendRGB, - splashPipeResultColorNoAlphaBlendMono, - splashPipeResultColorAlphaNoBlendMono, - splashPipeResultColorAlphaNoBlendRGB, -#ifdef SPLASH_CMYK - splashPipeResultColorAlphaNoBlendCMYK, - splashPipeResultColorAlphaNoBlendDeviceN, -#endif - splashPipeResultColorAlphaBlendMono, - splashPipeResultColorAlphaBlendRGB -#ifdef SPLASH_CMYK - , - splashPipeResultColorAlphaBlendCMYK, - splashPipeResultColorAlphaBlendDeviceN -#endif -}; - -//------------------------------------------------------------------------ -// Splash -//------------------------------------------------------------------------ - -class Splash { -public: - - // Create a new rasterizer object. - Splash(SplashBitmap *bitmapA, GBool vectorAntialiasA, - SplashScreenParams *screenParams = NULL); - Splash(SplashBitmap *bitmapA, GBool vectorAntialiasA, - SplashScreen *screenA); - - ~Splash(); - - //----- state read - - SplashCoord *getMatrix(); - SplashPattern *getStrokePattern(); - SplashPattern *getFillPattern(); - SplashScreen *getScreen(); - SplashBlendFunc getBlendFunc(); - SplashCoord getStrokeAlpha(); - SplashCoord getFillAlpha(); - SplashCoord getLineWidth(); - int getLineCap(); - int getLineJoin(); - SplashCoord getMiterLimit(); - SplashCoord getFlatness(); - SplashCoord *getLineDash(); - int getLineDashLength(); - SplashCoord getLineDashPhase(); - GBool getStrokeAdjust(); - SplashClip *getClip(); - SplashBitmap *getSoftMask(); - GBool getInNonIsolatedGroup(); - - //----- state write - - void setMatrix(SplashCoord *matrix); - void setStrokePattern(SplashPattern *strokeColor); - void setFillPattern(SplashPattern *fillColor); - void setScreen(SplashScreen *screen); - void setBlendFunc(SplashBlendFunc func); - void setStrokeAlpha(SplashCoord alpha); - void setFillAlpha(SplashCoord alpha); - void setPatternAlpha(SplashCoord strokeAlpha, SplashCoord fillAlpha); - void clearPatternAlpha(); - void setFillOverprint(GBool fop); - void setStrokeOverprint(GBool sop); - void setOverprintMode(int opm); - void setLineWidth(SplashCoord lineWidth); - void setLineCap(int lineCap); - void setLineJoin(int lineJoin); - void setMiterLimit(SplashCoord miterLimit); - void setFlatness(SplashCoord flatness); - // the <lineDash> array will be copied - void setLineDash(SplashCoord *lineDash, int lineDashLength, - SplashCoord lineDashPhase); - void setStrokeAdjust(GBool strokeAdjust); - // NB: uses transformed coordinates. - void clipResetToRect(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1); - // NB: uses transformed coordinates. - SplashError clipToRect(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1); - // NB: uses untransformed coordinates. - SplashError clipToPath(SplashPath *path, GBool eo); - void setSoftMask(SplashBitmap *softMask); - void setInNonIsolatedGroup(SplashBitmap *alpha0BitmapA, - int alpha0XA, int alpha0YA); - void setTransfer(Guchar *red, Guchar *green, Guchar *blue, Guchar *gray); - void setOverprintMask(Guint overprintMask, GBool additive); - - //----- state save/restore - - void saveState(); - SplashError restoreState(); - - //----- drawing operations - - // Fill the bitmap with <color>. This is not subject to clipping. - void clear(SplashColorPtr color, Guchar alpha = 0x00); - - // Stroke a path using the current stroke pattern. - SplashError stroke(SplashPath *path); - - // Fill a path using the current fill pattern. - SplashError fill(SplashPath *path, GBool eo); - - // Fill a path, XORing with the current fill pattern. - SplashError xorFill(SplashPath *path, GBool eo); - - // Draw a character, using the current fill pattern. - SplashError fillChar(SplashCoord x, SplashCoord y, int c, SplashFont *font); - - // Draw a glyph, using the current fill pattern. This function does - // not free any data, i.e., it ignores glyph->freeData. - void fillGlyph(SplashCoord x, SplashCoord y, - SplashGlyphBitmap *glyph); - - // Draws an image mask using the fill color. This will read <h> - // lines of <w> pixels from <src>, starting with the top line. "1" - // pixels will be drawn with the current fill color; "0" pixels are - // transparent. The matrix: - // [ mat[0] mat[1] 0 ] - // [ mat[2] mat[3] 0 ] - // [ mat[4] mat[5] 1 ] - // maps a unit square to the desired destination for the image, in - // PostScript style: - // [x' y' 1] = [x y 1] * mat - // Note that the Splash y axis points downward, and the image source - // is assumed to produce pixels in raster order, starting from the - // top line. - SplashError fillImageMask(SplashImageMaskSource src, void *srcData, - int w, int h, SplashCoord *mat, - GBool glyphMode); - - // Draw an image. This will read <h> lines of <w> pixels from - // <src>, starting with the top line. These pixels are assumed to - // be in the source mode, <srcMode>. If <srcAlpha> is true, the - // alpha values returned by <src> are used; otherwise they are - // ignored. The following combinations of source and target modes - // are supported: - // source target - // ------ ------ - // Mono1 Mono1 - // Mono8 Mono1 -- with dithering - // Mono8 Mono8 - // RGB8 RGB8 - // BGR8 BGR8 - // CMYK8 CMYK8 - // The matrix behaves as for fillImageMask. - SplashError drawImage(SplashImageSource src, SplashICCTransform tf, void *srcData, - SplashColorMode srcMode, GBool srcAlpha, - int w, int h, SplashCoord *mat, GBool interpolate, - GBool tilingPattern = gFalse); - - // Composite a rectangular region from <src> onto this Splash - // object. - SplashError composite(SplashBitmap *src, int xSrc, int ySrc, - int xDest, int yDest, int w, int h, - GBool noClip, GBool nonIsolated, - GBool knockout = gFalse, SplashCoord knockoutOpacity = 1.0); - - // Composite this Splash object onto a background color. The - // background alpha is assumed to be 1. - void compositeBackground(SplashColorPtr color); - - // Copy a rectangular region from <src> onto the bitmap belonging to - // this Splash object. The destination alpha values are all set to - // zero. - SplashError blitTransparent(SplashBitmap *src, int xSrc, int ySrc, - int xDest, int yDest, int w, int h); - void blitImage(SplashBitmap *src, GBool srcAlpha, int xDest, int yDest); - - //----- misc - - // Construct a path for a stroke, given the path to be stroked and - // the line width <w>. All other stroke parameters are taken from - // the current state. If <flatten> is true, this function will - // first flatten the path and handle the linedash. - SplashPath *makeStrokePath(SplashPath *path, SplashCoord w, - GBool flatten = gTrue); - - // Return the associated bitmap. - SplashBitmap *getBitmap() { return bitmap; } - - // Set the minimum line width. - void setMinLineWidth(SplashCoord w) { minLineWidth = w; } - - // Setter/Getter for thin line mode - void setThinLineMode(SplashThinLineMode thinLineModeA) { thinLineMode = thinLineModeA; } - SplashThinLineMode getThinLineMode() { return thinLineMode; } - - // Get a bounding box which includes all modifications since the - // last call to clearModRegion. - void getModRegion(int *xMin, int *yMin, int *xMax, int *yMax) - { *xMin = modXMin; *yMin = modYMin; *xMax = modXMax; *yMax = modYMax; } - - // Clear the modified region bounding box. - void clearModRegion(); - - // Get clipping status for the last drawing operation subject to - // clipping. - SplashClipResult getClipRes() { return opClipRes; } - - // Toggle debug mode on or off. - void setDebugMode(GBool debugModeA) { debugMode = debugModeA; } - -#if 1 //~tmp: turn off anti-aliasing temporarily - void setInShading(GBool sh) { inShading = sh; } - GBool getVectorAntialias() { return vectorAntialias; } - void setVectorAntialias(GBool vaa) { vectorAntialias = vaa; } -#endif - - // Do shaded fills with dynamic patterns - SplashError shadedFill(SplashPath *path, GBool hasBBox, - SplashPattern *pattern); - // Draw a gouraud triangle shading. - GBool gouraudTriangleShadedFill(SplashGouraudColor *shading); - -private: - - void pipeInit(SplashPipe *pipe, int x, int y, - SplashPattern *pattern, SplashColorPtr cSrc, - Guchar aInput, GBool usesShape, - GBool nonIsolatedGroup, - GBool knockout = gFalse, Guchar knockoutOpacity = 255); - void pipeRun(SplashPipe *pipe); - void pipeRunSimpleMono1(SplashPipe *pipe); - void pipeRunSimpleMono8(SplashPipe *pipe); - void pipeRunSimpleRGB8(SplashPipe *pipe); - void pipeRunSimpleXBGR8(SplashPipe *pipe); - void pipeRunSimpleBGR8(SplashPipe *pipe); -#ifdef SPLASH_CMYK - void pipeRunSimpleCMYK8(SplashPipe *pipe); - void pipeRunSimpleDeviceN8(SplashPipe *pipe); -#endif - void pipeRunAAMono1(SplashPipe *pipe); - void pipeRunAAMono8(SplashPipe *pipe); - void pipeRunAARGB8(SplashPipe *pipe); - void pipeRunAAXBGR8(SplashPipe *pipe); - void pipeRunAABGR8(SplashPipe *pipe); -#ifdef SPLASH_CMYK - void pipeRunAACMYK8(SplashPipe *pipe); - void pipeRunAADeviceN8(SplashPipe *pipe); -#endif - void pipeSetXY(SplashPipe *pipe, int x, int y); - void pipeIncX(SplashPipe *pipe); - void drawPixel(SplashPipe *pipe, int x, int y, GBool noClip); - void drawAAPixelInit(); - void drawAAPixel(SplashPipe *pipe, int x, int y); - void drawSpan(SplashPipe *pipe, int x0, int x1, int y, GBool noClip); - void drawAALine(SplashPipe *pipe, int x0, int x1, int y, GBool adjustLine = gFalse, Guchar lineOpacity = 0); - void transform(SplashCoord *matrix, SplashCoord xi, SplashCoord yi, - SplashCoord *xo, SplashCoord *yo); - void updateModX(int x); - void updateModY(int y); - void strokeNarrow(SplashPath *path); - void strokeWide(SplashPath *path, SplashCoord w); - SplashPath *flattenPath(SplashPath *path, SplashCoord *matrix, - SplashCoord flatness); - void flattenCurve(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1, - SplashCoord x2, SplashCoord y2, - SplashCoord x3, SplashCoord y3, - SplashCoord *matrix, SplashCoord flatness2, - SplashPath *fPath); - SplashPath *makeDashedPath(SplashPath *xPath); - void getBBoxFP(SplashPath *path, SplashCoord *xMinA, SplashCoord *yMinA, SplashCoord *xMaxA, SplashCoord *yMaxA); - SplashError fillWithPattern(SplashPath *path, GBool eo, - SplashPattern *pattern, SplashCoord alpha); - GBool pathAllOutside(SplashPath *path); - void fillGlyph2(int x0, int y0, SplashGlyphBitmap *glyph, GBool noclip); - void arbitraryTransformMask(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - SplashCoord *mat, GBool glyphMode); - SplashBitmap *scaleMask(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight); - void scaleMaskYdXd(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest); - void scaleMaskYdXu(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest); - void scaleMaskYuXd(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest); - void scaleMaskYuXu(SplashImageMaskSource src, void *srcData, - int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest); - void blitMask(SplashBitmap *src, int xDest, int yDest, - SplashClipResult clipRes); - SplashError arbitraryTransformImage(SplashImageSource src, SplashICCTransform tf, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, - int srcWidth, int srcHeight, - SplashCoord *mat, GBool interpolate, GBool tilingPattern = gFalse); - SplashBitmap *scaleImage(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, GBool interpolate, GBool tilingPattern = gFalse); - void scaleImageYdXd(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest); - void scaleImageYdXu(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest); - void scaleImageYuXd(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest); - void scaleImageYuXu(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest); - void scaleImageYuXuBilinear(SplashImageSource src, void *srcData, - SplashColorMode srcMode, int nComps, - GBool srcAlpha, int srcWidth, int srcHeight, - int scaledWidth, int scaledHeight, - SplashBitmap *dest); - void vertFlipImage(SplashBitmap *img, int width, int height, - int nComps); - void blitImage(SplashBitmap *src, GBool srcAlpha, int xDest, int yDest, - SplashClipResult clipRes); - void blitImageClipped(SplashBitmap *src, GBool srcAlpha, - int xSrc, int ySrc, int xDest, int yDest, - int w, int h); - void dumpPath(SplashPath *path); - void dumpXPath(SplashXPath *path); - - static SplashPipeResultColorCtrl pipeResultColorNoAlphaBlend[]; - static SplashPipeResultColorCtrl pipeResultColorAlphaNoBlend[]; - static SplashPipeResultColorCtrl pipeResultColorAlphaBlend[]; - static int pipeNonIsoGroupCorrection[]; - - SplashBitmap *bitmap; - SplashState *state; - SplashBitmap *aaBuf; - int aaBufY; - SplashBitmap *alpha0Bitmap; // for non-isolated groups, this is the - // bitmap containing the alpha0 values - int alpha0X, alpha0Y; // offset within alpha0Bitmap - SplashCoord aaGamma[splashAASize * splashAASize + 1]; - SplashCoord minLineWidth; - SplashThinLineMode thinLineMode; - int modXMin, modYMin, modXMax, modYMax; - SplashClipResult opClipRes; - GBool vectorAntialias; - GBool inShading; - GBool debugMode; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashBitmap.cc b/Build/source/libs/poppler/poppler-src/splash/SplashBitmap.cc deleted file mode 100644 index 5acee7d0bd6..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashBitmap.cc +++ /dev/null @@ -1,853 +0,0 @@ -//======================================================================== -// -// SplashBitmap.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006, 2009, 2010, 2012, 2015 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2007 Ilmari Heikkinen <ilmari.heikkinen@gmail.com> -// Copyright (C) 2009 Shen Liang <shenzhuxi@gmail.com> -// Copyright (C) 2009 Stefan Thomas <thomas@eload24.com> -// Copyright (C) 2010, 2012, 2017 Adrian Johnson <ajohnson@redneon.com> -// Copyright (C) 2010 Harry Roberts <harry.roberts@midnight-labs.org> -// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com> -// Copyright (C) 2010, 2015 William Bader <williambader@hotmail.com> -// Copyright (C) 2011-2013 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2012 Anthony Wesley <awesley@smartnetworks.com.au> -// Copyright (C) 2015 Adam Reichold <adamreichold@myopera.com> -// Copyright (C) 2016 Kenji Uno <ku@digitaldolphins.jp> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <stdio.h> -#include <string.h> -#include <stdlib.h> -#include <limits.h> -#include "goo/gmem.h" -#include "SplashErrorCodes.h" -#include "SplashBitmap.h" -#include "poppler/Error.h" -#include "goo/JpegWriter.h" -#include "goo/PNGWriter.h" -#include "goo/TiffWriter.h" -#include "goo/ImgWriter.h" -#include "goo/GooList.h" - -//------------------------------------------------------------------------ -// SplashBitmap -//------------------------------------------------------------------------ - -SplashBitmap::SplashBitmap(int widthA, int heightA, int rowPadA, - SplashColorMode modeA, GBool alphaA, - GBool topDown, GooList *separationListA) { - width = widthA; - height = heightA; - mode = modeA; - rowPad = rowPadA; - switch (mode) { - case splashModeMono1: - if (width > 0) { - rowSize = (width + 7) >> 3; - } else { - rowSize = -1; - } - break; - case splashModeMono8: - if (width > 0) { - rowSize = width; - } else { - rowSize = -1; - } - break; - case splashModeRGB8: - case splashModeBGR8: - if (width > 0 && width <= INT_MAX / 3) { - rowSize = width * 3; - } else { - rowSize = -1; - } - break; - case splashModeXBGR8: - if (width > 0 && width <= INT_MAX / 4) { - rowSize = width * 4; - } else { - rowSize = -1; - } - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - if (width > 0 && width <= INT_MAX / 4) { - rowSize = width * 4; - } else { - rowSize = -1; - } - break; - case splashModeDeviceN8: - if (width > 0 && width <= INT_MAX / 4) { - rowSize = width * (SPOT_NCOMPS + 4); - } else { - rowSize = -1; - } - break; -#endif - } - if (rowSize > 0) { - rowSize += rowPad - 1; - rowSize -= rowSize % rowPad; - } - data = (SplashColorPtr)gmallocn_checkoverflow(rowSize, height); - if (data != NULL) { - if (!topDown) { - data += (height - 1) * rowSize; - rowSize = -rowSize; - } - if (alphaA) { - alpha = (Guchar *)gmallocn(width, height); - } else { - alpha = NULL; - } - } else { - alpha = NULL; - } - separationList = new GooList(); - if (separationListA != NULL) - for (int i = 0; i < separationListA->getLength(); i++) - separationList->append(((GfxSeparationColorSpace *) separationListA->get(i))->copy()); -} - -SplashBitmap *SplashBitmap::copy(SplashBitmap *src) { - SplashBitmap *result = new SplashBitmap(src->getWidth(), src->getHeight(), src->getRowPad(), - src->getMode(), src->getAlphaPtr() != NULL, src->getRowSize() >= 0, src->getSeparationList()); - Guchar *dataSource = src->getDataPtr(); - Guchar *dataDest = result->getDataPtr(); - int amount = src->getRowSize(); - if (amount < 0) { - dataSource = dataSource + (src->getHeight() - 1) * amount; - dataDest = dataDest + (src->getHeight() - 1) * amount; - amount *= -src->getHeight(); - } else { - amount *= src->getHeight(); - } - memcpy(dataDest, dataSource, amount); - if (src->getAlphaPtr() != NULL) { - memcpy(result->getAlphaPtr(), src->getAlphaPtr(), src->getWidth() * src->getHeight()); - } - return result; -} - -SplashBitmap::~SplashBitmap() { - if (data) { - if (rowSize < 0) { - gfree(data + (height - 1) * rowSize); - } else { - gfree(data); - } - } - gfree(alpha); - deleteGooList(separationList, GfxSeparationColorSpace); -} - - -SplashError SplashBitmap::writePNMFile(char *fileName) { - FILE *f; - SplashError e; - - if (!(f = fopen(fileName, "wb"))) { - return splashErrOpenFile; - } - - e = this->writePNMFile(f); - - fclose(f); - return e; -} - - -SplashError SplashBitmap::writePNMFile(FILE *f) { - SplashColorPtr row, p; - int x, y; - - switch (mode) { - - case splashModeMono1: - fprintf(f, "P4\n%d %d\n", width, height); - row = data; - for (y = 0; y < height; ++y) { - p = row; - for (x = 0; x < width; x += 8) { - fputc(*p ^ 0xff, f); - ++p; - } - row += rowSize; - } - break; - - case splashModeMono8: - fprintf(f, "P5\n%d %d\n255\n", width, height); - row = data; - for (y = 0; y < height; ++y) { - fwrite(row, 1, width, f); - row += rowSize; - } - break; - - case splashModeRGB8: - fprintf(f, "P6\n%d %d\n255\n", width, height); - row = data; - for (y = 0; y < height; ++y) { - fwrite(row, 1, 3 * width, f); - row += rowSize; - } - break; - - case splashModeXBGR8: - fprintf(f, "P6\n%d %d\n255\n", width, height); - row = data; - for (y = 0; y < height; ++y) { - p = row; - for (x = 0; x < width; ++x) { - fputc(splashBGR8R(p), f); - fputc(splashBGR8G(p), f); - fputc(splashBGR8B(p), f); - p += 4; - } - row += rowSize; - } - break; - - - case splashModeBGR8: - fprintf(f, "P6\n%d %d\n255\n", width, height); - row = data; - for (y = 0; y < height; ++y) { - p = row; - for (x = 0; x < width; ++x) { - fputc(splashBGR8R(p), f); - fputc(splashBGR8G(p), f); - fputc(splashBGR8B(p), f); - p += 3; - } - row += rowSize; - } - break; - -#ifdef SPLASH_CMYK - case splashModeCMYK8: - case splashModeDeviceN8: - // PNM doesn't support CMYK - error(errInternal, -1, "unsupported SplashBitmap mode"); - return splashErrGeneric; - break; -#endif - } - return splashOk; -} - -SplashError SplashBitmap::writeAlphaPGMFile(char *fileName) { - FILE *f; - - if (!alpha) { - return splashErrModeMismatch; - } - if (!(f = fopen(fileName, "wb"))) { - return splashErrOpenFile; - } - fprintf(f, "P5\n%d %d\n255\n", width, height); - fwrite(alpha, 1, width * height, f); - fclose(f); - return splashOk; -} - -void SplashBitmap::getPixel(int x, int y, SplashColorPtr pixel) { - SplashColorPtr p; - - if (y < 0 || y >= height || x < 0 || x >= width || !data) { - return; - } - switch (mode) { - case splashModeMono1: - p = &data[y * rowSize + (x >> 3)]; - pixel[0] = (p[0] & (0x80 >> (x & 7))) ? 0xff : 0x00; - break; - case splashModeMono8: - p = &data[y * rowSize + x]; - pixel[0] = p[0]; - break; - case splashModeRGB8: - p = &data[y * rowSize + 3 * x]; - pixel[0] = p[0]; - pixel[1] = p[1]; - pixel[2] = p[2]; - break; - case splashModeXBGR8: - p = &data[y * rowSize + 4 * x]; - pixel[0] = p[2]; - pixel[1] = p[1]; - pixel[2] = p[0]; - pixel[3] = p[3]; - break; - case splashModeBGR8: - p = &data[y * rowSize + 3 * x]; - pixel[0] = p[2]; - pixel[1] = p[1]; - pixel[2] = p[0]; - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - p = &data[y * rowSize + 4 * x]; - pixel[0] = p[0]; - pixel[1] = p[1]; - pixel[2] = p[2]; - pixel[3] = p[3]; - break; - case splashModeDeviceN8: - p = &data[y * rowSize + (SPOT_NCOMPS + 4) * x]; - for (int cp = 0; cp < SPOT_NCOMPS + 4; cp++) - pixel[cp] = p[cp]; - break; -#endif - } -} - -Guchar SplashBitmap::getAlpha(int x, int y) { - return alpha[y * width + x]; -} - -SplashColorPtr SplashBitmap::takeData() { - SplashColorPtr data2; - - data2 = data; - data = NULL; - return data2; -} - -SplashError SplashBitmap::writeImgFile(SplashImageFileFormat format, char *fileName, int hDPI, int vDPI, WriteImgParams* params) { - FILE *f; - SplashError e; - - if (!(f = fopen(fileName, "wb"))) { - return splashErrOpenFile; - } - - e = writeImgFile(format, f, hDPI, vDPI, params); - - fclose(f); - return e; -} - -void SplashBitmap::setJpegParams(ImgWriter *writer, WriteImgParams* params) -{ -#ifdef ENABLE_LIBJPEG - if (params) { - static_cast<JpegWriter*>(writer)->setProgressive(params->jpegProgressive); - if (params->jpegQuality >= 0) - static_cast<JpegWriter*>(writer)->setQuality(params->jpegQuality); - } -#endif -} - -SplashError SplashBitmap::writeImgFile(SplashImageFileFormat format, FILE *f, int hDPI, int vDPI, WriteImgParams* params) { - ImgWriter *writer; - SplashError e; - - SplashColorMode imageWriterFormat = splashModeRGB8; - - switch (format) { - #ifdef ENABLE_LIBPNG - case splashFormatPng: - writer = new PNGWriter(); - break; - #endif - - #ifdef ENABLE_LIBJPEG - #ifdef SPLASH_CMYK - case splashFormatJpegCMYK: - writer = new JpegWriter(JpegWriter::CMYK); - setJpegParams(writer, params); - break; - #endif - case splashFormatJpeg: - writer = new JpegWriter(); - setJpegParams(writer, params); - break; - #endif - - #ifdef ENABLE_LIBTIFF - case splashFormatTiff: - switch (mode) { - case splashModeMono1: - writer = new TiffWriter(TiffWriter::MONOCHROME); - imageWriterFormat = splashModeMono1; - break; - case splashModeMono8: - writer = new TiffWriter(TiffWriter::GRAY); - imageWriterFormat = splashModeMono8; - break; - case splashModeRGB8: - case splashModeBGR8: - writer = new TiffWriter(TiffWriter::RGB); - break; -#ifdef SPLASH_CMYK - case splashModeCMYK8: - case splashModeDeviceN8: - writer = new TiffWriter(TiffWriter::CMYK); - break; -#endif - default: - fprintf(stderr, "TiffWriter: Mode %d not supported\n", mode); - writer = new TiffWriter(); - } - if (writer && params) { - ((TiffWriter *)writer)->setCompressionString(params->tiffCompression.getCString()); - } - break; - #endif - - default: - // Not the greatest error message, but users of this function should - // have already checked whether their desired format is compiled in. - error(errInternal, -1, "Support for this image type not compiled in"); - return splashErrGeneric; - } - - e = writeImgFile(writer, f, hDPI, vDPI, imageWriterFormat); - delete writer; - return e; -} - -#include "poppler/GfxState_helpers.h" - -void SplashBitmap::getRGBLine(int yl, SplashColorPtr line) { - SplashColor col; - double c, m, y, k, c1, m1, y1, k1, r, g, b; - - for (int x = 0; x < width; x++) { - getPixel(x, yl, col); - c = byteToDbl(col[0]); - m = byteToDbl(col[1]); - y = byteToDbl(col[2]); - k = byteToDbl(col[3]); -#ifdef SPLASH_CMYK - if (separationList->getLength() > 0) { - for (int i = 0; i < separationList->getLength(); i++) { - if (col[i+4] > 0) { - GfxCMYK cmyk; - GfxColor input; - input.c[0] = byteToCol(col[i+4]); - GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)separationList->get(i); - sepCS->getCMYK(&input, &cmyk); - col[0] = colToByte(cmyk.c); - col[1] = colToByte(cmyk.m); - col[2] = colToByte(cmyk.y); - col[3] = colToByte(cmyk.k); - c += byteToDbl(col[0]); - m += byteToDbl(col[1]); - y += byteToDbl(col[2]); - k += byteToDbl(col[3]); - } - } - if (c > 1) c = 1; - if (m > 1) m = 1; - if (y > 1) y = 1; - if (k > 1) k = 1; - } -#endif - c1 = 1 - c; - m1 = 1 - m; - y1 = 1 - y; - k1 = 1 - k; - cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b); - *line++ = dblToByte(clip01(r)); - *line++ = dblToByte(clip01(g)); - *line++ = dblToByte(clip01(b)); - } -} - -void SplashBitmap::getXBGRLine(int yl, SplashColorPtr line, ConversionMode conversionMode) { - SplashColor col; - double c, m, y, k, c1, m1, y1, k1, r, g, b; - - for (int x = 0; x < width; x++) { - getPixel(x, yl, col); - c = byteToDbl(col[0]); - m = byteToDbl(col[1]); - y = byteToDbl(col[2]); - k = byteToDbl(col[3]); -#ifdef SPLASH_CMYK - if (separationList->getLength() > 0) { - for (int i = 0; i < separationList->getLength(); i++) { - if (col[i+4] > 0) { - GfxCMYK cmyk; - GfxColor input; - input.c[0] = byteToCol(col[i+4]); - GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)separationList->get(i); - sepCS->getCMYK(&input, &cmyk); - col[0] = colToByte(cmyk.c); - col[1] = colToByte(cmyk.m); - col[2] = colToByte(cmyk.y); - col[3] = colToByte(cmyk.k); - c += byteToDbl(col[0]); - m += byteToDbl(col[1]); - y += byteToDbl(col[2]); - k += byteToDbl(col[3]); - } - } - if (c > 1) c = 1; - if (m > 1) m = 1; - if (y > 1) y = 1; - if (k > 1) k = 1; - } -#endif - c1 = 1 - c; - m1 = 1 - m; - y1 = 1 - y; - k1 = 1 - k; - cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b); - - if (conversionMode == conversionAlphaPremultiplied) { - const double a = getAlpha(x, yl) / 255.0; - - *line++ = dblToByte(clip01(b * a)); - *line++ = dblToByte(clip01(g * a)); - *line++ = dblToByte(clip01(r * a)); - } else { - *line++ = dblToByte(clip01(b)); - *line++ = dblToByte(clip01(g)); - *line++ = dblToByte(clip01(r)); - } - - if (conversionMode != conversionOpaque) { - *line++ = getAlpha(x, yl); - } else { - *line++ = 255; - } - } -} - -static inline Guchar div255(int x) { - return (Guchar)((x + (x >> 8) + 0x80) >> 8); -} - -GBool SplashBitmap::convertToXBGR(ConversionMode conversionMode) { - if (mode == splashModeXBGR8) { - if (conversionMode != conversionOpaque) { - // Copy the alpha channel into the fourth component so that XBGR becomes ABGR. - const SplashColorPtr dbegin = data; - const SplashColorPtr dend = data + rowSize * height; - - Guchar *const abegin = alpha; - Guchar *const aend = alpha + width * height; - - SplashColorPtr d = dbegin; - Guchar *a = abegin; - - if (conversionMode == conversionAlphaPremultiplied) { - for (; d < dend && a < aend; d += 4, a += 1) { - d[0] = div255(d[0] * *a); - d[1] = div255(d[1] * *a); - d[2] = div255(d[2] * *a); - d[3] = *a; - } - } else { - for (d += 3; d < dend && a < aend; d += 4, a += 1) { - *d = *a; - } - } - } - - return gTrue; - } - - int newrowSize = width * 4; - SplashColorPtr newdata = (SplashColorPtr)gmallocn_checkoverflow(newrowSize, height); - if (newdata != NULL) { - for (int y = 0; y < height; y++) { - unsigned char *row = newdata + y * newrowSize; - getXBGRLine(y, row, conversionMode); - } - if (rowSize < 0) { - gfree(data + (height - 1) * rowSize); - } else { - gfree(data); - } - data = newdata; - rowSize = newrowSize; - mode = splashModeXBGR8; - } - return newdata != NULL; -} - -#ifdef SPLASH_CMYK -void SplashBitmap::getCMYKLine(int yl, SplashColorPtr line) { - SplashColor col; - - for (int x = 0; x < width; x++) { - getPixel(x, yl, col); - if (separationList->getLength() > 0) { - double c, m, y, k; - c = byteToDbl(col[0]); - m = byteToDbl(col[1]); - y = byteToDbl(col[2]); - k = byteToDbl(col[3]); - for (int i = 0; i < separationList->getLength(); i++) { - if (col[i+4] > 0) { - GfxCMYK cmyk; - GfxColor input; - input.c[0] = byteToCol(col[i+4]); - GfxSeparationColorSpace *sepCS = (GfxSeparationColorSpace *)separationList->get(i); - sepCS->getCMYK(&input, &cmyk); - col[0] = colToByte(cmyk.c); - col[1] = colToByte(cmyk.m); - col[2] = colToByte(cmyk.y); - col[3] = colToByte(cmyk.k); - c += byteToDbl(col[0]); - m += byteToDbl(col[1]); - y += byteToDbl(col[2]); - k += byteToDbl(col[3]); - } - } - col[0] = dblToByte(clip01(c)); - col[1] = dblToByte(clip01(m)); - col[2] = dblToByte(clip01(y)); - col[3] = dblToByte(clip01(k)); - } - *line++ = col[0]; - *line++ = col[1]; - *line++ = col[2]; - *line++ = col[3]; - } -} -#endif - -SplashError SplashBitmap::writeImgFile(ImgWriter *writer, FILE *f, int hDPI, int vDPI, SplashColorMode imageWriterFormat) { - if (mode != splashModeRGB8 && mode != splashModeMono8 && mode != splashModeMono1 && mode != splashModeXBGR8 && mode != splashModeBGR8 -#ifdef SPLASH_CMYK - && mode != splashModeCMYK8 && mode != splashModeDeviceN8 -#endif - ) { - error(errInternal, -1, "unsupported SplashBitmap mode"); - return splashErrGeneric; - } - - if (!writer->init(f, width, height, hDPI, vDPI)) { - return splashErrGeneric; - } - - switch (mode) { -#ifdef SPLASH_CMYK - case splashModeCMYK8: - if (writer->supportCMYK()) { - SplashColorPtr row; - unsigned char **row_pointers = new unsigned char*[height]; - row = data; - - for (int y = 0; y < height; ++y) { - row_pointers[y] = row; - row += rowSize; - } - if (!writer->writePointers(row_pointers, height)) { - delete[] row_pointers; - return splashErrGeneric; - } - delete[] row_pointers; - } else { - unsigned char *row = new unsigned char[3 * width]; - for (int y = 0; y < height; y++) { - getRGBLine(y, row); - if (!writer->writeRow(&row)) { - delete[] row; - return splashErrGeneric; - } - } - delete[] row; - } - break; - case splashModeDeviceN8: - if (writer->supportCMYK()) { - unsigned char *row = new unsigned char[4 * width]; - for (int y = 0; y < height; y++) { - getCMYKLine(y, row); - if (!writer->writeRow(&row)) { - delete[] row; - return splashErrGeneric; - } - } - delete[] row; - } else { - unsigned char *row = new unsigned char[3 * width]; - for (int y = 0; y < height; y++) { - getRGBLine(y, row); - if (!writer->writeRow(&row)) { - delete[] row; - return splashErrGeneric; - } - } - delete[] row; - } - break; -#endif - case splashModeRGB8: - { - SplashColorPtr row; - unsigned char **row_pointers = new unsigned char*[height]; - row = data; - - for (int y = 0; y < height; ++y) { - row_pointers[y] = row; - row += rowSize; - } - if (!writer->writePointers(row_pointers, height)) { - delete[] row_pointers; - return splashErrGeneric; - } - delete[] row_pointers; - } - break; - - case splashModeBGR8: - { - unsigned char *row = new unsigned char[3 * width]; - for (int y = 0; y < height; y++) { - // Convert into a PNG row - for (int x = 0; x < width; x++) { - row[3*x] = data[y * rowSize + x * 3 + 2]; - row[3*x+1] = data[y * rowSize + x * 3 + 1]; - row[3*x+2] = data[y * rowSize + x * 3]; - } - - if (!writer->writeRow(&row)) { - delete[] row; - return splashErrGeneric; - } - } - delete[] row; - } - break; - - case splashModeXBGR8: - { - unsigned char *row = new unsigned char[3 * width]; - for (int y = 0; y < height; y++) { - // Convert into a PNG row - for (int x = 0; x < width; x++) { - row[3*x] = data[y * rowSize + x * 4 + 2]; - row[3*x+1] = data[y * rowSize + x * 4 + 1]; - row[3*x+2] = data[y * rowSize + x * 4]; - } - - if (!writer->writeRow(&row)) { - delete[] row; - return splashErrGeneric; - } - } - delete[] row; - } - break; - - case splashModeMono8: - { - if (imageWriterFormat == splashModeMono8) { - SplashColorPtr row; - unsigned char **row_pointers = new unsigned char*[height]; - row = data; - - for (int y = 0; y < height; ++y) { - row_pointers[y] = row; - row += rowSize; - } - if (!writer->writePointers(row_pointers, height)) { - delete[] row_pointers; - return splashErrGeneric; - } - delete[] row_pointers; - } else if (imageWriterFormat == splashModeRGB8) { - unsigned char *row = new unsigned char[3 * width]; - for (int y = 0; y < height; y++) { - // Convert into a PNG row - for (int x = 0; x < width; x++) { - row[3*x] = data[y * rowSize + x]; - row[3*x+1] = data[y * rowSize + x]; - row[3*x+2] = data[y * rowSize + x]; - } - - if (!writer->writeRow(&row)) { - delete[] row; - return splashErrGeneric; - } - } - delete[] row; - } - else { - // only splashModeMono8 or splashModeRGB8 - return splashErrGeneric; - } - } - break; - - case splashModeMono1: - { - if (imageWriterFormat == splashModeMono1) { - SplashColorPtr row; - unsigned char **row_pointers = new unsigned char*[height]; - row = data; - - for (int y = 0; y < height; ++y) { - row_pointers[y] = row; - row += rowSize; - } - if (!writer->writePointers(row_pointers, height)) { - delete[] row_pointers; - return splashErrGeneric; - } - delete[] row_pointers; - } else if (imageWriterFormat == splashModeRGB8) { - unsigned char *row = new unsigned char[3 * width]; - for (int y = 0; y < height; y++) { - // Convert into a PNG row - for (int x = 0; x < width; x++) { - getPixel(x, y, &row[3*x]); - row[3*x+1] = row[3*x]; - row[3*x+2] = row[3*x]; - } - - if (!writer->writeRow(&row)) { - delete[] row; - return splashErrGeneric; - } - } - delete[] row; - } - else { - // only splashModeMono1 or splashModeRGB8 - return splashErrGeneric; - } - } - break; - - default: - // can't happen - break; - } - - if (!writer->close()) { - return splashErrGeneric; - } - - return splashOk; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashBitmap.h b/Build/source/libs/poppler/poppler-src/splash/SplashBitmap.h deleted file mode 100644 index ccd3e7d955c..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashBitmap.h +++ /dev/null @@ -1,126 +0,0 @@ -//======================================================================== -// -// SplashBitmap.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2007 Ilmari Heikkinen <ilmari.heikkinen@gmail.com> -// Copyright (C) 2009 Shen Liang <shenzhuxi@gmail.com> -// Copyright (C) 2009, 2012 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2009 Stefan Thomas <thomas@eload24.com> -// Copyright (C) 2010, 2017 Adrian Johnson <ajohnson@redneon.com> -// Copyright (C) 2010 Harry Roberts <harry.roberts@midnight-labs.org> -// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com> -// Copyright (C) 2010 William Bader <williambader@hotmail.com> -// Copyright (C) 2012 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2015 Adam Reichold <adamreichold@myopera.com> -// Copyright (C) 2016 Kenji Uno <ku@digitaldolphins.jp> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHBITMAP_H -#define SPLASHBITMAP_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "SplashTypes.h" -#include "poppler/GfxState.h" -#include <stdio.h> - -class ImgWriter; - -//------------------------------------------------------------------------ -// SplashBitmap -//------------------------------------------------------------------------ - -class SplashBitmap { -public: - - // Create a new bitmap. It will have <widthA> x <heightA> pixels in - // color mode <modeA>. Rows will be padded out to a multiple of - // <rowPad> bytes. If <topDown> is false, the bitmap will be stored - // upside-down, i.e., with the last row first in memory. - SplashBitmap(int widthA, int heightA, int rowPad, - SplashColorMode modeA, GBool alphaA, - GBool topDown = gTrue, GooList *separationList = NULL); - static SplashBitmap *copy(SplashBitmap *src); - - ~SplashBitmap(); - - int getWidth() { return width; } - int getHeight() { return height; } - int getRowSize() { return rowSize; } - int getAlphaRowSize() { return width; } - int getRowPad() { return rowPad; } - SplashColorMode getMode() { return mode; } - SplashColorPtr getDataPtr() { return data; } - Guchar *getAlphaPtr() { return alpha; } - GooList *getSeparationList() { return separationList; } - - SplashError writePNMFile(char *fileName); - SplashError writePNMFile(FILE *f); - SplashError writeAlphaPGMFile(char *fileName); - - struct WriteImgParams - { - int jpegQuality = -1; - GBool jpegProgressive = gFalse; - GooString tiffCompression; - }; - - SplashError writeImgFile(SplashImageFileFormat format, char *fileName, int hDPI, int vDPI, WriteImgParams* params = nullptr); - SplashError writeImgFile(SplashImageFileFormat format, FILE *f, int hDPI, int vDPI, WriteImgParams* params = nullptr); - SplashError writeImgFile(ImgWriter *writer, FILE *f, int hDPI, int vDPI, SplashColorMode imageWriterFormat); - - enum ConversionMode - { - conversionOpaque, - conversionAlpha, - conversionAlphaPremultiplied - }; - - GBool convertToXBGR(ConversionMode conversionMode = conversionOpaque); - - void getPixel(int x, int y, SplashColorPtr pixel); - void getRGBLine(int y, SplashColorPtr line); - void getXBGRLine(int y, SplashColorPtr line, ConversionMode conversionMode = conversionOpaque); -#ifdef SPLASH_CMYK - void getCMYKLine(int y, SplashColorPtr line); -#endif - Guchar getAlpha(int x, int y); - - // Caller takes ownership of the bitmap data. The SplashBitmap - // object is no longer valid -- the next call should be to the - // destructor. - SplashColorPtr takeData(); - -private: - - int width, height; // size of bitmap - int rowPad; - int rowSize; // size of one row of data, in bytes - // - negative for bottom-up bitmaps - SplashColorMode mode; // color mode - SplashColorPtr data; // pointer to row zero of the color data - Guchar *alpha; // pointer to row zero of the alpha data - // (always top-down) - GooList *separationList; // list of spot colorants and their mapping functions - - friend class Splash; - - void setJpegParams(ImgWriter *writer, WriteImgParams* params); -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashClip.cc b/Build/source/libs/poppler/poppler-src/splash/SplashClip.cc deleted file mode 100644 index 85c6b11473d..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashClip.cc +++ /dev/null @@ -1,411 +0,0 @@ -//======================================================================== -// -// SplashClip.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2010 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <stdlib.h> -#include <string.h> -#include "goo/gmem.h" -#include "SplashErrorCodes.h" -#include "SplashPath.h" -#include "SplashXPath.h" -#include "SplashXPathScanner.h" -#include "SplashBitmap.h" -#include "SplashClip.h" - -//------------------------------------------------------------------------ -// SplashClip.flags -//------------------------------------------------------------------------ - -#define splashClipEO 0x01 // use even-odd rule - -//------------------------------------------------------------------------ -// SplashClip -//------------------------------------------------------------------------ - -SplashClip::SplashClip(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1, - GBool antialiasA) { - antialias = antialiasA; - if (x0 < x1) { - xMin = x0; - xMax = x1; - } else { - xMin = x1; - xMax = x0; - } - if (y0 < y1) { - yMin = y0; - yMax = y1; - } else { - yMin = y1; - yMax = y0; - } - xMinI = splashFloor(xMin); - yMinI = splashFloor(yMin); - xMaxI = splashCeil(xMax) - 1; - yMaxI = splashCeil(yMax) - 1; - paths = NULL; - flags = NULL; - scanners = NULL; - length = size = 0; -} - -SplashClip::SplashClip(SplashClip *clip) { - int yMinAA, yMaxAA; - int i; - - antialias = clip->antialias; - xMin = clip->xMin; - yMin = clip->yMin; - xMax = clip->xMax; - yMax = clip->yMax; - xMinI = clip->xMinI; - yMinI = clip->yMinI; - xMaxI = clip->xMaxI; - yMaxI = clip->yMaxI; - length = clip->length; - size = clip->size; - paths = (SplashXPath **)gmallocn(size, sizeof(SplashXPath *)); - flags = (Guchar *)gmallocn(size, sizeof(Guchar)); - scanners = (SplashXPathScanner **) - gmallocn(size, sizeof(SplashXPathScanner *)); - for (i = 0; i < length; ++i) { - paths[i] = clip->paths[i]->copy(); - flags[i] = clip->flags[i]; - if (antialias) { - yMinAA = yMinI * splashAASize; - yMaxAA = (yMaxI + 1) * splashAASize - 1; - } else { - yMinAA = yMinI; - yMaxAA = yMaxI; - } - scanners[i] = new SplashXPathScanner(paths[i], flags[i] & splashClipEO, - yMinAA, yMaxAA); - } -} - -SplashClip::~SplashClip() { - int i; - - for (i = 0; i < length; ++i) { - delete paths[i]; - delete scanners[i]; - } - gfree(paths); - gfree(flags); - gfree(scanners); -} - -void SplashClip::grow(int nPaths) { - if (length + nPaths > size) { - if (size == 0) { - size = 32; - } - while (size < length + nPaths) { - size *= 2; - } - paths = (SplashXPath **)greallocn(paths, size, sizeof(SplashXPath *)); - flags = (Guchar *)greallocn(flags, size, sizeof(Guchar)); - scanners = (SplashXPathScanner **) - greallocn(scanners, size, sizeof(SplashXPathScanner *)); - } -} - -void SplashClip::resetToRect(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1) { - int i; - - for (i = 0; i < length; ++i) { - delete paths[i]; - delete scanners[i]; - } - gfree(paths); - gfree(flags); - gfree(scanners); - paths = NULL; - flags = NULL; - scanners = NULL; - length = size = 0; - - if (x0 < x1) { - xMin = x0; - xMax = x1; - } else { - xMin = x1; - xMax = x0; - } - if (y0 < y1) { - yMin = y0; - yMax = y1; - } else { - yMin = y1; - yMax = y0; - } - xMinI = splashFloor(xMin); - yMinI = splashFloor(yMin); - xMaxI = splashCeil(xMax) - 1; - yMaxI = splashCeil(yMax) - 1; -} - -SplashError SplashClip::clipToRect(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1) { - if (x0 < x1) { - if (x0 > xMin) { - xMin = x0; - xMinI = splashFloor(xMin); - } - if (x1 < xMax) { - xMax = x1; - xMaxI = splashCeil(xMax) - 1; - } - } else { - if (x1 > xMin) { - xMin = x1; - xMinI = splashFloor(xMin); - } - if (x0 < xMax) { - xMax = x0; - xMaxI = splashCeil(xMax) - 1; - } - } - if (y0 < y1) { - if (y0 > yMin) { - yMin = y0; - yMinI = splashFloor(yMin); - } - if (y1 < yMax) { - yMax = y1; - yMaxI = splashCeil(yMax) - 1; - } - } else { - if (y1 > yMin) { - yMin = y1; - yMinI = splashFloor(yMin); - } - if (y0 < yMax) { - yMax = y0; - yMaxI = splashCeil(yMax) - 1; - } - } - return splashOk; -} - -SplashError SplashClip::clipToPath(SplashPath *path, SplashCoord *matrix, - SplashCoord flatness, GBool eo) { - SplashXPath *xPath; - int yMinAA, yMaxAA; - - xPath = new SplashXPath(path, matrix, flatness, gTrue); - - // check for an empty path - if (xPath->length == 0) { - xMax = xMin - 1; - yMax = yMin - 1; - xMaxI = splashCeil(xMax) - 1; - yMaxI = splashCeil(yMax) - 1; - delete xPath; - - // check for a rectangle - } else if (xPath->length == 4 && - ((xPath->segs[0].x0 == xPath->segs[0].x1 && - xPath->segs[0].x0 == xPath->segs[1].x0 && - xPath->segs[0].x0 == xPath->segs[3].x1 && - xPath->segs[2].x0 == xPath->segs[2].x1 && - xPath->segs[2].x0 == xPath->segs[1].x1 && - xPath->segs[2].x0 == xPath->segs[3].x0 && - xPath->segs[1].y0 == xPath->segs[1].y1 && - xPath->segs[1].y0 == xPath->segs[0].y1 && - xPath->segs[1].y0 == xPath->segs[2].y0 && - xPath->segs[3].y0 == xPath->segs[3].y1 && - xPath->segs[3].y0 == xPath->segs[0].y0 && - xPath->segs[3].y0 == xPath->segs[2].y1) || - (xPath->segs[0].y0 == xPath->segs[0].y1 && - xPath->segs[0].y0 == xPath->segs[1].y0 && - xPath->segs[0].y0 == xPath->segs[3].y1 && - xPath->segs[2].y0 == xPath->segs[2].y1 && - xPath->segs[2].y0 == xPath->segs[1].y1 && - xPath->segs[2].y0 == xPath->segs[3].y0 && - xPath->segs[1].x0 == xPath->segs[1].x1 && - xPath->segs[1].x0 == xPath->segs[0].x1 && - xPath->segs[1].x0 == xPath->segs[2].x0 && - xPath->segs[3].x0 == xPath->segs[3].x1 && - xPath->segs[3].x0 == xPath->segs[0].x0 && - xPath->segs[3].x0 == xPath->segs[2].x1))) { - clipToRect(xPath->segs[0].x0, xPath->segs[0].y0, - xPath->segs[2].x0, xPath->segs[2].y0); - delete xPath; - - } else { - grow(1); - if (antialias) { - xPath->aaScale(); - } - xPath->sort(); - paths[length] = xPath; - flags[length] = eo ? splashClipEO : 0; - if (antialias) { - yMinAA = yMinI * splashAASize; - yMaxAA = (yMaxI + 1) * splashAASize - 1; - } else { - yMinAA = yMinI; - yMaxAA = yMaxI; - } - scanners[length] = new SplashXPathScanner(xPath, eo, yMinAA, yMaxAA); - ++length; - } - - return splashOk; -} - -SplashClipResult SplashClip::testRect(int rectXMin, int rectYMin, - int rectXMax, int rectYMax) { - // This tests the rectangle: - // x = [rectXMin, rectXMax + 1) (note: rect coords are ints) - // y = [rectYMin, rectYMax + 1) - // against the clipping region: - // x = [xMin, xMax) (note: clipping coords are fp) - // y = [yMin, yMax) - if ((SplashCoord)(rectXMax + 1) <= xMin || (SplashCoord)rectXMin >= xMax || - (SplashCoord)(rectYMax + 1) <= yMin || (SplashCoord)rectYMin >= yMax) { - return splashClipAllOutside; - } - if ((SplashCoord)rectXMin >= xMin && (SplashCoord)(rectXMax + 1) <= xMax && - (SplashCoord)rectYMin >= yMin && (SplashCoord)(rectYMax + 1) <= yMax && - length == 0) { - return splashClipAllInside; - } - return splashClipPartial; -} - -SplashClipResult SplashClip::testSpan(int spanXMin, int spanXMax, int spanY) { - int i; - - // This tests the rectangle: - // x = [spanXMin, spanXMax + 1) (note: span coords are ints) - // y = [spanY, spanY + 1) - // against the clipping region: - // x = [xMin, xMax) (note: clipping coords are fp) - // y = [yMin, yMax) - if ((SplashCoord)(spanXMax + 1) <= xMin || (SplashCoord)spanXMin >= xMax || - (SplashCoord)(spanY + 1) <= yMin || (SplashCoord)spanY >= yMax) { - return splashClipAllOutside; - } - if (!((SplashCoord)spanXMin >= xMin && (SplashCoord)(spanXMax + 1) <= xMax && - (SplashCoord)spanY >= yMin && (SplashCoord)(spanY + 1) <= yMax)) { - return splashClipPartial; - } - if (antialias) { - for (i = 0; i < length; ++i) { - if (!scanners[i]->testSpan(spanXMin * splashAASize, - spanXMax * splashAASize + (splashAASize - 1), - spanY * splashAASize)) { - return splashClipPartial; - } - } - } else { - for (i = 0; i < length; ++i) { - if (!scanners[i]->testSpan(spanXMin, spanXMax, spanY)) { - return splashClipPartial; - } - } - } - return splashClipAllInside; -} - -void SplashClip::clipAALine(SplashBitmap *aaBuf, int *x0, int *x1, int y, GBool adjustVertLine) { - int xx0, xx1, xx, yy, i; - SplashColorPtr p; - - // zero out pixels with x < xMin - xx0 = *x0 * splashAASize; - xx1 = splashFloor(xMin * splashAASize); - if (xx1 > aaBuf->getWidth()) { - xx1 = aaBuf->getWidth(); - } - if (xx0 < xx1) { - xx0 &= ~7; - for (yy = 0; yy < splashAASize; ++yy) { - p = aaBuf->getDataPtr() + yy * aaBuf->getRowSize() + (xx0 >> 3); - for (xx = xx0; xx + 7 < xx1; xx += 8) { - *p++ = 0; - } - if (xx < xx1 && !adjustVertLine) { - *p &= 0xff >> (xx1 & 7); - } - } - *x0 = splashFloor(xMin); - } - - // zero out pixels with x > xMax - xx0 = splashFloor(xMax * splashAASize) + 1; - if (xx0 < 0) { - xx0 = 0; - } - xx1 = (*x1 + 1) * splashAASize; - if (xx0 < xx1 && !adjustVertLine) { - for (yy = 0; yy < splashAASize; ++yy) { - p = aaBuf->getDataPtr() + yy * aaBuf->getRowSize() + (xx0 >> 3); - xx = xx0; - if (xx & 7) { - *p &= 0xff00 >> (xx & 7); - xx = (xx & ~7) + 8; - ++p; - } - for (; xx < xx1; xx += 8) { - *p++ = 0; - } - } - *x1 = splashFloor(xMax); - } - - // check the paths - for (i = 0; i < length; ++i) { - scanners[i]->clipAALine(aaBuf, x0, x1, y); - } - if (*x0 > *x1) { - *x0 = *x1; - } - if (*x0 < 0) { - *x0 = 0; - } - if ((*x0>>1) >= aaBuf->getRowSize()) { - xx0 = *x0; - *x0 = (aaBuf->getRowSize() - 1) << 1; - if (xx0 & 1) { - *x0 = *x0 + 1; - } - } - if (*x1 < *x0) { - *x1 = *x0; - } - if ((*x1>>1) >= aaBuf->getRowSize()) { - xx0 = *x1; - *x1 = (aaBuf->getRowSize() - 1) << 1; - if (xx0 & 1) { - *x1 = *x1 + 1; - } - } -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashClip.h b/Build/source/libs/poppler/poppler-src/splash/SplashClip.h deleted file mode 100644 index 5c0fdba99a7..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashClip.h +++ /dev/null @@ -1,152 +0,0 @@ -//======================================================================== -// -// SplashClip.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2010 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHCLIP_H -#define SPLASHCLIP_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "SplashTypes.h" -#include "SplashMath.h" -#include "SplashXPathScanner.h" - -class SplashPath; -class SplashXPath; -class SplashBitmap; - -//------------------------------------------------------------------------ - -enum SplashClipResult { - splashClipAllInside, - splashClipAllOutside, - splashClipPartial -}; - -//------------------------------------------------------------------------ -// SplashClip -//------------------------------------------------------------------------ - -class SplashClip { -public: - - // Create a clip, for the given rectangle. - SplashClip(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1, - GBool antialiasA); - - // Copy a clip. - SplashClip *copy() { return new SplashClip(this); } - - ~SplashClip(); - - // Reset the clip to a rectangle. - void resetToRect(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1); - - // Intersect the clip with a rectangle. - SplashError clipToRect(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1); - - // Interesect the clip with <path>. - SplashError clipToPath(SplashPath *path, SplashCoord *matrix, - SplashCoord flatness, GBool eo); - - // Returns true if (<x>,<y>) is inside the clip. - GBool test(int x, int y) - { - int i; - - // check the rectangle - if (x < xMinI || x > xMaxI || y < yMinI || y > yMaxI) { - return gFalse; - } - - // check the paths - if (antialias) { - for (i = 0; i < length; ++i) { - if (!scanners[i]->test(x * splashAASize, y * splashAASize)) { - return gFalse; - } - } - } else { - for (i = 0; i < length; ++i) { - if (!scanners[i]->test(x, y)) { - return gFalse; - } - } - } - - return gTrue; - } - - // Tests a rectangle against the clipping region. Returns one of: - // - splashClipAllInside if the entire rectangle is inside the - // clipping region, i.e., all pixels in the rectangle are - // visible - // - splashClipAllOutside if the entire rectangle is outside the - // clipping region, i.e., all the pixels in the rectangle are - // clipped - // - splashClipPartial if the rectangle is part inside and part - // outside the clipping region - SplashClipResult testRect(int rectXMin, int rectYMin, - int rectXMax, int rectYMax); - - // Similar to testRect, but tests a horizontal span. - SplashClipResult testSpan(int spanXMin, int spanXMax, int spanY); - - // Clips an anti-aliased line by setting pixels to zero. On entry, - // all non-zero pixels are between <x0> and <x1>. This function - // will update <x0> and <x1>. - void clipAALine(SplashBitmap *aaBuf, int *x0, int *x1, int y, - GBool adjustVertLine = gFalse); - - // Get the rectangle part of the clip region. - SplashCoord getXMin() { return xMin; } - SplashCoord getXMax() { return xMax; } - SplashCoord getYMin() { return yMin; } - SplashCoord getYMax() { return yMax; } - - // Get the rectangle part of the clip region, in integer coordinates. - int getXMinI() { return xMinI; } - int getXMaxI() { return xMaxI; } - int getYMinI() { return yMinI; } - int getYMaxI() { return yMaxI; } - - // Get the number of arbitrary paths used by the clip region. - int getNumPaths() { return length; } - -protected: - - SplashClip(SplashClip *clip); - void grow(int nPaths); - - GBool antialias; - SplashCoord xMin, yMin, xMax, yMax; - int xMinI, yMinI, xMaxI, yMaxI; - SplashXPath **paths; - Guchar *flags; - SplashXPathScanner **scanners; - int length, size; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashErrorCodes.h b/Build/source/libs/poppler/poppler-src/splash/SplashErrorCodes.h deleted file mode 100644 index d1f81f85dd8..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashErrorCodes.h +++ /dev/null @@ -1,50 +0,0 @@ -//======================================================================== -// -// SplashErrorCodes.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006, 2009 Albert Astals Cid <aacid@kde.org> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHERRORCODES_H -#define SPLASHERRORCODES_H - -//------------------------------------------------------------------------ - -#define splashOk 0 // no error - -#define splashErrNoCurPt 1 // no current point - -#define splashErrEmptyPath 2 // zero points in path - -#define splashErrBogusPath 3 // only one point in subpath - -#define splashErrNoSave 4 // state stack is empty - -#define splashErrOpenFile 5 // couldn't open file - -#define splashErrNoGlyph 6 // couldn't get the requested glyph - -#define splashErrModeMismatch 7 // invalid combination of color modes - -#define splashErrSingularMatrix 8 // matrix is singular - -#define splashErrBadArg 9 // bad argument - -#define splashErrZeroImage 254 // image of 0x0 - -#define splashErrGeneric 255 - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFTFont.cc b/Build/source/libs/poppler/poppler-src/splash/SplashFTFont.cc deleted file mode 100644 index 91226da0421..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFTFont.cc +++ /dev/null @@ -1,510 +0,0 @@ -//======================================================================== -// -// SplashFTFont.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2005, 2007-2011, 2014 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2006 Kristian Høgsberg <krh@bitplanet.net> -// Copyright (C) 2009 Petr Gajdos <pgajdos@novell.com> -// Copyright (C) 2010 Suzuki Toshiya <mpsuzuki@hiroshima-u.ac.jp> -// Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com> -// Copyright (C) 2012 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <ft2build.h> -#include FT_OUTLINE_H -#include FT_SIZES_H -#include FT_GLYPH_H -#include "goo/gmem.h" -#include "SplashMath.h" -#include "SplashGlyphBitmap.h" -#include "SplashPath.h" -#include "SplashFTFontEngine.h" -#include "SplashFTFontFile.h" -#include "SplashFTFont.h" - -//------------------------------------------------------------------------ - -static int glyphPathMoveTo(const FT_Vector *pt, void *path); -static int glyphPathLineTo(const FT_Vector *pt, void *path); -static int glyphPathConicTo(const FT_Vector *ctrl, const FT_Vector *pt, - void *path); -static int glyphPathCubicTo(const FT_Vector *ctrl1, const FT_Vector *ctrl2, - const FT_Vector *pt, void *path); - -//------------------------------------------------------------------------ -// SplashFTFont -//------------------------------------------------------------------------ - -SplashFTFont::SplashFTFont(SplashFTFontFile *fontFileA, SplashCoord *matA, - SplashCoord *textMatA): - SplashFont(fontFileA, matA, textMatA, fontFileA->engine->aa), - enableFreeTypeHinting(fontFileA->engine->enableFreeTypeHinting), - enableSlightHinting(fontFileA->engine->enableSlightHinting) -{ - FT_Face face; - int div; - int x, y; -#ifdef USE_FIXEDPOINT - SplashCoord scale; -#endif - - face = fontFileA->face; - if (FT_New_Size(face, &sizeObj)) { - return; - } - face->size = sizeObj; - size = splashRound(splashDist(0, 0, mat[2], mat[3])); - if (size < 1) { - size = 1; - } - if (FT_Set_Pixel_Sizes(face, 0, size)) { - return; - } - // if the textMat values are too small, FreeType's fixed point - // arithmetic doesn't work so well - textScale = splashDist(0, 0, textMat[2], textMat[3]) / size; - - div = face->bbox.xMax > 20000 ? 65536 : 1; - -#ifdef USE_FIXEDPOINT - scale = (SplashCoord)1 / (SplashCoord)face->units_per_EM; - - // transform the four corners of the font bounding box -- the min - // and max values form the bounding box of the transformed font - x = (int)(mat[0] * (scale * (face->bbox.xMin / div)) + - mat[2] * (scale * (face->bbox.yMin / div))); - xMin = xMax = x; - y = (int)(mat[1] * (scale * (face->bbox.xMin / div)) + - mat[3] * (scale * (face->bbox.yMin / div))); - yMin = yMax = y; - x = (int)(mat[0] * (scale * (face->bbox.xMin / div)) + - mat[2] * (scale * (face->bbox.yMax / div))); - if (x < xMin) { - xMin = x; - } else if (x > xMax) { - xMax = x; - } - y = (int)(mat[1] * (scale * (face->bbox.xMin / div)) + - mat[3] * (scale * (face->bbox.yMax / div))); - if (y < yMin) { - yMin = y; - } else if (y > yMax) { - yMax = y; - } - x = (int)(mat[0] * (scale * (face->bbox.xMax / div)) + - mat[2] * (scale * (face->bbox.yMin / div))); - if (x < xMin) { - xMin = x; - } else if (x > xMax) { - xMax = x; - } - y = (int)(mat[1] * (scale * (face->bbox.xMax / div)) + - mat[3] * (scale * (face->bbox.yMin / div))); - if (y < yMin) { - yMin = y; - } else if (y > yMax) { - yMax = y; - } - x = (int)(mat[0] * (scale * (face->bbox.xMax / div)) + - mat[2] * (scale * (face->bbox.yMax / div))); - if (x < xMin) { - xMin = x; - } else if (x > xMax) { - xMax = x; - } - y = (int)(mat[1] * (scale * (face->bbox.xMax / div)) + - mat[3] * (scale * (face->bbox.yMax / div))); - if (y < yMin) { - yMin = y; - } else if (y > yMax) { - yMax = y; - } -#else // USE_FIXEDPOINT - // transform the four corners of the font bounding box -- the min - // and max values form the bounding box of the transformed font - x = (int)((mat[0] * face->bbox.xMin + mat[2] * face->bbox.yMin) / - (div * face->units_per_EM)); - xMin = xMax = x; - y = (int)((mat[1] * face->bbox.xMin + mat[3] * face->bbox.yMin) / - (div * face->units_per_EM)); - yMin = yMax = y; - x = (int)((mat[0] * face->bbox.xMin + mat[2] * face->bbox.yMax) / - (div * face->units_per_EM)); - if (x < xMin) { - xMin = x; - } else if (x > xMax) { - xMax = x; - } - y = (int)((mat[1] * face->bbox.xMin + mat[3] * face->bbox.yMax) / - (div * face->units_per_EM)); - if (y < yMin) { - yMin = y; - } else if (y > yMax) { - yMax = y; - } - x = (int)((mat[0] * face->bbox.xMax + mat[2] * face->bbox.yMin) / - (div * face->units_per_EM)); - if (x < xMin) { - xMin = x; - } else if (x > xMax) { - xMax = x; - } - y = (int)((mat[1] * face->bbox.xMax + mat[3] * face->bbox.yMin) / - (div * face->units_per_EM)); - if (y < yMin) { - yMin = y; - } else if (y > yMax) { - yMax = y; - } - x = (int)((mat[0] * face->bbox.xMax + mat[2] * face->bbox.yMax) / - (div * face->units_per_EM)); - if (x < xMin) { - xMin = x; - } else if (x > xMax) { - xMax = x; - } - y = (int)((mat[1] * face->bbox.xMax + mat[3] * face->bbox.yMax) / - (div * face->units_per_EM)); - if (y < yMin) { - yMin = y; - } else if (y > yMax) { - yMax = y; - } -#endif // USE_FIXEDPOINT - // This is a kludge: some buggy PDF generators embed fonts with - // zero bounding boxes. - if (xMax == xMin) { - xMin = 0; - xMax = size; - } - if (yMax == yMin) { - yMin = 0; - yMax = (int)((SplashCoord)1.2 * size); - } - - // compute the transform matrix -#ifdef USE_FIXEDPOINT - matrix.xx = (FT_Fixed)((mat[0] / size).get16Dot16()); - matrix.yx = (FT_Fixed)((mat[1] / size).get16Dot16()); - matrix.xy = (FT_Fixed)((mat[2] / size).get16Dot16()); - matrix.yy = (FT_Fixed)((mat[3] / size).get16Dot16()); - textMatrix.xx = (FT_Fixed)((textMat[0] / (textScale * size)).get16Dot16()); - textMatrix.yx = (FT_Fixed)((textMat[1] / (textScale * size)).get16Dot16()); - textMatrix.xy = (FT_Fixed)((textMat[2] / (textScale * size)).get16Dot16()); - textMatrix.yy = (FT_Fixed)((textMat[3] / (textScale * size)).get16Dot16()); -#else - matrix.xx = (FT_Fixed)((mat[0] / size) * 65536); - matrix.yx = (FT_Fixed)((mat[1] / size) * 65536); - matrix.xy = (FT_Fixed)((mat[2] / size) * 65536); - matrix.yy = (FT_Fixed)((mat[3] / size) * 65536); - textMatrix.xx = (FT_Fixed)((textMat[0] / (textScale * size)) * 65536); - textMatrix.yx = (FT_Fixed)((textMat[1] / (textScale * size)) * 65536); - textMatrix.xy = (FT_Fixed)((textMat[2] / (textScale * size)) * 65536); - textMatrix.yy = (FT_Fixed)((textMat[3] / (textScale * size)) * 65536); -#endif -} - -SplashFTFont::~SplashFTFont() { -} - -GBool SplashFTFont::getGlyph(int c, int xFrac, int yFrac, - SplashGlyphBitmap *bitmap, int x0, int y0, SplashClip *clip, SplashClipResult *clipRes) { - return SplashFont::getGlyph(c, xFrac, 0, bitmap, x0, y0, clip, clipRes); -} - -static FT_Int32 getFTLoadFlags(GBool type1, GBool trueType, GBool aa, GBool enableFreeTypeHinting, GBool enableSlightHinting) -{ - int ret = FT_LOAD_DEFAULT; - if (aa) - ret |= FT_LOAD_NO_BITMAP; - - if (enableFreeTypeHinting) { - if (enableSlightHinting) { - ret |= FT_LOAD_TARGET_LIGHT; - } else { - if (trueType) { - // FT2's autohinting doesn't always work very well (especially with - // font subsets), so turn it off if anti-aliasing is enabled; if - // anti-aliasing is disabled, this seems to be a tossup - some fonts - // look better with hinting, some without, so leave hinting on - if (aa) { - ret |= FT_LOAD_NO_AUTOHINT; - } - } else if (type1) { - // Type 1 fonts seem to look better with 'light' hinting mode - ret |= FT_LOAD_TARGET_LIGHT; - } - } - } else { - ret |= FT_LOAD_NO_HINTING; - } - return ret; -} - -GBool SplashFTFont::makeGlyph(int c, int xFrac, int yFrac, - SplashGlyphBitmap *bitmap, int x0, int y0, SplashClip *clip, SplashClipResult *clipRes) { - SplashFTFontFile *ff; - FT_Vector offset; - FT_GlyphSlot slot; - FT_UInt gid; - int rowSize; - Guchar *p, *q; - int i; - - ff = (SplashFTFontFile *)fontFile; - - ff->face->size = sizeObj; - offset.x = (FT_Pos)(int)((SplashCoord)xFrac * splashFontFractionMul * 64); - offset.y = 0; - FT_Set_Transform(ff->face, &matrix, &offset); - slot = ff->face->glyph; - - if (ff->codeToGID && c < ff->codeToGIDLen && c >= 0) { - gid = (FT_UInt)ff->codeToGID[c]; - } else { - gid = (FT_UInt)c; - } - - if (FT_Load_Glyph(ff->face, gid, getFTLoadFlags(ff->type1, ff->trueType, aa, enableFreeTypeHinting, enableSlightHinting))) { - return gFalse; - } - - // prelimirary values based on FT_Outline_Get_CBox - // we add two pixels to each side to be in the safe side - FT_BBox cbox; - FT_Outline_Get_CBox(&ff->face->glyph->outline, &cbox); - bitmap->x = -(cbox.xMin / 64) + 2; - bitmap->y = (cbox.yMax / 64) + 2; - bitmap->w = ((cbox.xMax - cbox.xMin) / 64) + 4; - bitmap->h = ((cbox.yMax - cbox.yMin) / 64) + 4; - - *clipRes = clip->testRect(x0 - bitmap->x, - y0 - bitmap->y, - x0 - bitmap->x + bitmap->w, - y0 - bitmap->y + bitmap->h); - if (*clipRes == splashClipAllOutside) { - bitmap->freeData = gFalse; - return gTrue; - } - - if (FT_Render_Glyph(slot, aa ? ft_render_mode_normal - : ft_render_mode_mono)) { - return gFalse; - } - - if (slot->bitmap.width == 0 || slot->bitmap.rows == 0) { - // this can happen if (a) the glyph is really tiny or (b) the - // metrics in the TrueType file are broken - return gFalse; - } - - bitmap->x = -slot->bitmap_left; - bitmap->y = slot->bitmap_top; - bitmap->w = slot->bitmap.width; - bitmap->h = slot->bitmap.rows; - bitmap->aa = aa; - if (aa) { - rowSize = bitmap->w; - } else { - rowSize = (bitmap->w + 7) >> 3; - } - bitmap->data = (Guchar *)gmallocn_checkoverflow(rowSize, bitmap->h); - if (!bitmap->data) { - return gFalse; - } - bitmap->freeData = gTrue; - for (i = 0, p = bitmap->data, q = slot->bitmap.buffer; - i < bitmap->h; - ++i, p += rowSize, q += slot->bitmap.pitch) { - memcpy(p, q, rowSize); - } - - return gTrue; -} - -double SplashFTFont::getGlyphAdvance(int c) -{ - SplashFTFontFile *ff; - FT_Vector offset; - FT_UInt gid; - FT_Matrix identityMatrix; - - ff = (SplashFTFontFile *)fontFile; - - // init the matrix - identityMatrix.xx = 65536; // 1 in 16.16 format - identityMatrix.xy = 0; - identityMatrix.yx = 0; - identityMatrix.yy = 65536; // 1 in 16.16 format - - // init the offset - offset.x = 0; - offset.y = 0; - - ff->face->size = sizeObj; - FT_Set_Transform(ff->face, &identityMatrix, &offset); - - if (ff->codeToGID && c < ff->codeToGIDLen) { - gid = (FT_UInt)ff->codeToGID[c]; - } else { - gid = (FT_UInt)c; - } - - if (FT_Load_Glyph(ff->face, gid, getFTLoadFlags(ff->type1, ff->trueType, aa, enableFreeTypeHinting, enableSlightHinting))) { - return -1; - } - - // 64.0 is 1 in 26.6 format - return ff->face->glyph->metrics.horiAdvance / 64.0 / size; -} - -struct SplashFTFontPath { - SplashPath *path; - SplashCoord textScale; - GBool needClose; -}; - -SplashPath *SplashFTFont::getGlyphPath(int c) { - static FT_Outline_Funcs outlineFuncs = { -#if FREETYPE_MINOR <= 1 - (int (*)(FT_Vector *, void *))&glyphPathMoveTo, - (int (*)(FT_Vector *, void *))&glyphPathLineTo, - (int (*)(FT_Vector *, FT_Vector *, void *))&glyphPathConicTo, - (int (*)(FT_Vector *, FT_Vector *, FT_Vector *, void *))&glyphPathCubicTo, -#else - &glyphPathMoveTo, - &glyphPathLineTo, - &glyphPathConicTo, - &glyphPathCubicTo, -#endif - 0, 0 - }; - SplashFTFontFile *ff; - SplashFTFontPath path; - FT_GlyphSlot slot; - FT_UInt gid; - FT_Glyph glyph; - - ff = (SplashFTFontFile *)fontFile; - ff->face->size = sizeObj; - FT_Set_Transform(ff->face, &textMatrix, NULL); - slot = ff->face->glyph; - if (ff->codeToGID && c < ff->codeToGIDLen && c >= 0) { - gid = ff->codeToGID[c]; - } else { - gid = (FT_UInt)c; - } - if (FT_Load_Glyph(ff->face, gid, getFTLoadFlags(ff->type1, ff->trueType, aa, enableFreeTypeHinting, enableSlightHinting))) { - return NULL; - } - if (FT_Get_Glyph(slot, &glyph)) { - return NULL; - } - if (FT_Outline_Check(&((FT_OutlineGlyph)glyph)->outline)) { - return NULL; - } - path.path = new SplashPath(); - path.textScale = textScale; - path.needClose = gFalse; - FT_Outline_Decompose(&((FT_OutlineGlyph)glyph)->outline, - &outlineFuncs, &path); - if (path.needClose) { - path.path->close(); - } - FT_Done_Glyph(glyph); - return path.path; -} - -static int glyphPathMoveTo(const FT_Vector *pt, void *path) { - SplashFTFontPath *p = (SplashFTFontPath *)path; - - if (p->needClose) { - p->path->close(); - p->needClose = gFalse; - } - p->path->moveTo((SplashCoord)pt->x * p->textScale / 64.0, - (SplashCoord)pt->y * p->textScale / 64.0); - return 0; -} - -static int glyphPathLineTo(const FT_Vector *pt, void *path) { - SplashFTFontPath *p = (SplashFTFontPath *)path; - - p->path->lineTo((SplashCoord)pt->x * p->textScale / 64.0, - (SplashCoord)pt->y * p->textScale / 64.0); - p->needClose = gTrue; - return 0; -} - -static int glyphPathConicTo(const FT_Vector *ctrl, const FT_Vector *pt, - void *path) { - SplashFTFontPath *p = (SplashFTFontPath *)path; - SplashCoord x0, y0, x1, y1, x2, y2, x3, y3, xc, yc; - - if (!p->path->getCurPt(&x0, &y0)) { - return 0; - } - xc = (SplashCoord)ctrl->x * p->textScale / 64.0; - yc = (SplashCoord)ctrl->y * p->textScale / 64.0; - x3 = (SplashCoord)pt->x * p->textScale / 64.0; - y3 = (SplashCoord)pt->y * p->textScale / 64.0; - - // A second-order Bezier curve is defined by two endpoints, p0 and - // p3, and one control point, pc: - // - // p(t) = (1-t)^2*p0 + t*(1-t)*pc + t^2*p3 - // - // A third-order Bezier curve is defined by the same two endpoints, - // p0 and p3, and two control points, p1 and p2: - // - // p(t) = (1-t)^3*p0 + 3t*(1-t)^2*p1 + 3t^2*(1-t)*p2 + t^3*p3 - // - // Applying some algebra, we can convert a second-order curve to a - // third-order curve: - // - // p1 = (1/3) * (p0 + 2pc) - // p2 = (1/3) * (2pc + p3) - - x1 = (SplashCoord)(1.0 / 3.0) * (x0 + (SplashCoord)2 * xc); - y1 = (SplashCoord)(1.0 / 3.0) * (y0 + (SplashCoord)2 * yc); - x2 = (SplashCoord)(1.0 / 3.0) * ((SplashCoord)2 * xc + x3); - y2 = (SplashCoord)(1.0 / 3.0) * ((SplashCoord)2 * yc + y3); - - p->path->curveTo(x1, y1, x2, y2, x3, y3); - p->needClose = gTrue; - return 0; -} - -static int glyphPathCubicTo(const FT_Vector *ctrl1, const FT_Vector *ctrl2, - const FT_Vector *pt, void *path) { - SplashFTFontPath *p = (SplashFTFontPath *)path; - - p->path->curveTo((SplashCoord)ctrl1->x * p->textScale / 64.0, - (SplashCoord)ctrl1->y * p->textScale / 64.0, - (SplashCoord)ctrl2->x * p->textScale / 64.0, - (SplashCoord)ctrl2->y * p->textScale / 64.0, - (SplashCoord)pt->x * p->textScale / 64.0, - (SplashCoord)pt->y * p->textScale / 64.0); - p->needClose = gTrue; - return 0; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFTFont.h b/Build/source/libs/poppler/poppler-src/splash/SplashFTFont.h deleted file mode 100644 index 5f0d197669b..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFTFont.h +++ /dev/null @@ -1,77 +0,0 @@ -//======================================================================== -// -// SplashFTFont.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2007-2009, 2011 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2009 Petr Gajdos <pgajdos@novell.com> -// Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHFTFONT_H -#define SPLASHFTFONT_H - -#include "poppler-config.h" - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include <ft2build.h> -#include FT_FREETYPE_H -#include "SplashFont.h" - -class SplashFTFontFile; - -//------------------------------------------------------------------------ -// SplashFTFont -//------------------------------------------------------------------------ - -class SplashFTFont: public SplashFont { -public: - - SplashFTFont(SplashFTFontFile *fontFileA, SplashCoord *matA, - SplashCoord *textMatA); - - virtual ~SplashFTFont(); - - // Munge xFrac and yFrac before calling SplashFont::getGlyph. - GBool getGlyph(int c, int xFrac, int yFrac, - SplashGlyphBitmap *bitmap, int x0, int y0, SplashClip *clip, SplashClipResult *clipRes) override; - - // Rasterize a glyph. The <xFrac> and <yFrac> values are the same - // as described for getGlyph. - GBool makeGlyph(int c, int xFrac, int yFrac, - SplashGlyphBitmap *bitmap, int x0, int y0, SplashClip *clip, SplashClipResult *clipRes) override; - - // Return the path for a glyph. - SplashPath *getGlyphPath(int c) override; - - // Return the advance of a glyph. (in 0..1 range) - double getGlyphAdvance(int c) override; - -private: - - FT_Size sizeObj; - FT_Matrix matrix; - FT_Matrix textMatrix; - SplashCoord textScale; - int size; - GBool enableFreeTypeHinting; - GBool enableSlightHinting; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFTFontEngine.cc b/Build/source/libs/poppler/poppler-src/splash/SplashFTFontEngine.cc deleted file mode 100644 index 9b20f4a17ab..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFTFontEngine.cc +++ /dev/null @@ -1,177 +0,0 @@ -//======================================================================== -// -// SplashFTFontEngine.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de> -// Copyright (C) 2009, 2011, 2012 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2009 Petr Gajdos <pgajdos@novell.com> -// Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <stdio.h> -#ifdef HAVE_UNISTD_H -#include <unistd.h> -#endif -#include "goo/gmem.h" -#include "goo/GooString.h" -#include "goo/gfile.h" -#include "fofi/FoFiTrueType.h" -#include "fofi/FoFiType1C.h" -#include "SplashFTFontFile.h" -#include "SplashFTFontEngine.h" - -#ifdef VMS -#if (__VMS_VER < 70000000) -extern "C" int unlink(char *filename); -#endif -#endif - -//------------------------------------------------------------------------ -// SplashFTFontEngine -//------------------------------------------------------------------------ - -SplashFTFontEngine::SplashFTFontEngine(GBool aaA, GBool enableFreeTypeHintingA, - GBool enableSlightHintingA, FT_Library libA) { - FT_Int major, minor, patch; - - aa = aaA; - enableFreeTypeHinting = enableFreeTypeHintingA; - enableSlightHinting = enableSlightHintingA; - lib = libA; - - // as of FT 2.1.8, CID fonts are indexed by CID instead of GID - FT_Library_Version(lib, &major, &minor, &patch); - useCIDs = major > 2 || - (major == 2 && (minor > 1 || (minor == 1 && patch > 7))); -} - -SplashFTFontEngine *SplashFTFontEngine::init(GBool aaA, GBool enableFreeTypeHintingA, - GBool enableSlightHintingA) { - FT_Library libA; - - if (FT_Init_FreeType(&libA)) { - return NULL; - } - return new SplashFTFontEngine(aaA, enableFreeTypeHintingA, enableSlightHintingA, libA); -} - -SplashFTFontEngine::~SplashFTFontEngine() { - FT_Done_FreeType(lib); -} - -SplashFontFile *SplashFTFontEngine::loadType1Font(SplashFontFileID *idA, - SplashFontSrc *src, - const char **enc) { - return SplashFTFontFile::loadType1Font(this, idA, src, enc); -} - -SplashFontFile *SplashFTFontEngine::loadType1CFont(SplashFontFileID *idA, - SplashFontSrc *src, - const char **enc) { - return SplashFTFontFile::loadType1Font(this, idA, src, enc); -} - -SplashFontFile *SplashFTFontEngine::loadOpenTypeT1CFont(SplashFontFileID *idA, - SplashFontSrc *src, - const char **enc) { - return SplashFTFontFile::loadType1Font(this, idA, src, enc); -} - -SplashFontFile *SplashFTFontEngine::loadCIDFont(SplashFontFileID *idA, - SplashFontSrc *src) { - FoFiType1C *ff; - int *cidToGIDMap; - int nCIDs; - SplashFontFile *ret; - - // check for a CFF font - if (useCIDs) { - cidToGIDMap = NULL; - nCIDs = 0; - } else { - if (src->isFile) { - ff = FoFiType1C::load(src->fileName->getCString()); - } else { - ff = FoFiType1C::make(src->buf, src->bufLen); - } - if (ff) { - cidToGIDMap = ff->getCIDToGIDMap(&nCIDs); - delete ff; - } else { - cidToGIDMap = NULL; - nCIDs = 0; - } - } - ret = SplashFTFontFile::loadCIDFont(this, idA, src, cidToGIDMap, nCIDs); - if (!ret) { - gfree(cidToGIDMap); - } - return ret; -} - -SplashFontFile *SplashFTFontEngine::loadOpenTypeCFFFont(SplashFontFileID *idA, - SplashFontSrc *src, - int *codeToGID, - int codeToGIDLen) { - FoFiTrueType *ff; - int *cidToGIDMap; - int nCIDs; - SplashFontFile *ret; - - cidToGIDMap = NULL; - nCIDs = 0; - if (!codeToGID) { - if (!useCIDs) { - if (src->isFile) { - ff = FoFiTrueType::load(src->fileName->getCString()); - } else { - ff = FoFiTrueType::make(src->buf, src->bufLen); - } - if (ff) { - if (ff->isOpenTypeCFF()) { - cidToGIDMap = ff->getCIDToGIDMap(&nCIDs); - } - delete ff; - } - } - } - ret = SplashFTFontFile::loadCIDFont(this, idA, src, - codeToGID ? codeToGID : cidToGIDMap, - codeToGID ? codeToGIDLen : nCIDs); - if (!ret) { - gfree(cidToGIDMap); - } - return ret; -} - -SplashFontFile *SplashFTFontEngine::loadTrueTypeFont(SplashFontFileID *idA, - SplashFontSrc *src, - int *codeToGID, - int codeToGIDLen, - int faceIndex) { - SplashFontFile *ret; - ret = SplashFTFontFile::loadTrueTypeFont(this, idA, src, - codeToGID, codeToGIDLen, - faceIndex); - return ret; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFTFontEngine.h b/Build/source/libs/poppler/poppler-src/splash/SplashFTFontEngine.h deleted file mode 100644 index 899458bc5a7..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFTFontEngine.h +++ /dev/null @@ -1,78 +0,0 @@ -//======================================================================== -// -// SplashFTFontEngine.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de> -// Copyright (C) 2009 Petr Gajdos <pgajdos@novell.com> -// Copyright (C) 2009 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com> -// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHFTFONTENGINE_H -#define SPLASHFTFONTENGINE_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include <ft2build.h> -#include FT_FREETYPE_H -#include "goo/gtypes.h" - -class SplashFontFile; -class SplashFontFileID; -class SplashFontSrc; - -//------------------------------------------------------------------------ -// SplashFTFontEngine -//------------------------------------------------------------------------ - -class SplashFTFontEngine { -public: - - static SplashFTFontEngine *init(GBool aaA, GBool enableFreeTypeHintingA, GBool enableSlightHinting); - - ~SplashFTFontEngine(); - - // Load fonts. - SplashFontFile *loadType1Font(SplashFontFileID *idA, SplashFontSrc *src, const char **enc); - SplashFontFile *loadType1CFont(SplashFontFileID *idA, SplashFontSrc *src, const char **enc); - SplashFontFile *loadOpenTypeT1CFont(SplashFontFileID *idA, SplashFontSrc *src, const char **enc); - SplashFontFile *loadCIDFont(SplashFontFileID *idA, SplashFontSrc *src); - SplashFontFile *loadOpenTypeCFFFont(SplashFontFileID *idA, SplashFontSrc *src, - int *codeToGID, int codeToGIDLen); - SplashFontFile *loadTrueTypeFont(SplashFontFileID *idA, SplashFontSrc *src, - int *codeToGID, int codeToGIDLen, int faceIndex = 0); - GBool getAA() { return aa; } - void setAA(GBool aaA) { aa = aaA; } - -private: - - SplashFTFontEngine(GBool aaA, GBool enableFreeTypeHintingA, GBool enableSlightHintingA, FT_Library libA); - - GBool aa; - GBool enableFreeTypeHinting; - GBool enableSlightHinting; - FT_Library lib; - GBool useCIDs; - - friend class SplashFTFontFile; - friend class SplashFTFont; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFTFontFile.cc b/Build/source/libs/poppler/poppler-src/splash/SplashFTFontFile.cc deleted file mode 100644 index 3c070b70178..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFTFontFile.cc +++ /dev/null @@ -1,149 +0,0 @@ -//======================================================================== -// -// SplashFTFontFile.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de> -// Copyright (C) 2014, 2017 Adrian Johnson <ajohnson@redneon.com> -// Copyright (C) 2017 Oliver Sander <oliver.sander@tu-dresden.de> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include "goo/gmem.h" -#include "goo/GooString.h" -#include "poppler/GfxFont.h" -#include "SplashFTFontEngine.h" -#include "SplashFTFont.h" -#include "SplashFTFontFile.h" - -//------------------------------------------------------------------------ -// SplashFTFontFile -//------------------------------------------------------------------------ - -SplashFontFile *SplashFTFontFile::loadType1Font(SplashFTFontEngine *engineA, - SplashFontFileID *idA, - SplashFontSrc *src, - const char **encA) { - FT_Face faceA; - int *codeToGIDA; - const char *name; - int i; - - if (src->isFile) { - if (FT_New_Face(engineA->lib, src->fileName->getCString(), 0, &faceA)) - return NULL; - } else { - if (FT_New_Memory_Face(engineA->lib, (const FT_Byte *)src->buf, src->bufLen, 0, &faceA)) - return NULL; - } - codeToGIDA = (int *)gmallocn(256, sizeof(int)); - for (i = 0; i < 256; ++i) { - codeToGIDA[i] = 0; - if ((name = encA[i])) { - codeToGIDA[i] = (int)FT_Get_Name_Index(faceA, (char *)name); - if (codeToGIDA[i] == 0) { - name = GfxFont::getAlternateName(name); - if (name) { - codeToGIDA[i] = FT_Get_Name_Index(faceA, (char *)name); - } - } - } - } - - return new SplashFTFontFile(engineA, idA, src, - faceA, codeToGIDA, 256, gFalse, gTrue); -} - -SplashFontFile *SplashFTFontFile::loadCIDFont(SplashFTFontEngine *engineA, - SplashFontFileID *idA, - SplashFontSrc *src, - int *codeToGIDA, - int codeToGIDLenA) { - FT_Face faceA; - - if (src->isFile) { - if (FT_New_Face(engineA->lib, src->fileName->getCString(), 0, &faceA)) - return NULL; - } else { - if (FT_New_Memory_Face(engineA->lib, (const FT_Byte *)src->buf, src->bufLen, 0, &faceA)) - return NULL; - } - - return new SplashFTFontFile(engineA, idA, src, - faceA, codeToGIDA, codeToGIDLenA, gFalse, gFalse); -} - -SplashFontFile *SplashFTFontFile::loadTrueTypeFont(SplashFTFontEngine *engineA, - SplashFontFileID *idA, - SplashFontSrc *src, - int *codeToGIDA, - int codeToGIDLenA, - int faceIndexA) { - FT_Face faceA; - - if (src->isFile) { - if (FT_New_Face(engineA->lib, src->fileName->getCString(), faceIndexA, &faceA)) - return NULL; - } else { - if (FT_New_Memory_Face(engineA->lib, (const FT_Byte *)src->buf, src->bufLen, faceIndexA, &faceA)) - return NULL; - } - - return new SplashFTFontFile(engineA, idA, src, - faceA, codeToGIDA, codeToGIDLenA, gTrue, gFalse); -} - -SplashFTFontFile::SplashFTFontFile(SplashFTFontEngine *engineA, - SplashFontFileID *idA, - SplashFontSrc *src, - FT_Face faceA, - int *codeToGIDA, int codeToGIDLenA, - GBool trueTypeA, GBool type1A): - SplashFontFile(idA, src) -{ - engine = engineA; - face = faceA; - codeToGID = codeToGIDA; - codeToGIDLen = codeToGIDLenA; - trueType = trueTypeA; - type1 = type1A; -} - -SplashFTFontFile::~SplashFTFontFile() { - if (face) { - FT_Done_Face(face); - } - if (codeToGID) { - gfree(codeToGID); - } -} - -SplashFont *SplashFTFontFile::makeFont(SplashCoord *mat, - SplashCoord *textMat) { - SplashFont *font; - - font = new SplashFTFont(this, mat, textMat); - font->initCache(); - return font; -} - -int *SplashFTFontFile::getCodeToGID() { - return codeToGID; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFTFontFile.h b/Build/source/libs/poppler/poppler-src/splash/SplashFTFontFile.h deleted file mode 100644 index 5931be3fe73..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFTFontFile.h +++ /dev/null @@ -1,87 +0,0 @@ -//======================================================================== -// -// SplashFTFontFile.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de> -// Copyright (C) 2017 Oliver Sander <oliver.sander@tu-dresden.de> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHFTFONTFILE_H -#define SPLASHFTFONTFILE_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include <ft2build.h> -#include FT_FREETYPE_H -#include "SplashFontFile.h" - -class SplashFontFileID; -class SplashFTFontEngine; - -//------------------------------------------------------------------------ -// SplashFTFontFile -//------------------------------------------------------------------------ - -class SplashFTFontFile: public SplashFontFile { -public: - - static SplashFontFile *loadType1Font(SplashFTFontEngine *engineA, - SplashFontFileID *idA, - SplashFontSrc *src, const char **encA); - static SplashFontFile *loadCIDFont(SplashFTFontEngine *engineA, - SplashFontFileID *idA, - SplashFontSrc *src, - int *codeToCIDA, int codeToGIDLenA); - static SplashFontFile *loadTrueTypeFont(SplashFTFontEngine *engineA, - SplashFontFileID *idA, - SplashFontSrc *src, - int *codeToGIDA, - int codeToGIDLenA, - int faceIndexA=0); - - ~SplashFTFontFile(); - - // Create a new SplashFTFont, i.e., a scaled instance of this font - // file. - SplashFont *makeFont(SplashCoord *mat, - SplashCoord *textMat) override; - - // Provide access to the code-to-GID map - int* getCodeToGID(); - -private: - - SplashFTFontFile(SplashFTFontEngine *engineA, - SplashFontFileID *idA, - SplashFontSrc *src, - FT_Face faceA, - int *codeToGIDA, int codeToGIDLenA, - GBool trueTypeA, GBool type1A); - - SplashFTFontEngine *engine; - FT_Face face; - int *codeToGID; - int codeToGIDLen; - GBool trueType; - GBool type1; - - friend class SplashFTFont; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFont.cc b/Build/source/libs/poppler/poppler-src/splash/SplashFont.cc deleted file mode 100644 index 3d6d6b2343e..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFont.cc +++ /dev/null @@ -1,224 +0,0 @@ -//======================================================================== -// -// SplashFont.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2007-2008, 2010, 2014 Albert Astals Cid <aacid@kde.org> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <limits.h> -#include <string.h> -#include "goo/gmem.h" -#include "SplashMath.h" -#include "SplashGlyphBitmap.h" -#include "SplashFontFile.h" -#include "SplashFont.h" - -//------------------------------------------------------------------------ - -struct SplashFontCacheTag { - int c; - short xFrac, yFrac; // x and y fractions - int mru; // valid bit (0x80000000) and MRU index - int x, y, w, h; // offset and size of glyph -}; - -//------------------------------------------------------------------------ -// SplashFont -//------------------------------------------------------------------------ - -SplashFont::SplashFont(SplashFontFile *fontFileA, SplashCoord *matA, - SplashCoord *textMatA, GBool aaA) { - fontFile = fontFileA; - fontFile->incRefCnt(); - mat[0] = matA[0]; - mat[1] = matA[1]; - mat[2] = matA[2]; - mat[3] = matA[3]; - textMat[0] = textMatA[0]; - textMat[1] = textMatA[1]; - textMat[2] = textMatA[2]; - textMat[3] = textMatA[3]; - aa = aaA; - - cache = NULL; - cacheTags = NULL; - - xMin = yMin = xMax = yMax = 0; -} - -void SplashFont::initCache() { - int i; - - // this should be (max - min + 1), but we add some padding to - // deal with rounding errors - glyphW = xMax - xMin + 3; - glyphH = yMax - yMin + 3; - if (glyphW > INT_MAX / glyphH) { - glyphSize = -1; - } else { - if (aa) { - glyphSize = glyphW * glyphH; - } else { - glyphSize = ((glyphW + 7) >> 3) * glyphH; - } - } - - // set up the glyph pixmap cache - cacheAssoc = 8; - if (glyphSize <= 64) { - cacheSets = 32; - } else if (glyphSize <= 128) { - cacheSets = 16; - } else if (glyphSize <= 256) { - cacheSets = 8; - } else if (glyphSize <= 512) { - cacheSets = 4; - } else if (glyphSize <= 1024) { - cacheSets = 2; - } else { - cacheSets = 1; - } - cache = (Guchar *)gmallocn_checkoverflow(cacheSets* cacheAssoc, glyphSize); - if (cache != NULL) { - cacheTags = (SplashFontCacheTag *)gmallocn(cacheSets * cacheAssoc, - sizeof(SplashFontCacheTag)); - for (i = 0; i < cacheSets * cacheAssoc; ++i) { - cacheTags[i].mru = i & (cacheAssoc - 1); - } - } else { - cacheAssoc = 0; - } -} - -SplashFont::~SplashFont() { - fontFile->decRefCnt(); - if (cache) { - gfree(cache); - } - if (cacheTags) { - gfree(cacheTags); - } -} - -GBool SplashFont::getGlyph(int c, int xFrac, int yFrac, - SplashGlyphBitmap *bitmap, int x0, int y0, SplashClip *clip, SplashClipResult *clipRes) { - SplashGlyphBitmap bitmap2; - int size; - Guchar *p; - int i, j, k; - - // no fractional coordinates for large glyphs or non-anti-aliased - // glyphs - if (!aa || glyphH > 50) { - xFrac = yFrac = 0; - } - - // check the cache - i = (c & (cacheSets - 1)) * cacheAssoc; - for (j = 0; j < cacheAssoc; ++j) { - if ((cacheTags[i+j].mru & 0x80000000) && - cacheTags[i+j].c == c && - (int)cacheTags[i+j].xFrac == xFrac && - (int)cacheTags[i+j].yFrac == yFrac) { - bitmap->x = cacheTags[i+j].x; - bitmap->y = cacheTags[i+j].y; - bitmap->w = cacheTags[i+j].w; - bitmap->h = cacheTags[i+j].h; - for (k = 0; k < cacheAssoc; ++k) { - if (k != j && - (cacheTags[i+k].mru & 0x7fffffff) < - (cacheTags[i+j].mru & 0x7fffffff)) { - ++cacheTags[i+k].mru; - } - } - cacheTags[i+j].mru = 0x80000000; - bitmap->aa = aa; - bitmap->data = cache + (i+j) * glyphSize; - bitmap->freeData = gFalse; - - *clipRes = clip->testRect(x0 - bitmap->x, - y0 - bitmap->y, - x0 - bitmap->x + bitmap->w - 1, - y0 - bitmap->y + bitmap->h - 1); - - return gTrue; - } - } - - // generate the glyph bitmap - if (!makeGlyph(c, xFrac, yFrac, &bitmap2, x0, y0, clip, clipRes)) { - return gFalse; - } - - if (*clipRes == splashClipAllOutside) - { - bitmap->freeData = gFalse; - if (bitmap2.freeData) gfree(bitmap2.data); - return gTrue; - } - - // if the glyph doesn't fit in the bounding box, return a temporary - // uncached bitmap - if (bitmap2.w > glyphW || bitmap2.h > glyphH) { - *bitmap = bitmap2; - return gTrue; - } - - // insert glyph pixmap in cache - if (aa) { - size = bitmap2.w * bitmap2.h; - } else { - size = ((bitmap2.w + 7) >> 3) * bitmap2.h; - } - p = NULL; // make gcc happy - if (cacheAssoc == 0) - { - // we had problems on the malloc of the cache, so ignore it - *bitmap = bitmap2; - } - else - { - for (j = 0; j < cacheAssoc; ++j) { - if ((cacheTags[i+j].mru & 0x7fffffff) == cacheAssoc - 1) { - cacheTags[i+j].mru = 0x80000000; - cacheTags[i+j].c = c; - cacheTags[i+j].xFrac = (short)xFrac; - cacheTags[i+j].yFrac = (short)yFrac; - cacheTags[i+j].x = bitmap2.x; - cacheTags[i+j].y = bitmap2.y; - cacheTags[i+j].w = bitmap2.w; - cacheTags[i+j].h = bitmap2.h; - p = cache + (i+j) * glyphSize; - memcpy(p, bitmap2.data, size); - } else { - ++cacheTags[i+j].mru; - } - } - *bitmap = bitmap2; - bitmap->data = p; - bitmap->freeData = gFalse; - if (bitmap2.freeData) { - gfree(bitmap2.data); - } - } - return gTrue; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFont.h b/Build/source/libs/poppler/poppler-src/splash/SplashFont.h deleted file mode 100644 index 78b00d2dcaf..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFont.h +++ /dev/null @@ -1,121 +0,0 @@ -//======================================================================== -// -// SplashFont.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2007-2008 Albert Astals Cid <aacid@kde.org> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHFONT_H -#define SPLASHFONT_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "goo/gtypes.h" -#include "SplashTypes.h" -#include "SplashClip.h" - -struct SplashGlyphBitmap; -struct SplashFontCacheTag; -class SplashFontFile; -class SplashPath; - -//------------------------------------------------------------------------ - -// Fractional positioning uses this many bits to the right of the -// decimal points. -#define splashFontFractionBits 2 -#define splashFontFraction (1 << splashFontFractionBits) -#define splashFontFractionMul \ - ((SplashCoord)1 / (SplashCoord)splashFontFraction) - -//------------------------------------------------------------------------ -// SplashFont -//------------------------------------------------------------------------ - -class SplashFont { -public: - - SplashFont(SplashFontFile *fontFileA, SplashCoord *matA, - SplashCoord *textMatA, GBool aaA); - - // This must be called after the constructor, so that the subclass - // constructor has a chance to compute the bbox. - void initCache(); - - virtual ~SplashFont(); - - SplashFontFile *getFontFile() { return fontFile; } - - // Return true if <this> matches the specified font file and matrix. - GBool matches(SplashFontFile *fontFileA, SplashCoord *matA, - SplashCoord *textMatA) { - return fontFileA == fontFile && - matA[0] == mat[0] && matA[1] == mat[1] && - matA[2] == mat[2] && matA[3] == mat[3] && - textMatA[0] == textMat[0] && textMatA[1] == textMat[1] && - textMatA[2] == textMat[2] && textMatA[3] == textMat[3]; - } - - // Get a glyph - this does a cache lookup first, and if not found, - // creates a new bitmap and adds it to the cache. The <xFrac> and - // <yFrac> values are splashFontFractionBits bits each, representing - // the numerators of fractions in [0, 1), where the denominator is - // splashFontFraction = 1 << splashFontFractionBits. Subclasses - // should override this to zero out xFrac and/or yFrac if they don't - // support fractional coordinates. - virtual GBool getGlyph(int c, int xFrac, int yFrac, - SplashGlyphBitmap *bitmap, int x0, int y0, SplashClip *clip, SplashClipResult *clipRes); - - // Rasterize a glyph. The <xFrac> and <yFrac> values are the same - // as described for getGlyph. - virtual GBool makeGlyph(int c, int xFrac, int yFrac, - SplashGlyphBitmap *bitmap, int x0, int y0, SplashClip *clip, SplashClipResult *clipRes) = 0; - - // Return the path for a glyph. - virtual SplashPath *getGlyphPath(int c) = 0; - - // Return the advance of a glyph. (in 0..1 range) - // < 0 means not known - virtual double getGlyphAdvance(int c) { return -1; } - - // Return the font transform matrix. - SplashCoord *getMatrix() { return mat; } - - // Return the glyph bounding box. - void getBBox(int *xMinA, int *yMinA, int *xMaxA, int *yMaxA) - { *xMinA = xMin; *yMinA = yMin; *xMaxA = xMax; *yMaxA = yMax; } - -protected: - - SplashFontFile *fontFile; - SplashCoord mat[4]; // font transform matrix - // (text space -> device space) - SplashCoord textMat[4]; // text transform matrix - // (text space -> user space) - GBool aa; // anti-aliasing - int xMin, yMin, xMax, yMax; // glyph bounding box - Guchar *cache; // glyph bitmap cache - SplashFontCacheTag * // cache tags - cacheTags; - int glyphW, glyphH; // size of glyph bitmaps - int glyphSize; // size of glyph bitmaps, in bytes - int cacheSets; // number of sets in cache - int cacheAssoc; // cache associativity (glyphs per set) -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFontEngine.cc b/Build/source/libs/poppler/poppler-src/splash/SplashFontEngine.cc deleted file mode 100644 index 62e5a0199bf..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFontEngine.cc +++ /dev/null @@ -1,288 +0,0 @@ -//======================================================================== -// -// SplashFontEngine.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de> -// Copyright (C) 2009 Petr Gajdos <pgajdos@novell.com> -// Copyright (C) 2009 Kovid Goyal <kovid@kovidgoyal.net> -// Copyright (C) 2009 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com> -// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2015 Dmytro Morgun <lztoad@gmail.com> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <stdlib.h> -#include <stdio.h> -#ifdef HAVE_UNISTD_H -# include <unistd.h> -#endif -#include "goo/gmem.h" -#include "goo/GooString.h" -#include "SplashMath.h" -#include "SplashFTFontEngine.h" -#include "SplashFontFile.h" -#include "SplashFontFileID.h" -#include "SplashFont.h" -#include "SplashFontEngine.h" - -#ifdef VMS -#if (__VMS_VER < 70000000) -extern "C" int unlink(char *filename); -#endif -#endif - -#ifdef VMS -#if (__VMS_VER < 70000000) -extern "C" int unlink(char *filename); -#endif -#endif - -//------------------------------------------------------------------------ -// SplashFontEngine -//------------------------------------------------------------------------ - -SplashFontEngine::SplashFontEngine( - GBool enableFreeType, - GBool enableFreeTypeHinting, - GBool enableSlightHinting, - GBool aa) { - int i; - - for (i = 0; i < splashFontCacheSize; ++i) { - fontCache[i] = NULL; - } - - if (enableFreeType) { - ftEngine = SplashFTFontEngine::init(aa, enableFreeTypeHinting, enableSlightHinting); - } else { - ftEngine = NULL; - } -} - -SplashFontEngine::~SplashFontEngine() { - int i; - - for (i = 0; i < splashFontCacheSize; ++i) { - if (fontCache[i]) { - delete fontCache[i]; - } - } - - if (ftEngine) { - delete ftEngine; - } -} - -SplashFontFile *SplashFontEngine::getFontFile(SplashFontFileID *id) { - SplashFontFile *fontFile; - int i; - - for (i = 0; i < splashFontCacheSize; ++i) { - if (fontCache[i]) { - fontFile = fontCache[i]->getFontFile(); - if (fontFile && fontFile->getID()->matches(id)) { - return fontFile; - } - } - } - return NULL; -} - -SplashFontFile *SplashFontEngine::loadType1Font(SplashFontFileID *idA, - SplashFontSrc *src, - const char **enc) { - SplashFontFile *fontFile; - - fontFile = NULL; - if (!fontFile && ftEngine) { - fontFile = ftEngine->loadType1Font(idA, src, enc); - } - - // delete the (temporary) font file -- with Unix hard link - // semantics, this will remove the last link; otherwise it will - // return an error, leaving the file to be deleted later (if - // loadXYZFont failed, the file will always be deleted) - if (src->isFile) - src->unref(); - - return fontFile; -} - -SplashFontFile *SplashFontEngine::loadType1CFont(SplashFontFileID *idA, - SplashFontSrc *src, - const char **enc) { - SplashFontFile *fontFile; - - fontFile = NULL; - if (!fontFile && ftEngine) { - fontFile = ftEngine->loadType1CFont(idA, src, enc); - } - - // delete the (temporary) font file -- with Unix hard link - // semantics, this will remove the last link; otherwise it will - // return an error, leaving the file to be deleted later (if - // loadXYZFont failed, the file will always be deleted) - if (src->isFile) - src->unref(); - - return fontFile; -} - -SplashFontFile *SplashFontEngine::loadOpenTypeT1CFont(SplashFontFileID *idA, - SplashFontSrc *src, - const char **enc) { - SplashFontFile *fontFile; - - fontFile = NULL; - if (!fontFile && ftEngine) { - fontFile = ftEngine->loadOpenTypeT1CFont(idA, src, enc); - } - - // delete the (temporary) font file -- with Unix hard link - // semantics, this will remove the last link; otherwise it will - // return an error, leaving the file to be deleted later (if - // loadXYZFont failed, the file will always be deleted) - if (src->isFile) - src->unref(); - - return fontFile; -} - -SplashFontFile *SplashFontEngine::loadCIDFont(SplashFontFileID *idA, - SplashFontSrc *src) { - SplashFontFile *fontFile; - - fontFile = NULL; - if (!fontFile && ftEngine) { - fontFile = ftEngine->loadCIDFont(idA, src); - } - - // delete the (temporary) font file -- with Unix hard link - // semantics, this will remove the last link; otherwise it will - // return an error, leaving the file to be deleted later (if - // loadXYZFont failed, the file will always be deleted) - if (src->isFile) - src->unref(); - - return fontFile; -} - -SplashFontFile *SplashFontEngine::loadOpenTypeCFFFont(SplashFontFileID *idA, - SplashFontSrc *src, - int *codeToGID, - int codeToGIDLen) { - SplashFontFile *fontFile; - - fontFile = NULL; - if (!fontFile && ftEngine) { - fontFile = ftEngine->loadOpenTypeCFFFont(idA, src, codeToGID, codeToGIDLen); - } - - // delete the (temporary) font file -- with Unix hard link - // semantics, this will remove the last link; otherwise it will - // return an error, leaving the file to be deleted later (if - // loadXYZFont failed, the file will always be deleted) - if (src->isFile) - src->unref(); - - return fontFile; -} - -SplashFontFile *SplashFontEngine::loadTrueTypeFont(SplashFontFileID *idA, - SplashFontSrc *src, - int *codeToGID, - int codeToGIDLen, - int faceIndex) { - SplashFontFile *fontFile; - - fontFile = NULL; - if (!fontFile && ftEngine) { - fontFile = ftEngine->loadTrueTypeFont(idA, src, - codeToGID, codeToGIDLen, faceIndex); - } - - if (!fontFile) { - gfree(codeToGID); - } - - // delete the (temporary) font file -- with Unix hard link - // semantics, this will remove the last link; otherwise it will - // return an error, leaving the file to be deleted later (if - // loadXYZFont failed, the file will always be deleted) - if (src->isFile) - src->unref(); - - return fontFile; -} - -GBool SplashFontEngine::getAA() { - return (ftEngine == NULL) ? gFalse : ftEngine->getAA(); -} - -void SplashFontEngine::setAA(GBool aa) { - if (ftEngine != NULL) { - ftEngine->setAA(aa); - } -} - -SplashFont *SplashFontEngine::getFont(SplashFontFile *fontFile, - SplashCoord *textMat, - SplashCoord *ctm) { - SplashCoord mat[4]; - SplashFont *font; - int i, j; - - mat[0] = textMat[0] * ctm[0] + textMat[1] * ctm[2]; - mat[1] = -(textMat[0] * ctm[1] + textMat[1] * ctm[3]); - mat[2] = textMat[2] * ctm[0] + textMat[3] * ctm[2]; - mat[3] = -(textMat[2] * ctm[1] + textMat[3] * ctm[3]); - if (!splashCheckDet(mat[0], mat[1], mat[2], mat[3], 0.01)) { - // avoid a singular (or close-to-singular) matrix - mat[0] = 0.01; mat[1] = 0; - mat[2] = 0; mat[3] = 0.01; - } - - font = fontCache[0]; - if (font && font->matches(fontFile, mat, textMat)) { - return font; - } - for (i = 1; i < splashFontCacheSize; ++i) { - font = fontCache[i]; - if (font && font->matches(fontFile, mat, textMat)) { - for (j = i; j > 0; --j) { - fontCache[j] = fontCache[j-1]; - } - fontCache[0] = font; - return font; - } - } - font = fontFile->makeFont(mat, textMat); - if (fontCache[splashFontCacheSize - 1]) { - delete fontCache[splashFontCacheSize - 1]; - } - for (j = splashFontCacheSize - 1; j > 0; --j) { - fontCache[j] = fontCache[j-1]; - } - fontCache[0] = font; - return font; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFontEngine.h b/Build/source/libs/poppler/poppler-src/splash/SplashFontEngine.h deleted file mode 100644 index e3ee1ce600d..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFontEngine.h +++ /dev/null @@ -1,99 +0,0 @@ -//======================================================================== -// -// SplashFontEngine.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de> -// Copyright (C) 2009 Petr Gajdos <pgajdos@novell.com> -// Copyright (C) 2009, 2011 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com> -// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHFONTENGINE_H -#define SPLASHFONTENGINE_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "goo/gtypes.h" -#include "SplashTypes.h" - -class SplashT1FontEngine; -class SplashFTFontEngine; -class SplashDTFontEngine; -class SplashDT4FontEngine; -class SplashFontFile; -class SplashFontFileID; -class SplashFont; -class SplashFontSrc; - -//------------------------------------------------------------------------ - -#define splashFontCacheSize 16 - -//------------------------------------------------------------------------ -// SplashFontEngine -//------------------------------------------------------------------------ - -class SplashFontEngine { -public: - - // Create a font engine. - SplashFontEngine( - GBool enableFreeType, - GBool enableFreeTypeHinting, - GBool enableSlightHinting, - GBool aa); - - ~SplashFontEngine(); - - // Get a font file from the cache. Returns NULL if there is no - // matching entry in the cache. - SplashFontFile *getFontFile(SplashFontFileID *id); - - // Load fonts - these create new SplashFontFile objects. - SplashFontFile *loadType1Font(SplashFontFileID *idA, SplashFontSrc *src, const char **enc); - SplashFontFile *loadType1CFont(SplashFontFileID *idA, SplashFontSrc *src, const char **enc); - SplashFontFile *loadOpenTypeT1CFont(SplashFontFileID *idA, SplashFontSrc *src, const char **enc); - SplashFontFile *loadCIDFont(SplashFontFileID *idA, SplashFontSrc *src); - SplashFontFile *loadOpenTypeCFFFont(SplashFontFileID *idA, SplashFontSrc *src, - int *codeToGID, int codeToGIDLen); - SplashFontFile *loadTrueTypeFont(SplashFontFileID *idA, SplashFontSrc *src, - int *codeToGID, int codeToGIDLen, int faceIndex = 0); - - // Get a font - this does a cache lookup first, and if not found, - // creates a new SplashFont object and adds it to the cache. The - // matrix, mat = textMat * ctm: - // [ mat[0] mat[1] ] - // [ mat[2] mat[3] ] - // specifies the font transform in PostScript style: - // [x' y'] = [x y] * mat - // Note that the Splash y axis points downward. - SplashFont *getFont(SplashFontFile *fontFile, - SplashCoord *textMat, SplashCoord *ctm); - GBool getAA(); - void setAA(GBool aa); - -private: - - SplashFont *fontCache[splashFontCacheSize]; - - SplashFTFontEngine *ftEngine; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFontFile.cc b/Build/source/libs/poppler/poppler-src/splash/SplashFontFile.cc deleted file mode 100644 index 68e8608b6a7..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFontFile.cc +++ /dev/null @@ -1,124 +0,0 @@ -//======================================================================== -// -// SplashFontFile.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de> -// Copyright (C) 2008 Albert Astals Cid <aacid@kde.org> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <stdio.h> -#ifdef HAVE_UNISTD_H -#include <unistd.h> -#endif -#include "goo/gmem.h" -#include "goo/GooString.h" -#include "SplashFontFile.h" -#include "SplashFontFileID.h" - -#ifdef VMS -#if (__VMS_VER < 70000000) -extern "C" int unlink(char *filename); -#endif -#endif - -//------------------------------------------------------------------------ -// SplashFontFile -//------------------------------------------------------------------------ - -SplashFontFile::SplashFontFile(SplashFontFileID *idA, SplashFontSrc *srcA) { - id = idA; - src = srcA; - src->ref(); - refCnt = 0; - doAdjustMatrix = gFalse; -} - -SplashFontFile::~SplashFontFile() { - src->unref(); - delete id; -} - -void SplashFontFile::incRefCnt() { - ++refCnt; -} - -void SplashFontFile::decRefCnt() { - if (!--refCnt) { - delete this; - } -} - -// - -SplashFontSrc::SplashFontSrc() { - isFile = gFalse; - deleteSrc = gFalse; - fileName = NULL; - buf = NULL; - refcnt = 1; -} - -SplashFontSrc::~SplashFontSrc() { - if (deleteSrc) { - if (isFile) { - if (fileName) - unlink(fileName->getCString()); - } else { - if (buf) - gfree(buf); - } - } - - if (isFile && fileName) - delete fileName; -} - -void SplashFontSrc::ref() { - refcnt++; -} - -void SplashFontSrc::unref() { - if (! --refcnt) - delete this; -} - -void SplashFontSrc::setFile(GooString *file, GBool del) -{ - isFile = gTrue; - fileName = file->copy(); - deleteSrc = del; -} - -void SplashFontSrc::setFile(const char *file, GBool del) -{ - isFile = gTrue; - fileName = new GooString(file); - deleteSrc = del; -} - -void SplashFontSrc::setBuf(char *bufA, int bufLenA, GBool del) -{ - isFile = gFalse; - buf = bufA; - bufLen = bufLenA; - deleteSrc = del; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFontFile.h b/Build/source/libs/poppler/poppler-src/splash/SplashFontFile.h deleted file mode 100644 index ec87504b9bc..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFontFile.h +++ /dev/null @@ -1,95 +0,0 @@ -//======================================================================== -// -// SplashFontFile.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de> -// Copyright (C) 2008, 2010 Albert Astals Cid <aacid@kde.org> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHFONTFILE_H -#define SPLASHFONTFILE_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "goo/gtypes.h" -#include "SplashTypes.h" - -class GooString; -class SplashFontEngine; -class SplashFont; -class SplashFontFileID; - -//------------------------------------------------------------------------ -// SplashFontFile -//------------------------------------------------------------------------ - -class SplashFontSrc { -public: - SplashFontSrc(); - - void setFile(GooString *file, GBool del); - void setFile(const char *file, GBool del); - void setBuf(char *bufA, int buflenA, GBool del); - - void ref(); - void unref(); - - GBool isFile; - GooString *fileName; - char *buf; - int bufLen; - -private: - ~SplashFontSrc(); - int refcnt; - GBool deleteSrc; -}; - -class SplashFontFile { -public: - - virtual ~SplashFontFile(); - - // Create a new SplashFont, i.e., a scaled instance of this font - // file. - virtual SplashFont *makeFont(SplashCoord *mat, SplashCoord *textMat) = 0; - - // Get the font file ID. - SplashFontFileID *getID() { return id; } - - // Increment the reference count. - void incRefCnt(); - - // Decrement the reference count. If the new value is zero, delete - // the SplashFontFile object. - void decRefCnt(); - - GBool doAdjustMatrix; - -protected: - - SplashFontFile(SplashFontFileID *idA, SplashFontSrc *srcA); - - SplashFontFileID *id; - SplashFontSrc *src; - int refCnt; - - friend class SplashFontEngine; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFontFileID.cc b/Build/source/libs/poppler/poppler-src/splash/SplashFontFileID.cc deleted file mode 100644 index a66dabf61e3..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFontFileID.cc +++ /dev/null @@ -1,23 +0,0 @@ -//======================================================================== -// -// SplashFontFileID.cc -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include "SplashFontFileID.h" - -//------------------------------------------------------------------------ -// SplashFontFileID -//------------------------------------------------------------------------ - -SplashFontFileID::SplashFontFileID() { -} - -SplashFontFileID::~SplashFontFileID() { -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashFontFileID.h b/Build/source/libs/poppler/poppler-src/splash/SplashFontFileID.h deleted file mode 100644 index cfd89ebb56a..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashFontFileID.h +++ /dev/null @@ -1,28 +0,0 @@ -//======================================================================== -// -// SplashFontFileID.h -// -//======================================================================== - -#ifndef SPLASHFONTFILEID_H -#define SPLASHFONTFILEID_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "goo/gtypes.h" - -//------------------------------------------------------------------------ -// SplashFontFileID -//------------------------------------------------------------------------ - -class SplashFontFileID { -public: - - SplashFontFileID(); - virtual ~SplashFontFileID(); - virtual GBool matches(SplashFontFileID *id) = 0; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashGlyphBitmap.h b/Build/source/libs/poppler/poppler-src/splash/SplashGlyphBitmap.h deleted file mode 100644 index c062c106e6a..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashGlyphBitmap.h +++ /dev/null @@ -1,24 +0,0 @@ -//======================================================================== -// -// SplashGlyphBitmap.h -// -//======================================================================== - -#ifndef SPLASHGLYPHBITMAP_H -#define SPLASHGLYPHBITMAP_H - -#include "goo/gtypes.h" - -//------------------------------------------------------------------------ -// SplashGlyphBitmap -//------------------------------------------------------------------------ - -struct SplashGlyphBitmap { - int x, y, w, h; // offset and size of glyph - GBool aa; // anti-aliased: true means 8-bit alpha - // bitmap; false means 1-bit - Guchar *data; // bitmap data - GBool freeData; // true if data memory should be freed -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashMath.h b/Build/source/libs/poppler/poppler-src/splash/SplashMath.h deleted file mode 100644 index 36793ea3fcd..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashMath.h +++ /dev/null @@ -1,246 +0,0 @@ -//======================================================================== -// -// SplashMath.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2009-2011 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHMATH_H -#define SPLASHMATH_H - -#include "poppler-config.h" - -#ifdef USE_FIXEDPOINT -#include "goo/FixedPoint.h" -#else -#include <math.h> -#endif -#include "SplashTypes.h" - -static inline SplashCoord splashAbs(SplashCoord x) { -#if defined(USE_FIXEDPOINT) - return FixedPoint::abs(x); -#elif defined(USE_FLOAT) - return fabsf(x); -#else - return fabs(x); -#endif -} - -static inline int splashFloor(SplashCoord x) { -#if defined(USE_FIXEDPOINT) - return FixedPoint::floor(x); -#elif defined(USE_FLOAT) - return (int)floorf(x); -#elif defined(__GNUC__) && defined(__i386__) - // floor() and (int)() are implemented separately, which results - // in changing the FPCW multiple times - so we optimize it with - // some inline assembly - Gushort oldCW, newCW, t; - int result; - - __asm__ volatile("fldl %4\n" - "fnstcw %0\n" - "movw %0, %3\n" - "andw $0xf3ff, %3\n" - "orw $0x0400, %3\n" - "movw %3, %1\n" // round down - "fldcw %1\n" - "fistpl %2\n" - "fldcw %0\n" - : "=m" (oldCW), "=m" (newCW), "=m" (result), "=r" (t) - : "m" (x)); - return result; -#elif defined(_WIN32) && defined(_M_IX86) - // floor() and (int)() are implemented separately, which results - // in changing the FPCW multiple times - so we optimize it with - // some inline assembly - Gushort oldCW, newCW; - int result; - - __asm fld QWORD PTR x - __asm fnstcw WORD PTR oldCW - __asm mov ax, WORD PTR oldCW - __asm and ax, 0xf3ff - __asm or ax, 0x0400 - __asm mov WORD PTR newCW, ax // round down - __asm fldcw WORD PTR newCW - __asm fistp DWORD PTR result - __asm fldcw WORD PTR oldCW - return result; -#else - if (x > 0) return (int)x; - else return (int)floor(x); -#endif -} - -static inline int splashCeil(SplashCoord x) { -#if defined(USE_FIXEDPOINT) - return FixedPoint::ceil(x); -#elif defined(USE_FLOAT) - return (int)ceilf(x); -#elif defined(__GNUC__) && defined(__i386__) - // ceil() and (int)() are implemented separately, which results - // in changing the FPCW multiple times - so we optimize it with - // some inline assembly - Gushort oldCW, newCW, t; - int result; - - __asm__ volatile("fldl %4\n" - "fnstcw %0\n" - "movw %0, %3\n" - "andw $0xf3ff, %3\n" - "orw $0x0800, %3\n" - "movw %3, %1\n" // round up - "fldcw %1\n" - "fistpl %2\n" - "fldcw %0\n" - : "=m" (oldCW), "=m" (newCW), "=m" (result), "=r" (t) - : "m" (x)); - return result; -#elif defined(_WIN32) && defined(_M_IX86) - // ceil() and (int)() are implemented separately, which results - // in changing the FPCW multiple times - so we optimize it with - // some inline assembly - Gushort oldCW, newCW; - int result; - - __asm fld QWORD PTR x - __asm fnstcw WORD PTR oldCW - __asm mov ax, WORD PTR oldCW - __asm and ax, 0xf3ff - __asm or ax, 0x0800 - __asm mov WORD PTR newCW, ax // round up - __asm fldcw WORD PTR newCW - __asm fistp DWORD PTR result - __asm fldcw WORD PTR oldCW - return result; -#else - return (int)ceil(x); -#endif -} - -static inline int splashRound(SplashCoord x) { -#if defined(USE_FIXEDPOINT) - return FixedPoint::round(x); -#elif defined(__GNUC__) && defined(__i386__) - // this could use round-to-nearest mode and avoid the "+0.5", - // but that produces slightly different results (because i+0.5 - // sometimes rounds up and sometimes down using the even rule) - Gushort oldCW, newCW, t; - int result; - - x += 0.5; - __asm__ volatile("fldl %4\n" - "fnstcw %0\n" - "movw %0, %3\n" - "andw $0xf3ff, %3\n" - "orw $0x0400, %3\n" - "movw %3, %1\n" // round down - "fldcw %1\n" - "fistpl %2\n" - "fldcw %0\n" - : "=m" (oldCW), "=m" (newCW), "=m" (result), "=r" (t) - : "m" (x)); - return result; -#elif defined(_WIN32) && defined(_M_IX86) - // this could use round-to-nearest mode and avoid the "+0.5", - // but that produces slightly different results (because i+0.5 - // sometimes rounds up and sometimes down using the even rule) - Gushort oldCW, newCW; - int result; - - x += 0.5; - __asm fld QWORD PTR x - __asm fnstcw WORD PTR oldCW - __asm mov ax, WORD PTR oldCW - __asm and ax, 0xf3ff - __asm or ax, 0x0400 - __asm mov WORD PTR newCW, ax // round down - __asm fldcw WORD PTR newCW - __asm fistp DWORD PTR result - __asm fldcw WORD PTR oldCW - return result; -#else - return (int)splashFloor(x + 0.5); -#endif -} - -static inline SplashCoord splashAvg(SplashCoord x, SplashCoord y) { -#ifdef USE_FIXEDPOINT - return FixedPoint::avg(x, y); -#else - return 0.5 * (x + y); -#endif -} - -static inline SplashCoord splashSqrt(SplashCoord x) { -#if defined(USE_FIXEDPOINT) - return FixedPoint::sqrt(x); -#elif defined(USE_FLOAT) - return sqrtf(x); -#else - return sqrt(x); -#endif -} - -static inline SplashCoord splashPow(SplashCoord x, SplashCoord y) { -#if defined(USE_FIXEDPOINT) - return FixedPoint::pow(x, y); -#elif defined(USE_FLOAT) - return powf(x, y); -#else - return pow(x, y); -#endif -} - -static inline SplashCoord splashDist(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1) { - SplashCoord dx, dy; - dx = x1 - x0; - dy = y1 - y0; -#ifdef USE_FIXEDPOINT - // this handles the situation where dx*dx or dy*dy is too large to - // fit in the 16.16 fixed point format - SplashCoord dxa, dya, d; - dxa = splashAbs(dx); - dya = splashAbs(dy); - if (dxa == 0 && dya == 0) { - return 0; - } else if (dxa > dya) { - d = dya / dxa; - return dxa * FixedPoint::sqrt(d*d + 1); - } else { - d = dxa / dya; - return dya * FixedPoint::sqrt(d*d + 1); - } -#else - return splashSqrt(dx * dx + dy * dy); -#endif -} - -static inline GBool splashCheckDet(SplashCoord m11, SplashCoord m12, - SplashCoord m21, SplashCoord m22, - SplashCoord epsilon) { -#ifdef USE_FIXEDPOINT - return FixedPoint::checkDet(m11, m12, m21, m22, epsilon); -#else - return fabs(m11 * m22 - m12 * m21) >= epsilon; -#endif -} - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashPath.cc b/Build/source/libs/poppler/poppler-src/splash/SplashPath.cc deleted file mode 100644 index bc4ccd524a4..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashPath.cc +++ /dev/null @@ -1,185 +0,0 @@ -//======================================================================== -// -// SplashPath.cc -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <string.h> -#include "goo/gmem.h" -#include "SplashErrorCodes.h" -#include "SplashPath.h" - -//------------------------------------------------------------------------ -// SplashPath -//------------------------------------------------------------------------ - -// A path can be in three possible states: -// -// 1. no current point -- zero or more finished subpaths -// [curSubpath == length] -// -// 2. one point in subpath -// [curSubpath == length - 1] -// -// 3. open subpath with two or more points -// [curSubpath < length - 1] - -SplashPath::SplashPath() { - pts = NULL; - flags = NULL; - length = size = 0; - curSubpath = 0; - hints = NULL; - hintsLength = hintsSize = 0; -} - -SplashPath::SplashPath(SplashPath *path) { - length = path->length; - size = path->size; - pts = (SplashPathPoint *)gmallocn(size, sizeof(SplashPathPoint)); - flags = (Guchar *)gmallocn(size, sizeof(Guchar)); - memcpy(pts, path->pts, length * sizeof(SplashPathPoint)); - memcpy(flags, path->flags, length * sizeof(Guchar)); - curSubpath = path->curSubpath; - if (path->hints) { - hintsLength = hintsSize = path->hintsLength; - hints = (SplashPathHint *)gmallocn(hintsSize, sizeof(SplashPathHint)); - memcpy(hints, path->hints, hintsLength * sizeof(SplashPathHint)); - } else { - hints = NULL; - } -} - -SplashPath::~SplashPath() { - gfree(pts); - gfree(flags); - gfree(hints); -} - -// Add space for <nPts> more points. -void SplashPath::grow(int nPts) { - if (length + nPts > size) { - if (size == 0) { - size = 32; - } - while (size < length + nPts) { - size *= 2; - } - pts = (SplashPathPoint *)greallocn(pts, size, sizeof(SplashPathPoint)); - flags = (Guchar *)greallocn(flags, size, sizeof(Guchar)); - } -} - -void SplashPath::append(SplashPath *path) { - int i; - - curSubpath = length + path->curSubpath; - grow(path->length); - for (i = 0; i < path->length; ++i) { - pts[length] = path->pts[i]; - flags[length] = path->flags[i]; - ++length; - } -} - -SplashError SplashPath::moveTo(SplashCoord x, SplashCoord y) { - if (onePointSubpath()) { - return splashErrBogusPath; - } - grow(1); - pts[length].x = x; - pts[length].y = y; - flags[length] = splashPathFirst | splashPathLast; - curSubpath = length++; - return splashOk; -} - -SplashError SplashPath::lineTo(SplashCoord x, SplashCoord y) { - if (noCurrentPoint()) { - return splashErrNoCurPt; - } - flags[length-1] &= ~splashPathLast; - grow(1); - pts[length].x = x; - pts[length].y = y; - flags[length] = splashPathLast; - ++length; - return splashOk; -} - -SplashError SplashPath::curveTo(SplashCoord x1, SplashCoord y1, - SplashCoord x2, SplashCoord y2, - SplashCoord x3, SplashCoord y3) { - if (noCurrentPoint()) { - return splashErrNoCurPt; - } - flags[length-1] &= ~splashPathLast; - grow(3); - pts[length].x = x1; - pts[length].y = y1; - flags[length] = splashPathCurve; - ++length; - pts[length].x = x2; - pts[length].y = y2; - flags[length] = splashPathCurve; - ++length; - pts[length].x = x3; - pts[length].y = y3; - flags[length] = splashPathLast; - ++length; - return splashOk; -} - -SplashError SplashPath::close(GBool force) { - if (noCurrentPoint()) { - return splashErrNoCurPt; - } - if (force || - curSubpath == length - 1 || - pts[length - 1].x != pts[curSubpath].x || - pts[length - 1].y != pts[curSubpath].y) { - lineTo(pts[curSubpath].x, pts[curSubpath].y); - } - flags[curSubpath] |= splashPathClosed; - flags[length - 1] |= splashPathClosed; - curSubpath = length; - return splashOk; -} - -void SplashPath::addStrokeAdjustHint(int ctrl0, int ctrl1, - int firstPt, int lastPt) { - if (hintsLength == hintsSize) { - hintsSize = hintsLength ? 2 * hintsLength : 8; - hints = (SplashPathHint *)greallocn(hints, hintsSize, - sizeof(SplashPathHint)); - } - hints[hintsLength].ctrl0 = ctrl0; - hints[hintsLength].ctrl1 = ctrl1; - hints[hintsLength].firstPt = firstPt; - hints[hintsLength].lastPt = lastPt; - ++hintsLength; -} - -void SplashPath::offset(SplashCoord dx, SplashCoord dy) { - int i; - - for (i = 0; i < length; ++i) { - pts[i].x += dx; - pts[i].y += dy; - } -} - -GBool SplashPath::getCurPt(SplashCoord *x, SplashCoord *y) { - if (noCurrentPoint()) { - return gFalse; - } - *x = pts[length - 1].x; - *y = pts[length - 1].y; - return gTrue; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashPath.h b/Build/source/libs/poppler/poppler-src/splash/SplashPath.h deleted file mode 100644 index 81273c613e5..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashPath.h +++ /dev/null @@ -1,123 +0,0 @@ -//======================================================================== -// -// SplashPath.h -// -//======================================================================== - -#ifndef SPLASHPATH_H -#define SPLASHPATH_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "SplashTypes.h" - -//------------------------------------------------------------------------ -// SplashPathPoint -//------------------------------------------------------------------------ - -struct SplashPathPoint { - SplashCoord x, y; -}; - -//------------------------------------------------------------------------ -// SplashPath.flags -//------------------------------------------------------------------------ - -// first point on each subpath sets this flag -#define splashPathFirst 0x01 - -// last point on each subpath sets this flag -#define splashPathLast 0x02 - -// if the subpath is closed, its first and last points must be -// identical, and must set this flag -#define splashPathClosed 0x04 - -// curve control points set this flag -#define splashPathCurve 0x08 - -//------------------------------------------------------------------------ -// SplashPathHint -//------------------------------------------------------------------------ - -struct SplashPathHint { - int ctrl0, ctrl1; - int firstPt, lastPt; -}; - -//------------------------------------------------------------------------ -// SplashPath -//------------------------------------------------------------------------ - -class SplashPath { -public: - - // Create an empty path. - SplashPath(); - - // Copy a path. - SplashPath *copy() { return new SplashPath(this); } - - ~SplashPath(); - - // Append <path> to <this>. - void append(SplashPath *path); - - // Start a new subpath. - SplashError moveTo(SplashCoord x, SplashCoord y); - - // Add a line segment to the last subpath. - SplashError lineTo(SplashCoord x, SplashCoord y); - - // Add a third-order (cubic) Bezier curve segment to the last - // subpath. - SplashError curveTo(SplashCoord x1, SplashCoord y1, - SplashCoord x2, SplashCoord y2, - SplashCoord x3, SplashCoord y3); - - // Close the last subpath, adding a line segment if necessary. If - // <force> is true, this adds a line segment even if the current - // point is equal to the first point in the subpath. - SplashError close(GBool force = gFalse); - - // Add a stroke adjustment hint. The controlling segments are - // <ctrl0> and <ctrl1> (where segments are identified by their first - // point), and the points to be adjusted are <firstPt> .. <lastPt>. - void addStrokeAdjustHint(int ctrl0, int ctrl1, int firstPt, int lastPt); - - // Add (<dx>, <dy>) to every point on this path. - void offset(SplashCoord dx, SplashCoord dy); - - // Get the points on the path. - int getLength() { return length; } - void getPoint(int i, double *x, double *y, Guchar *f) - { *x = pts[i].x; *y = pts[i].y; *f = flags[i]; } - - // Get the current point. - GBool getCurPt(SplashCoord *x, SplashCoord *y); - -protected: - - SplashPath(SplashPath *path); - void grow(int nPts); - GBool noCurrentPoint() { return curSubpath == length; } - GBool onePointSubpath() { return curSubpath == length - 1; } - GBool openSubpath() { return curSubpath < length - 1; } - - SplashPathPoint *pts; // array of points - Guchar *flags; // array of flags - int length, size; // length/size of the pts and flags arrays - int curSubpath; // index of first point in last subpath - - SplashPathHint *hints; // list of hints - int hintsLength, hintsSize; - - friend class SplashXPath; - friend class Splash; - // this is a temporary hack, until we read FreeType paths directly - friend class ArthurOutputDev; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashPattern.cc b/Build/source/libs/poppler/poppler-src/splash/SplashPattern.cc deleted file mode 100644 index 28ca4995882..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashPattern.cc +++ /dev/null @@ -1,55 +0,0 @@ -//======================================================================== -// -// SplashPattern.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2010, 2011 Thomas Freitag <Thomas.Freitag@alfa.de> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include "SplashMath.h" -#include "SplashScreen.h" -#include "SplashPattern.h" - -//------------------------------------------------------------------------ -// SplashPattern -//------------------------------------------------------------------------ - -SplashPattern::SplashPattern() { -} - -SplashPattern::~SplashPattern() { -} - -//------------------------------------------------------------------------ -// SplashSolidColor -//------------------------------------------------------------------------ - -SplashSolidColor::SplashSolidColor(SplashColorPtr colorA) { - splashColorCopy(color, colorA); -} - -SplashSolidColor::~SplashSolidColor() { -} - -GBool SplashSolidColor::getColor(int x, int y, SplashColorPtr c) { - splashColorCopy(c, color); - return gTrue; -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashPattern.h b/Build/source/libs/poppler/poppler-src/splash/SplashPattern.h deleted file mode 100644 index 1e2881c812e..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashPattern.h +++ /dev/null @@ -1,104 +0,0 @@ -//======================================================================== -// -// SplashPattern.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2010, 2011, 2014 Thomas Freitag <Thomas.Freitag@alfa.de> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHPATTERN_H -#define SPLASHPATTERN_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "SplashTypes.h" - -class SplashScreen; - -//------------------------------------------------------------------------ -// SplashPattern -//------------------------------------------------------------------------ - -class SplashPattern { -public: - - SplashPattern(); - - virtual SplashPattern *copy() = 0; - - virtual ~SplashPattern(); - - // Return the color value for a specific pixel. - virtual GBool getColor(int x, int y, SplashColorPtr c) = 0; - - // Test if x,y-position is inside pattern. - virtual GBool testPosition(int x, int y) = 0; - - // Returns true if this pattern object will return the same color - // value for all pixels. - virtual GBool isStatic() = 0; - - // Returns true if this pattern colorspace is CMYK. - virtual GBool isCMYK() = 0; -private: -}; - -//------------------------------------------------------------------------ -// SplashSolidColor -//------------------------------------------------------------------------ - -class SplashSolidColor: public SplashPattern { -public: - - SplashSolidColor(SplashColorPtr colorA); - - SplashPattern *copy() override { return new SplashSolidColor(color); } - - ~SplashSolidColor(); - - GBool getColor(int x, int y, SplashColorPtr c) override; - - GBool testPosition(int x, int y) override { return gFalse; } - - GBool isStatic() override { return gTrue; } - - GBool isCMYK() override { return gFalse; } - -private: - - SplashColor color; -}; - -//------------------------------------------------------------------------ -// SplashGouraudColor (needed for gouraudTriangleShadedFill) -//------------------------------------------------------------------------ - -class SplashGouraudColor: public SplashPattern { -public: - - virtual GBool isParameterized() = 0; - - virtual int getNTriangles() = 0; - - virtual void getTriangle(int i, double *x0, double *y0, double *color0, - double *x1, double *y1, double *color1, - double *x2, double *y2, double *color2) = 0; - - virtual void getParameterizedColor(double t, SplashColorMode mode, SplashColorPtr c) = 0; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashScreen.cc b/Build/source/libs/poppler/poppler-src/splash/SplashScreen.cc deleted file mode 100644 index 28b1e7997e2..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashScreen.cc +++ /dev/null @@ -1,390 +0,0 @@ -//======================================================================== -// -// SplashScreen.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2009, 2016 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2012 Fabio D'Urso <fabiodurso@hotmail.it> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <stdlib.h> -#include <string.h> -#include <algorithm> -#include "goo/gmem.h" -#include "goo/grandom.h" -#include "goo/GooLikely.h" -#include "SplashMath.h" -#include "SplashScreen.h" - -static SplashScreenParams defaultParams = { - splashScreenDispersed, // type - 2, // size - 2, // dotRadius - 1.0, // gamma - 0.0, // blackThreshold - 1.0 // whiteThreshold -}; - -//------------------------------------------------------------------------ - -struct SplashScreenPoint { - int x, y; - int dist; -}; - - -struct cmpDistancesFunctor { - bool operator()(const SplashScreenPoint &p0, const SplashScreenPoint &p1) { - return p0.dist < p1.dist; - } -}; - -//------------------------------------------------------------------------ -// SplashScreen -//------------------------------------------------------------------------ - -// If <clustered> is true, this generates a 45 degree screen using a -// circular dot spot function. DPI = resolution / ((size / 2) * -// sqrt(2)). If <clustered> is false, this generates an optimal -// threshold matrix using recursive tesselation. Gamma correction -// (gamma = 1 / 1.33) is also computed here. -SplashScreen::SplashScreen(SplashScreenParams *params) { - - if (!params) { - params = &defaultParams; - } - - screenParams = params; - mat = NULL; - size = 0; - maxVal = 0; - minVal = 0; -} - -void SplashScreen::createMatrix() -{ - Guchar u; - int black, white, i; - - SplashScreenParams *params = screenParams; - - // size must be a power of 2, and at least 2 - for (size = 2, log2Size = 1; size < params->size; size <<= 1, ++log2Size) ; - - switch (params->type) { - - case splashScreenDispersed: - mat = (Guchar *)gmallocn(size * size, sizeof(Guchar)); - buildDispersedMatrix(size/2, size/2, 1, size/2, 1); - break; - - case splashScreenClustered: - mat = (Guchar *)gmallocn(size * size, sizeof(Guchar)); - buildClusteredMatrix(); - break; - - case splashScreenStochasticClustered: - // size must be at least 2*r - while (size < (params->dotRadius << 1)) { - size <<= 1; - ++log2Size; - } - mat = (Guchar *)gmallocn(size * size, sizeof(Guchar)); - buildSCDMatrix(params->dotRadius); - break; - } - - sizeM1 = size - 1; - - // do gamma correction and compute minVal/maxVal - minVal = 255; - maxVal = 0; - black = splashRound((SplashCoord)255.0 * params->blackThreshold); - if (black < 1) { - black = 1; - } - int whiteAux = splashRound((SplashCoord)255.0 * params->whiteThreshold); - if (whiteAux > 255) { - white = 255; - } else { - white = whiteAux; - } - for (i = 0; i < size * size; ++i) { - u = splashRound((SplashCoord)255.0 * - splashPow((SplashCoord)mat[i] / 255.0, params->gamma)); - if (u < black) { - u = (Guchar)black; - } else if (u >= white) { - u = (Guchar)white; - } - mat[i] = u; - if (u < minVal) { - minVal = u; - } else if (u > maxVal) { - maxVal = u; - } - } -} - -void SplashScreen::buildDispersedMatrix(int i, int j, int val, - int delta, int offset) { - if (delta == 0) { - // map values in [1, size^2] --> [1, 255] - mat[(i << log2Size) + j] = 1 + (254 * (val - 1)) / (size * size - 1); - } else { - buildDispersedMatrix(i, j, - val, delta / 2, 4*offset); - buildDispersedMatrix((i + delta) % size, (j + delta) % size, - val + offset, delta / 2, 4*offset); - buildDispersedMatrix((i + delta) % size, j, - val + 2*offset, delta / 2, 4*offset); - buildDispersedMatrix((i + 2*delta) % size, (j + delta) % size, - val + 3*offset, delta / 2, 4*offset); - } -} - -void SplashScreen::buildClusteredMatrix() { - SplashCoord *dist; - SplashCoord u, v, d; - Guchar val; - int size2, x, y, x1, y1, i; - - size2 = size >> 1; - - // initialize the threshold matrix - for (y = 0; y < size; ++y) { - for (x = 0; x < size; ++x) { - mat[(y << log2Size) + x] = 0; - } - } - - // build the distance matrix - dist = (SplashCoord *)gmallocn(size * size2, sizeof(SplashCoord)); - for (y = 0; y < size2; ++y) { - for (x = 0; x < size2; ++x) { - if (x + y < size2 - 1) { - u = (SplashCoord)x + 0.5 - 0; - v = (SplashCoord)y + 0.5 - 0; - } else { - u = (SplashCoord)x + 0.5 - (SplashCoord)size2; - v = (SplashCoord)y + 0.5 - (SplashCoord)size2; - } - dist[y * size2 + x] = u*u + v*v; - } - } - for (y = 0; y < size2; ++y) { - for (x = 0; x < size2; ++x) { - if (x < y) { - u = (SplashCoord)x + 0.5 - 0; - v = (SplashCoord)y + 0.5 - (SplashCoord)size2; - } else { - u = (SplashCoord)x + 0.5 - (SplashCoord)size2; - v = (SplashCoord)y + 0.5 - 0; - } - dist[(size2 + y) * size2 + x] = u*u + v*v; - } - } - - // build the threshold matrix - x1 = y1 = 0; // make gcc happy - for (i = 0; i < size * size2; ++i) { - d = -1; - for (y = 0; y < size; ++y) { - for (x = 0; x < size2; ++x) { - if (mat[(y << log2Size) + x] == 0 && - dist[y * size2 + x] > d) { - x1 = x; - y1 = y; - d = dist[y1 * size2 + x1]; - } - } - } - // map values in [0, 2*size*size2-1] --> [1, 255] - val = 1 + (254 * (2*i)) / (2*size*size2 - 1); - mat[(y1 << log2Size) + x1] = val; - val = 1 + (254 * (2*i+1)) / (2*size*size2 - 1); - if (y1 < size2) { - mat[((y1 + size2) << log2Size) + x1 + size2] = val; - } else { - mat[((y1 - size2) << log2Size) + x1 + size2] = val; - } - } - - gfree(dist); -} - -// Compute the distance between two points on a toroid. -int SplashScreen::distance(int x0, int y0, int x1, int y1) { - int dx0, dx1, dx, dy0, dy1, dy; - - dx0 = abs(x0 - x1); - dx1 = size - dx0; - dx = dx0 < dx1 ? dx0 : dx1; - dy0 = abs(y0 - y1); - dy1 = size - dy0; - dy = dy0 < dy1 ? dy0 : dy1; - return dx * dx + dy * dy; -} - -// Algorithm taken from: -// Victor Ostromoukhov and Roger D. Hersch, "Stochastic Clustered-Dot -// Dithering" in Color Imaging: Device-Independent Color, Color -// Hardcopy, and Graphic Arts IV, SPIE Vol. 3648, pp. 496-505, 1999. -void SplashScreen::buildSCDMatrix(int r) { - SplashScreenPoint *dots, *pts; - int dotsLen, dotsSize; - char *tmpl; - char *grid; - int *region, *dist; - int x, y, xx, yy, x0, x1, y0, y1, i, j, d, iMin, dMin, n; - - // generate the random space-filling curve - pts = (SplashScreenPoint *)gmallocn(size * size, sizeof(SplashScreenPoint)); - i = 0; - for (y = 0; y < size; ++y) { - for (x = 0; x < size; ++x) { - pts[i].x = x; - pts[i].y = y; - ++i; - } - } - for (i = 0; i < size * size; ++i) { - j = i + (int)((double)(size * size - i) * grandom_double()); - x = pts[i].x; - y = pts[i].y; - pts[i].x = pts[j].x; - pts[i].y = pts[j].y; - pts[j].x = x; - pts[j].y = y; - } - - // construct the circle template - tmpl = (char *)gmallocn((r+1)*(r+1), sizeof(char)); - for (y = 0; y <= r; ++y) { - for (x = 0; x <= r; ++x) { - tmpl[y*(r+1) + x] = (x * y <= r * r) ? 1 : 0; - } - } - - // mark all grid cells as free - grid = (char *)gmallocn(size * size, sizeof(char)); - for (y = 0; y < size; ++y) { - for (x = 0; x < size; ++x) { - grid[(y << log2Size) + x] = 0; - } - } - - // walk the space-filling curve, adding dots - dotsLen = 0; - dotsSize = 32; - dots = (SplashScreenPoint *)gmallocn(dotsSize, sizeof(SplashScreenPoint)); - for (i = 0; i < size * size; ++i) { - x = pts[i].x; - y = pts[i].y; - if (!grid[(y << log2Size) + x]) { - if (dotsLen == dotsSize) { - dotsSize *= 2; - dots = (SplashScreenPoint *)greallocn(dots, dotsSize, - sizeof(SplashScreenPoint)); - } - dots[dotsLen++] = pts[i]; - for (yy = 0; yy <= r; ++yy) { - y0 = (y + yy) % size; - y1 = (y - yy + size) % size; - for (xx = 0; xx <= r; ++xx) { - if (tmpl[yy*(r+1) + xx]) { - x0 = (x + xx) % size; - x1 = (x - xx + size) % size; - grid[(y0 << log2Size) + x0] = 1; - grid[(y0 << log2Size) + x1] = 1; - grid[(y1 << log2Size) + x0] = 1; - grid[(y1 << log2Size) + x1] = 1; - } - } - } - } - } - - gfree(tmpl); - gfree(grid); - - // assign each cell to a dot, compute distance to center of dot - region = (int *)gmallocn(size * size, sizeof(int)); - dist = (int *)gmallocn(size * size, sizeof(int)); - for (y = 0; y < size; ++y) { - for (x = 0; x < size; ++x) { - iMin = 0; - dMin = distance(dots[0].x, dots[0].y, x, y); - for (i = 1; i < dotsLen; ++i) { - d = distance(dots[i].x, dots[i].y, x, y); - if (d < dMin) { - iMin = i; - dMin = d; - } - } - region[(y << log2Size) + x] = iMin; - dist[(y << log2Size) + x] = dMin; - } - } - - // compute threshold values - for (i = 0; i < dotsLen; ++i) { - n = 0; - for (y = 0; y < size; ++y) { - for (x = 0; x < size; ++x) { - if (region[(y << log2Size) + x] == i) { - pts[n].x = x; - pts[n].y = y; - pts[n].dist = distance(dots[i].x, dots[i].y, x, y); - ++n; - } - } - } - std::sort(pts, pts + n, cmpDistancesFunctor()); - for (j = 0; j < n; ++j) { - // map values in [0 .. n-1] --> [255 .. 1] - mat[(pts[j].y << log2Size) + pts[j].x] = 255 - (254 * j) / (n - 1); - } - } - - gfree(pts); - gfree(region); - gfree(dist); - - gfree(dots); -} - -SplashScreen::SplashScreen(SplashScreen *screen) { - screenParams = screen->screenParams; - size = screen->size; - sizeM1 = screen->sizeM1; - log2Size = screen->log2Size; - mat = (Guchar *)gmallocn(size * size, sizeof(Guchar)); - if (likely(mat != NULL)) { - memcpy(mat, screen->mat, size * size * sizeof(Guchar)); - } - minVal = screen->minVal; - maxVal = screen->maxVal; -} - -SplashScreen::~SplashScreen() { - gfree(mat); -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashScreen.h b/Build/source/libs/poppler/poppler-src/splash/SplashScreen.h deleted file mode 100644 index a7fc4559148..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashScreen.h +++ /dev/null @@ -1,80 +0,0 @@ -//======================================================================== -// -// SplashScreen.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2009 Albert Astals Cid <aacid@kde.org> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHSCREEN_H -#define SPLASHSCREEN_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "SplashTypes.h" - -#include <stdlib.h> - -//------------------------------------------------------------------------ -// SplashScreen -//------------------------------------------------------------------------ - -class SplashScreen { -public: - - SplashScreen(SplashScreenParams *params); - SplashScreen(SplashScreen *screen); - ~SplashScreen(); - - SplashScreen *copy() { return new SplashScreen(this); } - - // Return the computed pixel value (0=black, 1=white) for the gray - // level <value> at (<x>, <y>). - int test(int x, int y, Guchar value) { - int xx, yy; - if (mat == NULL) createMatrix(); - xx = x & sizeM1; - yy = y & sizeM1; - return value < mat[(yy << log2Size) + xx] ? 0 : 1; - } - - // Returns true if value is above the white threshold or below the - // black threshold, i.e., if the corresponding halftone will be - // solid white or black. - GBool isStatic(Guchar value) { if (mat == NULL) createMatrix(); return value < minVal || value >= maxVal; } - -private: - void createMatrix(); - - void buildDispersedMatrix(int i, int j, int val, - int delta, int offset); - void buildClusteredMatrix(); - int distance(int x0, int y0, int x1, int y1); - void buildSCDMatrix(int r); - - SplashScreenParams *screenParams; // params to create the other members - Guchar *mat; // threshold matrix - int size; // size of the threshold matrix - int sizeM1; // size - 1 - int log2Size; // log2(size) - Guchar minVal; // any pixel value below minVal generates - // solid black - Guchar maxVal; // any pixel value above maxVal generates - // solid white -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashState.cc b/Build/source/libs/poppler/poppler-src/splash/SplashState.cc deleted file mode 100644 index abd940842ae..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashState.cc +++ /dev/null @@ -1,273 +0,0 @@ -//======================================================================== -// -// SplashState.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2009, 2011, 2012, 2015 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <string.h> -#include "goo/gmem.h" -#include "SplashPattern.h" -#include "SplashScreen.h" -#include "SplashClip.h" -#include "SplashBitmap.h" -#include "SplashState.h" - -//------------------------------------------------------------------------ -// SplashState -//------------------------------------------------------------------------ - -// number of components in each color mode -int splashColorModeNComps[] = { - 1, 1, 3, 3, 4 -#ifdef SPLASH_CMYK - , 4, 4 + SPOT_NCOMPS -#endif -}; - -SplashState::SplashState(int width, int height, GBool vectorAntialias, - SplashScreenParams *screenParams) { - SplashColor color; - int i; - - matrix[0] = 1; matrix[1] = 0; - matrix[2] = 0; matrix[3] = 1; - matrix[4] = 0; matrix[5] = 0; - memset(&color, 0, sizeof(SplashColor)); - strokePattern = new SplashSolidColor(color); - fillPattern = new SplashSolidColor(color); - screen = new SplashScreen(screenParams); - blendFunc = NULL; - strokeAlpha = 1; - fillAlpha = 1; - multiplyPatternAlpha = gFalse; - patternStrokeAlpha = 1; - patternFillAlpha = 1; - lineWidth = 0; - lineCap = splashLineCapButt; - lineJoin = splashLineJoinMiter; - miterLimit = 10; - flatness = 1; - lineDash = NULL; - lineDashLength = 0; - lineDashPhase = 0; - strokeAdjust = gFalse; - clip = new SplashClip(0, 0, width - 0.001, height - 0.001, vectorAntialias); - softMask = NULL; - deleteSoftMask = gFalse; - inNonIsolatedGroup = gFalse; - fillOverprint = gFalse; - strokeOverprint = gFalse; - overprintMode = 0; - for (i = 0; i < 256; ++i) { - rgbTransferR[i] = (Guchar)i; - rgbTransferG[i] = (Guchar)i; - rgbTransferB[i] = (Guchar)i; - grayTransfer[i] = (Guchar)i; -#ifdef SPLASH_CMYK - cmykTransferC[i] = (Guchar)i; - cmykTransferM[i] = (Guchar)i; - cmykTransferY[i] = (Guchar)i; - cmykTransferK[i] = (Guchar)i; - for (int cp = 0; cp < SPOT_NCOMPS+4; cp++) - deviceNTransfer[cp][i] = (Guchar)i; -#endif - } - overprintMask = 0xffffffff; - overprintAdditive = gFalse; - next = NULL; -} - -SplashState::SplashState(int width, int height, GBool vectorAntialias, - SplashScreen *screenA) { - SplashColor color; - int i; - - matrix[0] = 1; matrix[1] = 0; - matrix[2] = 0; matrix[3] = 1; - matrix[4] = 0; matrix[5] = 0; - memset(&color, 0, sizeof(SplashColor)); - strokePattern = new SplashSolidColor(color); - fillPattern = new SplashSolidColor(color); - screen = screenA->copy(); - blendFunc = NULL; - strokeAlpha = 1; - fillAlpha = 1; - multiplyPatternAlpha = gFalse; - patternStrokeAlpha = 1; - patternFillAlpha = 1; - lineWidth = 0; - lineCap = splashLineCapButt; - lineJoin = splashLineJoinMiter; - miterLimit = 10; - flatness = 1; - lineDash = NULL; - lineDashLength = 0; - lineDashPhase = 0; - strokeAdjust = gFalse; - clip = new SplashClip(0, 0, width - 0.001, height - 0.001, vectorAntialias); - softMask = NULL; - deleteSoftMask = gFalse; - inNonIsolatedGroup = gFalse; - fillOverprint = gFalse; - strokeOverprint = gFalse; - overprintMode = 0; - for (i = 0; i < 256; ++i) { - rgbTransferR[i] = (Guchar)i; - rgbTransferG[i] = (Guchar)i; - rgbTransferB[i] = (Guchar)i; - grayTransfer[i] = (Guchar)i; -#ifdef SPLASH_CMYK - cmykTransferC[i] = (Guchar)i; - cmykTransferM[i] = (Guchar)i; - cmykTransferY[i] = (Guchar)i; - cmykTransferK[i] = (Guchar)i; - for (int cp = 0; cp < SPOT_NCOMPS+4; cp++) - deviceNTransfer[cp][i] = (Guchar)i; -#endif - } - overprintMask = 0xffffffff; - overprintAdditive = gFalse; - next = NULL; -} - -SplashState::SplashState(SplashState *state) { - memcpy(matrix, state->matrix, 6 * sizeof(SplashCoord)); - strokePattern = state->strokePattern->copy(); - fillPattern = state->fillPattern->copy(); - screen = state->screen->copy(); - blendFunc = state->blendFunc; - strokeAlpha = state->strokeAlpha; - fillAlpha = state->fillAlpha; - multiplyPatternAlpha = state->multiplyPatternAlpha; - patternStrokeAlpha = state->patternStrokeAlpha; - patternFillAlpha = state->patternFillAlpha; - lineWidth = state->lineWidth; - lineCap = state->lineCap; - lineJoin = state->lineJoin; - miterLimit = state->miterLimit; - flatness = state->flatness; - if (state->lineDash) { - lineDashLength = state->lineDashLength; - lineDash = (SplashCoord *)gmallocn(lineDashLength, sizeof(SplashCoord)); - memcpy(lineDash, state->lineDash, lineDashLength * sizeof(SplashCoord)); - } else { - lineDash = NULL; - lineDashLength = 0; - } - lineDashPhase = state->lineDashPhase; - strokeAdjust = state->strokeAdjust; - clip = state->clip->copy(); - softMask = state->softMask; - deleteSoftMask = gFalse; - inNonIsolatedGroup = state->inNonIsolatedGroup; - fillOverprint = state->fillOverprint; - strokeOverprint = state->strokeOverprint; - overprintMode = state->overprintMode; - memcpy(rgbTransferR, state->rgbTransferR, 256); - memcpy(rgbTransferG, state->rgbTransferG, 256); - memcpy(rgbTransferB, state->rgbTransferB, 256); - memcpy(grayTransfer, state->grayTransfer, 256); -#ifdef SPLASH_CMYK - memcpy(cmykTransferC, state->cmykTransferC, 256); - memcpy(cmykTransferM, state->cmykTransferM, 256); - memcpy(cmykTransferY, state->cmykTransferY, 256); - memcpy(cmykTransferK, state->cmykTransferK, 256); - for (int cp = 0; cp < SPOT_NCOMPS+4; cp++) - memcpy(deviceNTransfer[cp], state->deviceNTransfer[cp], 256); -#endif - overprintMask = state->overprintMask; - overprintAdditive = state->overprintAdditive; - next = NULL; -} - -SplashState::~SplashState() { - delete strokePattern; - delete fillPattern; - delete screen; - gfree(lineDash); - delete clip; - if (deleteSoftMask && softMask) { - delete softMask; - } -} - -void SplashState::setStrokePattern(SplashPattern *strokePatternA) { - delete strokePattern; - strokePattern = strokePatternA; -} - -void SplashState::setFillPattern(SplashPattern *fillPatternA) { - delete fillPattern; - fillPattern = fillPatternA; -} - -void SplashState::setScreen(SplashScreen *screenA) { - delete screen; - screen = screenA; -} - -void SplashState::setLineDash(SplashCoord *lineDashA, int lineDashLengthA, - SplashCoord lineDashPhaseA) { - gfree(lineDash); - lineDashLength = lineDashLengthA; - if (lineDashLength > 0) { - lineDash = (SplashCoord *)gmallocn(lineDashLength, sizeof(SplashCoord)); - memcpy(lineDash, lineDashA, lineDashLength * sizeof(SplashCoord)); - } else { - lineDash = NULL; - } - lineDashPhase = lineDashPhaseA; -} - -void SplashState::setSoftMask(SplashBitmap *softMaskA) { - if (deleteSoftMask) { - delete softMask; - } - softMask = softMaskA; - deleteSoftMask = gTrue; -} - -void SplashState::setTransfer(Guchar *red, Guchar *green, Guchar *blue, - Guchar *gray) { -#ifdef SPLASH_CMYK - int i; - - for (i = 0; i < 256; ++i) { - cmykTransferC[i] = 255 - rgbTransferR[255 - i]; - cmykTransferM[i] = 255 - rgbTransferG[255 - i]; - cmykTransferY[i] = 255 - rgbTransferB[255 - i]; - cmykTransferK[i] = 255 - grayTransfer[255 - i]; - } - for (i = 0; i < 256; ++i) { - deviceNTransfer[0][i] = 255 - rgbTransferR[255 - i]; - deviceNTransfer[1][i] = 255 - rgbTransferG[255 - i]; - deviceNTransfer[2][i] = 255 - rgbTransferB[255 - i]; - deviceNTransfer[3][i] = 255 - grayTransfer[255 - i]; - } -#endif - memcpy(rgbTransferR, red, 256); - memcpy(rgbTransferG, green, 256); - memcpy(rgbTransferB, blue, 256); - memcpy(grayTransfer, gray, 256); -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashState.h b/Build/source/libs/poppler/poppler-src/splash/SplashState.h deleted file mode 100644 index 32270382037..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashState.h +++ /dev/null @@ -1,143 +0,0 @@ -//======================================================================== -// -// SplashState.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2011, 2012, 2015 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHSTATE_H -#define SPLASHSTATE_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "SplashTypes.h" - -class SplashPattern; -class SplashScreen; -class SplashClip; -class SplashBitmap; - -//------------------------------------------------------------------------ -// line cap values -//------------------------------------------------------------------------ - -#define splashLineCapButt 0 -#define splashLineCapRound 1 -#define splashLineCapProjecting 2 - -//------------------------------------------------------------------------ -// line join values -//------------------------------------------------------------------------ - -#define splashLineJoinMiter 0 -#define splashLineJoinRound 1 -#define splashLineJoinBevel 2 - -//------------------------------------------------------------------------ -// SplashState -//------------------------------------------------------------------------ - -class SplashState { -public: - - // Create a new state object, initialized with default settings. - SplashState(int width, int height, GBool vectorAntialias, - SplashScreenParams *screenParams); - SplashState(int width, int height, GBool vectorAntialias, - SplashScreen *screenA); - - // Copy a state object. - SplashState *copy() { return new SplashState(this); } - - ~SplashState(); - - // Set the stroke pattern. This does not copy <strokePatternA>. - void setStrokePattern(SplashPattern *strokePatternA); - - // Set the fill pattern. This does not copy <fillPatternA>. - void setFillPattern(SplashPattern *fillPatternA); - - // Set the screen. This does not copy <screenA>. - void setScreen(SplashScreen *screenA); - - // Set the line dash pattern. This copies the <lineDashA> array. - void setLineDash(SplashCoord *lineDashA, int lineDashLengthA, - SplashCoord lineDashPhaseA); - - // Set the soft mask bitmap. - void setSoftMask(SplashBitmap *softMaskA); - - // Set the overprint parametes. - void setFillOverprint(GBool fillOverprintA) { fillOverprint = fillOverprintA; } - void setStrokeOverprint(GBool strokeOverprintA) { strokeOverprint = strokeOverprintA; } - void setOverprintMode(int overprintModeA) { overprintMode = overprintModeA; } - - // Set the transfer function. - void setTransfer(Guchar *red, Guchar *green, Guchar *blue, Guchar *gray); - -private: - - SplashState(SplashState *state); - - SplashCoord matrix[6]; - SplashPattern *strokePattern; - SplashPattern *fillPattern; - SplashScreen *screen; - SplashBlendFunc blendFunc; - SplashCoord strokeAlpha; - SplashCoord fillAlpha; - GBool multiplyPatternAlpha; - SplashCoord patternStrokeAlpha; - SplashCoord patternFillAlpha; - SplashCoord lineWidth; - int lineCap; - int lineJoin; - SplashCoord miterLimit; - SplashCoord flatness; - SplashCoord *lineDash; - int lineDashLength; - SplashCoord lineDashPhase; - GBool strokeAdjust; - SplashClip *clip; - SplashBitmap *softMask; - GBool deleteSoftMask; - GBool inNonIsolatedGroup; - GBool fillOverprint; - GBool strokeOverprint; - int overprintMode; - Guchar rgbTransferR[256], - rgbTransferG[256], - rgbTransferB[256]; - Guchar grayTransfer[256]; -#ifdef SPLASH_CMYK - Guchar cmykTransferC[256], - cmykTransferM[256], - cmykTransferY[256], - cmykTransferK[256]; - Guchar deviceNTransfer[SPOT_NCOMPS+4][256]; -#endif - Guint overprintMask; - GBool overprintAdditive; - - SplashState *next; // used by Splash class - - friend class Splash; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashXPath.cc b/Build/source/libs/poppler/poppler-src/splash/SplashXPath.cc deleted file mode 100644 index 9c5c8813a2c..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashXPath.cc +++ /dev/null @@ -1,473 +0,0 @@ -//======================================================================== -// -// SplashXPath.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2010 PaweÅ‚ Wiejacha <pawel.wiejacha@gmail.com> -// Copyright (C) 2010, 2011 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de> -// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <stdlib.h> -#include <string.h> -#include <algorithm> -#include "goo/gmem.h" -#include "SplashMath.h" -#include "SplashPath.h" -#include "SplashXPath.h" - -//------------------------------------------------------------------------ - -struct SplashXPathPoint { - SplashCoord x, y; -}; - -struct SplashXPathAdjust { - int firstPt, lastPt; // range of points - GBool vert; // vertical or horizontal hint - SplashCoord x0a, x0b, // hint boundaries - xma, xmb, - x1a, x1b; - SplashCoord x0, x1, xm; // adjusted coordinates -}; - -//------------------------------------------------------------------------ - -// Transform a point from user space to device space. -inline void SplashXPath::transform(SplashCoord *matrix, - SplashCoord xi, SplashCoord yi, - SplashCoord *xo, SplashCoord *yo) { - // [ m[0] m[1] 0 ] - // [xo yo 1] = [xi yi 1] * [ m[2] m[3] 0 ] - // [ m[4] m[5] 1 ] - *xo = xi * matrix[0] + yi * matrix[2] + matrix[4]; - *yo = xi * matrix[1] + yi * matrix[3] + matrix[5]; -} - -//------------------------------------------------------------------------ -// SplashXPath -//------------------------------------------------------------------------ - -SplashXPath::SplashXPath(SplashPath *path, SplashCoord *matrix, - SplashCoord flatness, GBool closeSubpaths, - GBool adjustLines, int linePosI) { - SplashPathHint *hint; - SplashXPathPoint *pts; - SplashXPathAdjust *adjusts, *adjust; - SplashCoord x0, y0, x1, y1, x2, y2, x3, y3, xsp, ysp; - SplashCoord adj0, adj1; - int curSubpath, i, j; - - // transform the points - pts = (SplashXPathPoint *)gmallocn(path->length, sizeof(SplashXPathPoint)); - for (i = 0; i < path->length; ++i) { - transform(matrix, path->pts[i].x, path->pts[i].y, &pts[i].x, &pts[i].y); - } - - // set up the stroke adjustment hints - if (path->hints) { - adjusts = (SplashXPathAdjust *)gmallocn(path->hintsLength, - sizeof(SplashXPathAdjust)); - for (i = 0; i < path->hintsLength; ++i) { - hint = &path->hints[i]; - if (hint->ctrl0 + 1 >= path->length || hint->ctrl1 + 1 >= path->length) { - gfree(adjusts); - adjusts = NULL; - break; - } - x0 = pts[hint->ctrl0 ].x; y0 = pts[hint->ctrl0 ].y; - x1 = pts[hint->ctrl0 + 1].x; y1 = pts[hint->ctrl0 + 1].y; - x2 = pts[hint->ctrl1 ].x; y2 = pts[hint->ctrl1 ].y; - x3 = pts[hint->ctrl1 + 1].x; y3 = pts[hint->ctrl1 + 1].y; - if (x0 == x1 && x2 == x3) { - adjusts[i].vert = gTrue; - adj0 = x0; - adj1 = x2; - } else if (y0 == y1 && y2 == y3) { - adjusts[i].vert = gFalse; - adj0 = y0; - adj1 = y2; - } else { - gfree(adjusts); - adjusts = NULL; - break; - } - if (adj0 > adj1) { - x0 = adj0; - adj0 = adj1; - adj1 = x0; - } - adjusts[i].x0a = adj0 - 0.01; - adjusts[i].x0b = adj0 + 0.01; - adjusts[i].xma = (SplashCoord)0.5 * (adj0 + adj1) - 0.01; - adjusts[i].xmb = (SplashCoord)0.5 * (adj0 + adj1) + 0.01; - adjusts[i].x1a = adj1 - 0.01; - adjusts[i].x1b = adj1 + 0.01; - // rounding both edge coordinates can result in lines of - // different widths (e.g., adj=10.1, adj1=11.3 --> x0=10, x1=11; - // adj0=10.4, adj1=11.6 --> x0=10, x1=12), but it has the - // benefit of making adjacent strokes/fills line up without any - // gaps between them - x0 = splashRound(adj0); - x1 = splashRound(adj1); - if (x1 == x0) { - if (adjustLines) { - // the adjustment moves thin lines (clip rectangle with - // empty width or height) out of clip area, here we need - // a special adjustment: - x0 = linePosI; - x1 = x0 + 1; - } else { - x1 = x1 + 1; - } - } - adjusts[i].x0 = (SplashCoord)x0; - adjusts[i].x1 = (SplashCoord)x1 - 0.01; - adjusts[i].xm = (SplashCoord)0.5 * (adjusts[i].x0 + adjusts[i].x1); - adjusts[i].firstPt = hint->firstPt; - adjusts[i].lastPt = hint->lastPt; - } - - } else { - adjusts = NULL; - } - - // perform stroke adjustment - if (adjusts) { - for (i = 0, adjust = adjusts; i < path->hintsLength; ++i, ++adjust) { - for (j = adjust->firstPt; j <= adjust->lastPt; ++j) { - strokeAdjust(adjust, &pts[j].x, &pts[j].y); - } - } - gfree(adjusts); - } - - segs = NULL; - length = size = 0; - - x0 = y0 = xsp = ysp = 0; // make gcc happy - adj0 = adj1 = 0; // make gcc happy - curSubpath = 0; - i = 0; - while (i < path->length) { - - // first point in subpath - skip it - if (path->flags[i] & splashPathFirst) { - x0 = pts[i].x; - y0 = pts[i].y; - xsp = x0; - ysp = y0; - curSubpath = i; - ++i; - - } else { - - // curve segment - if (path->flags[i] & splashPathCurve) { - x1 = pts[i].x; - y1 = pts[i].y; - x2 = pts[i+1].x; - y2 = pts[i+1].y; - x3 = pts[i+2].x; - y3 = pts[i+2].y; - addCurve(x0, y0, x1, y1, x2, y2, x3, y3, - flatness, - (path->flags[i-1] & splashPathFirst), - (path->flags[i+2] & splashPathLast), - !closeSubpaths && - (path->flags[i-1] & splashPathFirst) && - !(path->flags[i-1] & splashPathClosed), - !closeSubpaths && - (path->flags[i+2] & splashPathLast) && - !(path->flags[i+2] & splashPathClosed)); - x0 = x3; - y0 = y3; - i += 3; - - // line segment - } else { - x1 = pts[i].x; - y1 = pts[i].y; - addSegment(x0, y0, x1, y1); - x0 = x1; - y0 = y1; - ++i; - } - - // close a subpath - if (closeSubpaths && - (path->flags[i-1] & splashPathLast) && - (pts[i-1].x != pts[curSubpath].x || - pts[i-1].y != pts[curSubpath].y)) { - addSegment(x0, y0, xsp, ysp); - } - } - } - - gfree(pts); -} - -// Apply the stroke adjust hints to point <pt>: (*<xp>, *<yp>). -void SplashXPath::strokeAdjust(SplashXPathAdjust *adjust, - SplashCoord *xp, SplashCoord *yp) { - SplashCoord x, y; - - if (adjust->vert) { - x = *xp; - if (x > adjust->x0a && x < adjust->x0b) { - *xp = adjust->x0; - } else if (x > adjust->xma && x < adjust->xmb) { - *xp = adjust->xm; - } else if (x > adjust->x1a && x < adjust->x1b) { - *xp = adjust->x1; - } - } else { - y = *yp; - if (y > adjust->x0a && y < adjust->x0b) { - *yp = adjust->x0; - } else if (y > adjust->xma && y < adjust->xmb) { - *yp = adjust->xm; - } else if (y > adjust->x1a && y < adjust->x1b) { - *yp = adjust->x1; - } - } -} - -SplashXPath::SplashXPath(SplashXPath *xPath) { - length = xPath->length; - size = xPath->size; - segs = (SplashXPathSeg *)gmallocn(size, sizeof(SplashXPathSeg)); - memcpy(segs, xPath->segs, length * sizeof(SplashXPathSeg)); -} - -SplashXPath::~SplashXPath() { - gfree(segs); -} - -// Add space for <nSegs> more segments -void SplashXPath::grow(int nSegs) { - if (length + nSegs > size) { - if (size == 0) { - size = 32; - } - while (size < length + nSegs) { - size *= 2; - } - segs = (SplashXPathSeg *)greallocn(segs, size, sizeof(SplashXPathSeg)); - } -} - -void SplashXPath::addCurve(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1, - SplashCoord x2, SplashCoord y2, - SplashCoord x3, SplashCoord y3, - SplashCoord flatness, - GBool first, GBool last, GBool end0, GBool end1) { - SplashCoord *cx = new SplashCoord[(splashMaxCurveSplits + 1) * 3]; - SplashCoord *cy = new SplashCoord[(splashMaxCurveSplits + 1) * 3]; - int *cNext = new int[splashMaxCurveSplits + 1]; - SplashCoord xl0, xl1, xl2, xr0, xr1, xr2, xr3, xx1, xx2, xh; - SplashCoord yl0, yl1, yl2, yr0, yr1, yr2, yr3, yy1, yy2, yh; - SplashCoord dx, dy, mx, my, d1, d2, flatness2; - int p1, p2, p3; - -#ifdef USE_FIXEDPOINT - flatness2 = flatness; -#else - flatness2 = flatness * flatness; -#endif - - // initial segment - p1 = 0; - p2 = splashMaxCurveSplits; - - *(cx + p1 * 3 + 0) = x0; - *(cx + p1 * 3 + 1) = x1; - *(cx + p1 * 3 + 2) = x2; - *(cx + p2 * 3 + 0) = x3; - - *(cy + p1 * 3 + 0) = y0; - *(cy + p1 * 3 + 1) = y1; - *(cy + p1 * 3 + 2) = y2; - *(cy + p2 * 3 + 0) = y3; - - *(cNext + p1) = p2; - - while (p1 < splashMaxCurveSplits) { - - // get the next segment - xl0 = *(cx + p1 * 3 + 0); - xx1 = *(cx + p1 * 3 + 1); - xx2 = *(cx + p1 * 3 + 2); - - yl0 = *(cy + p1 * 3 + 0); - yy1 = *(cy + p1 * 3 + 1); - yy2 = *(cy + p1 * 3 + 2); - - p2 = *(cNext + p1); - - xr3 = *(cx + p2 * 3 + 0); - yr3 = *(cy + p2 * 3 + 0); - - // compute the distances from the control points to the - // midpoint of the straight line (this is a bit of a hack, but - // it's much faster than computing the actual distances to the - // line) - mx = (xl0 + xr3) * 0.5; - my = (yl0 + yr3) * 0.5; -#ifdef USE_FIXEDPOINT - d1 = splashDist(xx1, yy1, mx, my); - d2 = splashDist(xx2, yy2, mx, my); -#else - dx = xx1 - mx; - dy = yy1 - my; - d1 = dx*dx + dy*dy; - dx = xx2 - mx; - dy = yy2 - my; - d2 = dx*dx + dy*dy; -#endif - - // if the curve is flat enough, or no more subdivisions are - // allowed, add the straight line segment - if (p2 - p1 == 1 || (d1 <= flatness2 && d2 <= flatness2)) { - addSegment(xl0, yl0, xr3, yr3); - p1 = p2; - - // otherwise, subdivide the curve - } else { - xl1 = (xl0 + xx1) * 0.5; - yl1 = (yl0 + yy1) * 0.5; - xh = (xx1 + xx2) * 0.5; - yh = (yy1 + yy2) * 0.5; - xl2 = (xl1 + xh) * 0.5; - yl2 = (yl1 + yh) * 0.5; - xr2 = (xx2 + xr3) * 0.5; - yr2 = (yy2 + yr3) * 0.5; - xr1 = (xh + xr2) * 0.5; - yr1 = (yh + yr2) * 0.5; - xr0 = (xl2 + xr1) * 0.5; - yr0 = (yl2 + yr1) * 0.5; - // add the new subdivision points - p3 = (p1 + p2) / 2; - - *(cx + p1 * 3 + 1) = xl1; - *(cx + p1 * 3 + 2) = xl2; - - *(cy + p1 * 3 + 1) = yl1; - *(cy + p1 * 3 + 2) = yl2; - - *(cNext + p1) = p3; - - *(cx + p3 * 3 + 0) = xr0; - *(cx + p3 * 3 + 1) = xr1; - *(cx + p3 * 3 + 2) = xr2; - - *(cy + p3 * 3 + 0) = yr0; - *(cy + p3 * 3 + 1) = yr1; - *(cy + p3 * 3 + 2) = yr2; - - *(cNext + p3) = p2; - } - } - - delete [] cx; - delete [] cy; - delete [] cNext; -} - -void SplashXPath::addSegment(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1) { - grow(1); - segs[length].x0 = x0; - segs[length].y0 = y0; - segs[length].x1 = x1; - segs[length].y1 = y1; - segs[length].flags = 0; - if (y1 == y0) { - segs[length].dxdy = segs[length].dydx = 0; - segs[length].flags |= splashXPathHoriz; - if (x1 == x0) { - segs[length].flags |= splashXPathVert; - } - } else if (x1 == x0) { - segs[length].dxdy = segs[length].dydx = 0; - segs[length].flags |= splashXPathVert; - } else { -#ifdef USE_FIXEDPOINT - if (FixedPoint::divCheck(x1 - x0, y1 - y0, &segs[length].dxdy)) { - segs[length].dydx = (SplashCoord)1 / segs[length].dxdy; - } else { - segs[length].dxdy = segs[length].dydx = 0; - if (splashAbs(x1 - x0) > splashAbs(y1 - y0)) { - segs[length].flags |= splashXPathHoriz; - } else { - segs[length].flags |= splashXPathVert; - } - } -#else - segs[length].dxdy = (x1 - x0) / (y1 - y0); - segs[length].dydx = (SplashCoord)1 / segs[length].dxdy; -#endif - } - if (y0 > y1) { - segs[length].flags |= splashXPathFlip; - } - ++length; -} - -struct cmpXPathSegsFunctor { - bool operator()(const SplashXPathSeg &seg0, const SplashXPathSeg &seg1) { - SplashCoord x0, y0, x1, y1; - - if (seg0.flags & splashXPathFlip) { - x0 = seg0.x1; - y0 = seg0.y1; - } else { - x0 = seg0.x0; - y0 = seg0.y0; - } - if (seg1.flags & splashXPathFlip) { - x1 = seg1.x1; - y1 = seg1.y1; - } else { - x1 = seg1.x0; - y1 = seg1.y0; - } - return (y0 != y1) ? (y0 < y1) : (x0 < x1); - } -}; - -void SplashXPath::aaScale() { - SplashXPathSeg *seg; - int i; - - for (i = 0, seg = segs; i < length; ++i, ++seg) { - seg->x0 *= splashAASize; - seg->y0 *= splashAASize; - seg->x1 *= splashAASize; - seg->y1 *= splashAASize; - } -} - -void SplashXPath::sort() { - std::sort(segs, segs + length, cmpXPathSegsFunctor()); -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashXPath.h b/Build/source/libs/poppler/poppler-src/splash/SplashXPath.h deleted file mode 100644 index 1c7040daa23..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashXPath.h +++ /dev/null @@ -1,107 +0,0 @@ -//======================================================================== -// -// SplashXPath.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHXPATH_H -#define SPLASHXPATH_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "SplashTypes.h" - -class SplashPath; -struct SplashXPathAdjust; - -//------------------------------------------------------------------------ - -#define splashMaxCurveSplits (1 << 10) - -//------------------------------------------------------------------------ -// SplashXPathSeg -//------------------------------------------------------------------------ - -struct SplashXPathSeg { - SplashCoord x0, y0; // first endpoint - SplashCoord x1, y1; // second endpoint - SplashCoord dxdy; // slope: delta-x / delta-y - SplashCoord dydx; // slope: delta-y / delta-x - Guint flags; -}; - -#define splashXPathHoriz 0x01 // segment is vertical (y0 == y1) - // (dxdy is undef) -#define splashXPathVert 0x02 // segment is horizontal (x0 == x1) - // (dydx is undef) -#define splashXPathFlip 0x04 // y0 > y1 - -//------------------------------------------------------------------------ -// SplashXPath -//------------------------------------------------------------------------ - -class SplashXPath { -public: - - // Expands (converts to segments) and flattens (converts curves to - // lines) <path>. Transforms all points from user space to device - // space, via <matrix>. If <closeSubpaths> is true, closes all open - // subpaths. - SplashXPath(SplashPath *path, SplashCoord *matrix, - SplashCoord flatness, GBool closeSubpaths, - GBool adjustLines = gFalse, int linePosI = 0); - - // Copy an expanded path. - SplashXPath *copy() { return new SplashXPath(this); } - - ~SplashXPath(); - - // Multiply all coordinates by splashAASize, in preparation for - // anti-aliased rendering. - void aaScale(); - - // Sort by upper coordinate (lower y), in y-major order. - void sort(); - -protected: - - SplashXPath(SplashXPath *xPath); - void transform(SplashCoord *matrix, SplashCoord xi, SplashCoord yi, - SplashCoord *xo, SplashCoord *yo); - void strokeAdjust(SplashXPathAdjust *adjust, - SplashCoord *xp, SplashCoord *yp); - void grow(int nSegs); - void addCurve(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1, - SplashCoord x2, SplashCoord y2, - SplashCoord x3, SplashCoord y3, - SplashCoord flatness, - GBool first, GBool last, GBool end0, GBool end1); - void addSegment(SplashCoord x0, SplashCoord y0, - SplashCoord x1, SplashCoord y1); - - SplashXPathSeg *segs; - int length, size; // length and size of segs array - - friend class SplashXPathScanner; - friend class SplashClip; - friend class Splash; -}; - -#endif diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashXPathScanner.cc b/Build/source/libs/poppler/poppler-src/splash/SplashXPathScanner.cc deleted file mode 100644 index ac47881cb4f..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashXPathScanner.cc +++ /dev/null @@ -1,544 +0,0 @@ -//======================================================================== -// -// SplashXPathScanner.cc -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2008, 2010, 2014 Albert Astals Cid <aacid@kde.org> -// Copyright (C) 2010 PaweÅ‚ Wiejacha <pawel.wiejacha@gmail.com> -// Copyright (C) 2013, 2014 Thomas Freitag <Thomas.Freitag@alfa.de> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#include <config.h> - -#ifdef USE_GCC_PRAGMAS -#pragma implementation -#endif - -#include <stdlib.h> -#include <string.h> -#include <algorithm> -#include "goo/gmem.h" -#include "SplashMath.h" -#include "SplashXPath.h" -#include "SplashBitmap.h" -#include "SplashXPathScanner.h" - -//------------------------------------------------------------------------ - -struct SplashIntersect { - int y; - int x0, x1; // intersection of segment with [y, y+1) - int count; // EO/NZWN counter increment -}; - -struct cmpIntersectFunctor { - bool operator()(const SplashIntersect &i0, const SplashIntersect &i1) { - return (i0.y != i1.y) ? (i0.y < i1.y) : (i0.x0 < i1.x0); - } -}; - -//------------------------------------------------------------------------ -// SplashXPathScanner -//------------------------------------------------------------------------ - -SplashXPathScanner::SplashXPathScanner(SplashXPath *xPathA, GBool eoA, - int clipYMin, int clipYMax) { - SplashXPathSeg *seg; - SplashCoord xMinFP, yMinFP, xMaxFP, yMaxFP; - int i; - - xPath = xPathA; - eo = eoA; - partialClip = gFalse; - - // compute the bbox - if (xPath->length == 0) { - xMin = yMin = 1; - xMax = yMax = 0; - } else { - seg = &xPath->segs[0]; - if (seg->x0 <= seg->x1) { - xMinFP = seg->x0; - xMaxFP = seg->x1; - } else { - xMinFP = seg->x1; - xMaxFP = seg->x0; - } - if (seg->flags & splashXPathFlip) { - yMinFP = seg->y1; - yMaxFP = seg->y0; - } else { - yMinFP = seg->y0; - yMaxFP = seg->y1; - } - for (i = 1; i < xPath->length; ++i) { - seg = &xPath->segs[i]; - if (seg->x0 < xMinFP) { - xMinFP = seg->x0; - } else if (seg->x0 > xMaxFP) { - xMaxFP = seg->x0; - } - if (seg->x1 < xMinFP) { - xMinFP = seg->x1; - } else if (seg->x1 > xMaxFP) { - xMaxFP = seg->x1; - } - if (seg->flags & splashXPathFlip) { - if (seg->y0 > yMaxFP) { - yMaxFP = seg->y0; - } - } else { - if (seg->y1 > yMaxFP) { - yMaxFP = seg->y1; - } - } - } - xMin = splashFloor(xMinFP); - xMax = splashFloor(xMaxFP); - yMin = splashFloor(yMinFP); - yMax = splashFloor(yMaxFP); - if (clipYMin > yMin) { - yMin = clipYMin; - partialClip = gTrue; - } - if (clipYMax < yMax) { - yMax = clipYMax; - partialClip = gTrue; - } - } - - allInter = NULL; - inter = NULL; - computeIntersections(); - interY = yMin - 1; -} - -SplashXPathScanner::~SplashXPathScanner() { - gfree(inter); - gfree(allInter); -} - -void SplashXPathScanner::getBBoxAA(int *xMinA, int *yMinA, - int *xMaxA, int *yMaxA) { - *xMinA = xMin / splashAASize; - *yMinA = yMin / splashAASize; - *xMaxA = xMax / splashAASize; - *yMaxA = yMax / splashAASize; -} - -void SplashXPathScanner::getSpanBounds(int y, int *spanXMin, int *spanXMax) { - int interBegin, interEnd, xx, i; - - if (y < yMin || y > yMax) { - interBegin = interEnd = 0; - } else { - interBegin = inter[y - yMin]; - interEnd = inter[y - yMin + 1]; - } - if (interBegin < interEnd) { - *spanXMin = allInter[interBegin].x0; - xx = allInter[interBegin].x1; - for (i = interBegin + 1; i < interEnd; ++i) { - if (allInter[i].x1 > xx) { - xx = allInter[i].x1; - } - } - *spanXMax = xx; - } else { - *spanXMin = xMax + 1; - *spanXMax = xMax; - } -} - -GBool SplashXPathScanner::test(int x, int y) { - int interBegin, interEnd, count, i; - - if (y < yMin || y > yMax) { - return gFalse; - } - interBegin = inter[y - yMin]; - interEnd = inter[y - yMin + 1]; - count = 0; - for (i = interBegin; i < interEnd && allInter[i].x0 <= x; ++i) { - if (x <= allInter[i].x1) { - return gTrue; - } - count += allInter[i].count; - } - return eo ? (count & 1) : (count != 0); -} - -GBool SplashXPathScanner::testSpan(int x0, int x1, int y) { - int interBegin, interEnd, count, xx1, i; - - if (y < yMin || y > yMax) { - return gFalse; - } - interBegin = inter[y - yMin]; - interEnd = inter[y - yMin + 1]; - count = 0; - for (i = interBegin; i < interEnd && allInter[i].x1 < x0; ++i) { - count += allInter[i].count; - } - - // invariant: the subspan [x0,xx1] is inside the path - xx1 = x0 - 1; - while (xx1 < x1) { - if (i >= interEnd) { - return gFalse; - } - if (allInter[i].x0 > xx1 + 1 && - !(eo ? (count & 1) : (count != 0))) { - return gFalse; - } - if (allInter[i].x1 > xx1) { - xx1 = allInter[i].x1; - } - count += allInter[i].count; - ++i; - } - - return gTrue; -} - -GBool SplashXPathScanner::getNextSpan(int y, int *x0, int *x1) { - int interEnd, xx0, xx1; - - if (y < yMin || y > yMax) { - return gFalse; - } - if (interY != y) { - interY = y; - interIdx = inter[y - yMin]; - interCount = 0; - } - interEnd = inter[y - yMin + 1]; - if (interIdx >= interEnd) { - return gFalse; - } - xx0 = allInter[interIdx].x0; - xx1 = allInter[interIdx].x1; - interCount += allInter[interIdx].count; - ++interIdx; - while (interIdx < interEnd && - (allInter[interIdx].x0 <= xx1 || - (eo ? (interCount & 1) : (interCount != 0)))) { - if (allInter[interIdx].x1 > xx1) { - xx1 = allInter[interIdx].x1; - } - interCount += allInter[interIdx].count; - ++interIdx; - } - *x0 = xx0; - *x1 = xx1; - return gTrue; -} - -void SplashXPathScanner::computeIntersections() { - SplashXPathSeg *seg; - SplashCoord segXMin, segXMax, segYMin, segYMax, xx0, xx1; - int x, y, y0, y1, i; - - if (yMin > yMax) { - return; - } - - // build the list of all intersections - allInterLen = 0; - allInterSize = 16; - allInter = (SplashIntersect *)gmallocn(allInterSize, - sizeof(SplashIntersect)); - for (i = 0; i < xPath->length; ++i) { - seg = &xPath->segs[i]; - if (seg->flags & splashXPathFlip) { - segYMin = seg->y1; - segYMax = seg->y0; - } else { - segYMin = seg->y0; - segYMax = seg->y1; - } - if (seg->flags & splashXPathHoriz) { - y = splashFloor(seg->y0); - if (y >= yMin && y <= yMax) { - if (!addIntersection(segYMin, segYMax, seg->flags, - y, splashFloor(seg->x0), splashFloor(seg->x1))) - break; - } - } else if (seg->flags & splashXPathVert) { - y0 = splashFloor(segYMin); - if (y0 < yMin) { - y0 = yMin; - } - y1 = splashFloor(segYMax); - if (y1 > yMax) { - y1 = yMax; - } - x = splashFloor(seg->x0); - for (y = y0; y <= y1; ++y) { - if (!addIntersection(segYMin, segYMax, seg->flags, y, x, x)) - break; - } - } else { - if (seg->x0 < seg->x1) { - segXMin = seg->x0; - segXMax = seg->x1; - } else { - segXMin = seg->x1; - segXMax = seg->x0; - } - y0 = splashFloor(segYMin); - if (y0 < yMin) { - y0 = yMin; - } - y1 = splashFloor(segYMax); - if (y1 > yMax) { - y1 = yMax; - } - // this loop could just add seg->dxdy to xx1 on each iteration, - // but that introduces numerical accuracy problems - xx1 = seg->x0 + ((SplashCoord)y0 - seg->y0) * seg->dxdy; - for (y = y0; y <= y1; ++y) { - xx0 = xx1; - xx1 = seg->x0 + ((SplashCoord)(y + 1) - seg->y0) * seg->dxdy; - // the segment may not actually extend to the top and/or bottom edges - if (xx0 < segXMin) { - xx0 = segXMin; - } else if (xx0 > segXMax) { - xx0 = segXMax; - } - if (xx1 < segXMin) { - xx1 = segXMin; - } else if (xx1 > segXMax) { - xx1 = segXMax; - } - if (!addIntersection(segYMin, segYMax, seg->flags, y, - splashFloor(xx0), splashFloor(xx1))) - break; - } - } - } - std::sort(allInter, allInter + allInterLen, cmpIntersectFunctor()); - - // build the list of y pointers - inter = (int *)gmallocn(yMax - yMin + 2, sizeof(int)); - i = 0; - for (y = yMin; y <= yMax; ++y) { - inter[y - yMin] = i; - while (i < allInterLen && allInter[i].y <= y) { - ++i; - } - } - inter[yMax - yMin + 1] = i; -} - -GBool SplashXPathScanner::addIntersection(double segYMin, double segYMax, - Guint segFlags, - int y, int x0, int x1) { - if (allInterLen == allInterSize) { - unsigned int newInterSize = ((unsigned int) allInterSize * 2 > INT_MAX / sizeof(SplashIntersect)) ? allInterSize + 32768 : allInterSize * 2; - if (newInterSize >= INT_MAX / sizeof(SplashIntersect)) { - error(errInternal, -1, "Bogus memory allocation size in SplashXPathScanner::addIntersection {0:d}", newInterSize); - return gFalse; - } - allInterSize = newInterSize; - allInter = (SplashIntersect *)greallocn(allInter, newInterSize, - sizeof(SplashIntersect)); - } - allInter[allInterLen].y = y; - if (x0 < x1) { - allInter[allInterLen].x0 = x0; - allInter[allInterLen].x1 = x1; - } else { - allInter[allInterLen].x0 = x1; - allInter[allInterLen].x1 = x0; - } - if (segYMin <= y && - (SplashCoord)y < segYMax && - !(segFlags & splashXPathHoriz)) { - allInter[allInterLen].count = eo ? 1 - : (segFlags & splashXPathFlip) ? 1 : -1; - } else { - allInter[allInterLen].count = 0; - } - ++allInterLen; - return gTrue; -} - -void SplashXPathScanner::renderAALine(SplashBitmap *aaBuf, - int *x0, int *x1, int y, GBool adjustVertLine) { - int xx0, xx1, xx, xxMin, xxMax, yy, interEnd; - Guchar mask; - SplashColorPtr p; - - memset(aaBuf->getDataPtr(), 0, aaBuf->getRowSize() * aaBuf->getHeight()); - xxMin = aaBuf->getWidth(); - xxMax = -1; - if (yMin <= yMax) { - if (splashAASize * y < yMin) { - interIdx = inter[0]; - } else if (splashAASize * y > yMax) { - interIdx = inter[yMax - yMin + 1]; - } else { - interIdx = inter[splashAASize * y - yMin]; - } - for (yy = 0; yy < splashAASize; ++yy) { - if (splashAASize * y + yy < yMin) { - interEnd = inter[0]; - } else if (splashAASize * y + yy > yMax) { - interEnd = inter[yMax - yMin + 1]; - } else { - interEnd = inter[splashAASize * y + yy - yMin + 1]; - } - interCount = 0; - while (interIdx < interEnd) { - xx0 = allInter[interIdx].x0; - xx1 = allInter[interIdx].x1; - interCount += allInter[interIdx].count; - ++interIdx; - while (interIdx < interEnd && - (allInter[interIdx].x0 <= xx1 || - (eo ? (interCount & 1) : (interCount != 0)))) { - if (allInter[interIdx].x1 > xx1) { - xx1 = allInter[interIdx].x1; - } - interCount += allInter[interIdx].count; - ++interIdx; - } - if (xx0 < 0) { - xx0 = 0; - } - ++xx1; - if (xx1 > aaBuf->getWidth()) { - xx1 = aaBuf->getWidth(); - } - // set [xx0, xx1) to 1 - if (xx0 < xx1) { - xx = xx0; - p = aaBuf->getDataPtr() + yy * aaBuf->getRowSize() + (xx >> 3); - if (xx & 7) { - mask = adjustVertLine ? 0xff : 0xff >> (xx & 7); - if (!adjustVertLine && (xx & ~7) == (xx1 & ~7)) { - mask &= (Guchar)(0xff00 >> (xx1 & 7)); - } - *p++ |= mask; - xx = (xx & ~7) + 8; - } - for (; xx + 7 < xx1; xx += 8) { - *p++ |= 0xff; - } - if (xx < xx1) { - *p |= adjustVertLine ? 0xff : (Guchar)(0xff00 >> (xx1 & 7)); - } - } - if (xx0 < xxMin) { - xxMin = xx0; - } - if (xx1 > xxMax) { - xxMax = xx1; - } - } - } - } - if (xxMin > xxMax) { - xxMin = xxMax; - } - *x0 = xxMin / splashAASize; - *x1 = (xxMax - 1) / splashAASize; -} - -void SplashXPathScanner::clipAALine(SplashBitmap *aaBuf, - int *x0, int *x1, int y) { - int xx0, xx1, xx, yy, interEnd; - Guchar mask; - SplashColorPtr p; - - for (yy = 0; yy < splashAASize; ++yy) { - xx = *x0 * splashAASize; - if (yMin <= yMax) { - if (splashAASize * y + yy < yMin) { - interIdx = interEnd = inter[0]; - } else if (splashAASize * y + yy > yMax) { - interIdx = interEnd = inter[yMax - yMin + 1]; - } else { - interIdx = inter[splashAASize * y + yy - yMin]; - if (splashAASize * y + yy > yMax) { - interEnd = inter[yMax - yMin + 1]; - } else { - interEnd = inter[splashAASize * y + yy - yMin + 1]; - } - } - interCount = 0; - while (interIdx < interEnd && xx < (*x1 + 1) * splashAASize) { - xx0 = allInter[interIdx].x0; - xx1 = allInter[interIdx].x1; - interCount += allInter[interIdx].count; - ++interIdx; - while (interIdx < interEnd && - (allInter[interIdx].x0 <= xx1 || - (eo ? (interCount & 1) : (interCount != 0)))) { - if (allInter[interIdx].x1 > xx1) { - xx1 = allInter[interIdx].x1; - } - interCount += allInter[interIdx].count; - ++interIdx; - } - if (xx0 > aaBuf->getWidth()) { - xx0 = aaBuf->getWidth(); - } - // set [xx, xx0) to 0 - if (xx < xx0) { - p = aaBuf->getDataPtr() + yy * aaBuf->getRowSize() + (xx >> 3); - if (xx & 7) { - mask = (Guchar)(0xff00 >> (xx & 7)); - if ((xx & ~7) == (xx0 & ~7)) { - mask |= 0xff >> (xx0 & 7); - } - *p++ &= mask; - xx = (xx & ~7) + 8; - } - for (; xx + 7 < xx0; xx += 8) { - *p++ = 0x00; - } - if (xx < xx0) { - *p &= 0xff >> (xx0 & 7); - } - } - if (xx1 >= xx) { - xx = xx1 + 1; - } - } - } - xx0 = (*x1 + 1) * splashAASize; - if (xx0 > aaBuf->getWidth()) xx0 = aaBuf->getWidth(); - // set [xx, xx0) to 0 - if (xx < xx0 && xx >= 0) { - p = aaBuf->getDataPtr() + yy * aaBuf->getRowSize() + (xx >> 3); - if (xx & 7) { - mask = (Guchar)(0xff00 >> (xx & 7)); - if ((xx & ~7) == (xx0 & ~7)) { - mask &= 0xff >> (xx0 & 7); - } - *p++ &= mask; - xx = (xx & ~7) + 8; - } - for (; xx + 7 < xx0; xx += 8) { - *p++ = 0x00; - } - if (xx < xx0) { - *p &= 0xff >> (xx0 & 7); - } - } - } -} diff --git a/Build/source/libs/poppler/poppler-src/splash/SplashXPathScanner.h b/Build/source/libs/poppler/poppler-src/splash/SplashXPathScanner.h deleted file mode 100644 index cc295cb68fe..00000000000 --- a/Build/source/libs/poppler/poppler-src/splash/SplashXPathScanner.h +++ /dev/null @@ -1,108 +0,0 @@ -//======================================================================== -// -// SplashXPathScanner.h -// -//======================================================================== - -//======================================================================== -// -// Modified under the Poppler project - http://poppler.freedesktop.org -// -// All changes made under the Poppler project to this file are licensed -// under GPL version 2 or later -// -// Copyright (C) 2013, 2014 Thomas Freitag <Thomas.Freitag@alfa.de> -// -// To see a description of the changes please see the Changelog file that -// came with your tarball or type make ChangeLog if you are building from git -// -//======================================================================== - -#ifndef SPLASHXPATHSCANNER_H -#define SPLASHXPATHSCANNER_H - -#ifdef USE_GCC_PRAGMAS -#pragma interface -#endif - -#include "SplashTypes.h" - -class SplashXPath; -class SplashBitmap; -struct SplashIntersect; - -//------------------------------------------------------------------------ -// SplashXPathScanner -//------------------------------------------------------------------------ - -class SplashXPathScanner { -public: - - // Create a new SplashXPathScanner object. <xPathA> must be sorted. - SplashXPathScanner(SplashXPath *xPathA, GBool eoA, - int clipYMin, int clipYMax); - - ~SplashXPathScanner(); - - // Return the path's bounding box. - void getBBox(int *xMinA, int *yMinA, int *xMaxA, int *yMaxA) - { *xMinA = xMin; *yMinA = yMin; *xMaxA = xMax; *yMaxA = yMax; } - - // Return the path's bounding box. - void getBBoxAA(int *xMinA, int *yMinA, int *xMaxA, int *yMaxA); - - // Returns true if at least part of the path was outside the - // clipYMin/clipYMax bounds passed to the constructor. - GBool hasPartialClip() { return partialClip; } - - // Return the min/max x values for the span at <y>. - void getSpanBounds(int y, int *spanXMin, int *spanXMax); - - // Returns true if (<x>,<y>) is inside the path. - GBool test(int x, int y); - - // Returns true if the entire span ([<x0>,<x1>], <y>) is inside the - // path. - GBool testSpan(int x0, int x1, int y); - - // Returns the next span inside the path at <y>. If <y> is - // different than the previous call to getNextSpan, this returns the - // first span at <y>; otherwise it returns the next span (relative - // to the previous call to getNextSpan). Returns false if there are - // no more spans at <y>. - GBool getNextSpan(int y, int *x0, int *x1); - - // Renders one anti-aliased line into <aaBuf>. Returns the min and - // max x coordinates with non-zero pixels in <x0> and <x1>. - void renderAALine(SplashBitmap *aaBuf, int *x0, int *x1, int y, - GBool adjustVertLine = gFalse); - - // Clips an anti-aliased line by setting pixels to zero. On entry, - // all non-zero pixels are between <x0> and <x1>. This function - // will update <x0> and <x1>. - void clipAALine(SplashBitmap *aaBuf, int *x0, int *x1, int y); - -private: - - void computeIntersections(); - GBool addIntersection(double segYMin, double segYMax, - Guint segFlags, - int y, int x0, int x1); - - SplashXPath *xPath; - GBool eo; - int xMin, yMin, xMax, yMax; - GBool partialClip; - - SplashIntersect *allInter; // array of intersections - int allInterLen; // number of intersections in <allInter> - int allInterSize; // size of the <allInter> array - int *inter; // indexes into <allInter> for each y value - int interY; // current y value - used by getNextSpan - int interIdx; // current index into <inter> - used by - // getNextSpan - int interCount; // current EO/NZWN counter - used by - // getNextSpan -}; - -#endif |