blob: 0e956c7af0220f634ce76a3db355af043883dc93 [file] [log] [blame]
//========================================================================
//
// SplashOutputDev.cc
//
// Copyright 2003 Glyph & Cog, LLC
//
//========================================================================
//========================================================================
//
// 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 Takashi Iwai <tiwai@suse.de>
// Copyright (C) 2006 Stefan Schweizer <genstef@gentoo.org>
// Copyright (C) 2006-2012 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2006 Krzysztof Kowalczyk <kkowalczyk@gmail.com>
// Copyright (C) 2006 Scott Turner <scotty1024@mac.com>
// Copyright (C) 2007 Koji Otani <sho@bbr.jp>
// Copyright (C) 2009 Petr Gajdos <pgajdos@novell.com>
// Copyright (C) 2009-2012 Thomas Freitag <Thomas.Freitag@alfa.de>
// Copyright (C) 2009 Carlos Garcia Campos <carlosgc@gnome.org>
// Copyright (C) 2009 William Bader <williambader@hotmail.com>
// Copyright (C) 2010 Patrick Spendrin <ps_ml@gmx.de>
// Copyright (C) 2010 Brian Cameron <brian.cameron@oracle.com>
// Copyright (C) 2010 Paweł Wiejacha <pawel.wiejacha@gmail.com>
// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com>
// Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com>
// Copyright (C) 2011 Andrea Canciani <ranma42@gmail.com>
// Copyright (C) 2011 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 <math.h>
#include "goo/gfile.h"
#include "GlobalParams.h"
#include "Error.h"
#include "Object.h"
#include "Gfx.h"
#include "GfxFont.h"
#include "Page.h"
#include "PDFDoc.h"
#include "Link.h"
#include "FontEncodingTables.h"
#include "fofi/FoFiTrueType.h"
#include "splash/SplashBitmap.h"
#include "splash/SplashGlyphBitmap.h"
#include "splash/SplashPattern.h"
#include "splash/SplashScreen.h"
#include "splash/SplashPath.h"
#include "splash/SplashState.h"
#include "splash/SplashErrorCodes.h"
#include "splash/SplashFontEngine.h"
#include "splash/SplashFont.h"
#include "splash/SplashFontFile.h"
#include "splash/SplashFontFileID.h"
#include "splash/Splash.h"
#include "SplashOutputDev.h"
#ifdef VMS
#if (__VMS_VER < 70000000)
extern "C" int unlink(char *filename);
#endif
#endif
#ifdef _MSC_VER
#include <float.h>
#define isfinite(x) _finite(x)
#endif
#ifdef __sun
#include <ieeefp.h>
#define isfinite(x) finite(x)
#endif
static inline void convertGfxColor(SplashColorPtr dest,
SplashColorMode colorMode,
GfxColorSpace *colorSpace,
GfxColor *src) {
SplashColor color;
GfxGray gray;
GfxRGB rgb;
#if SPLASH_CMYK
GfxCMYK cmyk;
#endif
// make gcc happy
color[0] = color[1] = color[2] = 0;
#if SPLASH_CMYK
color[3] = 0;
#endif
switch (colorMode) {
case splashModeMono1:
case splashModeMono8:
colorSpace->getGray(src, &gray);
color[0] = colToByte(gray);
break;
case splashModeXBGR8:
color[3] = 255;
case splashModeBGR8:
case splashModeRGB8:
colorSpace->getRGB(src, &rgb);
color[0] = colToByte(rgb.r);
color[1] = colToByte(rgb.g);
color[2] = colToByte(rgb.b);
break;
#if SPLASH_CMYK
case splashModeCMYK8:
colorSpace->getCMYK(src, &cmyk);
color[0] = colToByte(cmyk.c);
color[1] = colToByte(cmyk.m);
color[2] = colToByte(cmyk.y);
color[3] = colToByte(cmyk.k);
break;
#endif
}
splashColorCopy(dest, color);
}
//------------------------------------------------------------------------
// SplashGouraudPattern
//------------------------------------------------------------------------
SplashGouraudPattern::SplashGouraudPattern(GBool bDirectColorTranslationA,
GfxState *stateA, GfxGouraudTriangleShading *shadingA, SplashColorMode modeA) {
SplashColor defaultColor;
GfxColor srcColor;
state = stateA;
shading = shadingA;
mode = modeA;
bDirectColorTranslation = bDirectColorTranslationA;
shadingA->getColorSpace()->getDefaultColor(&srcColor);
convertGfxColor(defaultColor, mode, shadingA->getColorSpace(), &srcColor);
}
SplashGouraudPattern::~SplashGouraudPattern() {
}
void SplashGouraudPattern::getParameterizedColor(double colorinterp, SplashColorMode mode, SplashColorPtr dest) {
GfxColor src;
GfxColorSpace* srcColorSpace = shading->getColorSpace();
int colorComps = 3;
#if SPLASH_CMYK
if (mode == splashModeCMYK8)
colorComps=4;
#endif
shading->getParameterizedColor(colorinterp, &src);
if (bDirectColorTranslation) {
for (int m = 0; m < colorComps; ++m)
dest[m] = colToByte(src.c[m]);
} else {
convertGfxColor(dest, mode, srcColorSpace, &src);
}
}
//------------------------------------------------------------------------
// SplashUnivariatePattern
//------------------------------------------------------------------------
SplashUnivariatePattern::SplashUnivariatePattern(SplashColorMode colorModeA, GfxState *stateA, GfxUnivariateShading *shadingA) {
Matrix ctm;
double xMin, yMin, xMax, yMax;
shading = shadingA;
state = stateA;
colorMode = colorModeA;
state->getCTM(&ctm);
ctm.invertTo(&ictm);
// get the function domain
t0 = shading->getDomain0();
t1 = shading->getDomain1();
dt = t1 - t0;
stateA->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
shadingA->setupCache(&ctm, xMin, yMin, xMax, yMax);
}
SplashUnivariatePattern::~SplashUnivariatePattern() {
}
GBool SplashUnivariatePattern::getColor(int x, int y, SplashColorPtr c) {
GfxColor gfxColor;
double xc, yc, t;
ictm.transform(x, y, &xc, &yc);
if (! getParameter (xc, yc, &t))
return gFalse;
shading->getColor(t, &gfxColor);
convertGfxColor(c, colorMode, shading->getColorSpace(), &gfxColor);
return gTrue;
}
GBool SplashUnivariatePattern::testPosition(int x, int y) {
double xc, yc, t;
ictm.transform(x, y, &xc, &yc);
if (! getParameter (xc, yc, &t))
return gFalse;
return (t0 < t1) ? (t > t0 && t < t1) : (t > t1 && t < t0);
}
//------------------------------------------------------------------------
// SplashRadialPattern
//------------------------------------------------------------------------
#define RADIAL_EPSILON (1. / 1024 / 1024)
SplashRadialPattern::SplashRadialPattern(SplashColorMode colorModeA, GfxState *stateA, GfxRadialShading *shadingA):
SplashUnivariatePattern(colorModeA, stateA, shadingA)
{
SplashColor defaultColor;
GfxColor srcColor;
shadingA->getCoords(&x0, &y0, &r0, &dx, &dy, &dr);
dx -= x0;
dy -= y0;
dr -= r0;
a = dx*dx + dy*dy - dr*dr;
if (fabs(a) > RADIAL_EPSILON)
inva = 1.0 / a;
shadingA->getColorSpace()->getDefaultColor(&srcColor);
convertGfxColor(defaultColor, colorModeA, shadingA->getColorSpace(), &srcColor);
}
SplashRadialPattern::~SplashRadialPattern() {
}
GBool SplashRadialPattern::getParameter(double xs, double ys, double *t) {
double b, c, s0, s1;
// We want to solve this system of equations:
//
// 1. (x - xc(s))^2 + (y -yc(s))^2 = rc(s)^2
// 2. xc(s) = x0 + s * (x1 - xo)
// 3. yc(s) = y0 + s * (y1 - yo)
// 4. rc(s) = r0 + s * (r1 - ro)
//
// To simplify the system a little, we translate
// our coordinates to have the origin in (x0,y0)
xs -= x0;
ys -= y0;
// Then we have to solve the equation:
// A*s^2 - 2*B*s + C = 0
// where
// A = dx^2 + dy^2 - dr^2
// B = xs*dx + ys*dy + r0*dr
// C = xs^2 + ys^2 - r0^2
b = xs*dx + ys*dy + r0*dr;
c = xs*xs + ys*ys - r0*r0;
if (fabs(a) <= RADIAL_EPSILON) {
// A is 0, thus the equation simplifies to:
// -2*B*s + C = 0
// If B is 0, we can either have no solution or an indeterminate
// equation, thus we behave as if we had an invalid solution
if (fabs(b) <= RADIAL_EPSILON)
return gFalse;
s0 = s1 = 0.5 * c / b;
} else {
double d;
d = b*b - a*c;
if (d < 0)
return gFalse;
d = sqrt (d);
s0 = b + d;
s1 = b - d;
// If A < 0, one of the two solutions will have negative radius,
// thus it will be ignored. Otherwise we know that s1 <= s0
// (because d >=0 implies b - d <= b + d), so if both are valid it
// will be the true solution.
s0 *= inva;
s1 *= inva;
}
if (r0 + s0 * dr >= 0) {
if (0 <= s0 && s0 <= 1) {
*t = t0 + dt * s0;
return gTrue;
} else if (s0 < 0 && shading->getExtend0()) {
*t = t0;
return gTrue;
} else if (s0 > 1 && shading->getExtend1()) {
*t = t1;
return gTrue;
}
}
if (r0 + s1 * dr >= 0) {
if (0 <= s1 && s1 <= 1) {
*t = t0 + dt * s1;
return gTrue;
} else if (s1 < 0 && shading->getExtend0()) {
*t = t0;
return gTrue;
} else if (s1 > 1 && shading->getExtend1()) {
*t = t1;
return gTrue;
}
}
return gFalse;
}
#undef RADIAL_EPSILON
//------------------------------------------------------------------------
// SplashAxialPattern
//------------------------------------------------------------------------
SplashAxialPattern::SplashAxialPattern(SplashColorMode colorModeA, GfxState *stateA, GfxAxialShading *shadingA):
SplashUnivariatePattern(colorModeA, stateA, shadingA)
{
SplashColor defaultColor;
GfxColor srcColor;
shadingA->getCoords(&x0, &y0, &x1, &y1);
dx = x1 - x0;
dy = y1 - y0;
mul = 1 / (dx * dx + dy * dy);
shadingA->getColorSpace()->getDefaultColor(&srcColor);
convertGfxColor(defaultColor, colorModeA, shadingA->getColorSpace(), &srcColor);
}
SplashAxialPattern::~SplashAxialPattern() {
}
GBool SplashAxialPattern::getParameter(double xc, double yc, double *t) {
double s;
xc -= x0;
yc -= y0;
s = (xc * dx + yc * dy) * mul;
if (0 <= s && s <= 1) {
*t = t0 + dt * s;
} else if (s < 0 && shading->getExtend0()) {
*t = t0;
} else if (s > 1 && shading->getExtend1()) {
*t = t1;
} else {
return gFalse;
}
return gTrue;
}
//------------------------------------------------------------------------
// Type 3 font cache size parameters
#define type3FontCacheAssoc 8
#define type3FontCacheMaxSets 8
#define type3FontCacheSize (128*1024)
//------------------------------------------------------------------------
// 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);
}
#if SPLASH_CMYK
#include "GfxState_helpers.h"
//-------------------------------------------------------------------------
// helper for Blend functions (convert CMYK to RGB, do blend, convert back)
//-------------------------------------------------------------------------
// based in GfxState.cc
static void cmykToRGB(SplashColorPtr cmyk, SplashColor rgb) {
double c, m, y, k, c1, m1, y1, k1, r, g, b;
c = colToDbl(byteToCol(cmyk[0]));
m = colToDbl(byteToCol(cmyk[1]));
y = colToDbl(byteToCol(cmyk[2]));
k = colToDbl(byteToCol(cmyk[3]));
c1 = 1 - c;
m1 = 1 - m;
y1 = 1 - y;
k1 = 1 - k;
cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b);
rgb[0] = colToByte(clip01(dblToCol(r)));
rgb[1] = colToByte(clip01(dblToCol(g)));
rgb[2] = colToByte(clip01(dblToCol(b)));
}
static void rgbToCMYK(SplashColor rgb, SplashColorPtr cmyk) {
GfxColorComp c, m, y, k;
c = clip01(gfxColorComp1 - byteToCol(rgb[0]));
m = clip01(gfxColorComp1 - byteToCol(rgb[1]));
y = clip01(gfxColorComp1 - byteToCol(rgb[2]));
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
cmyk[0] = colToByte(c - k);
cmyk[1] = colToByte(m - k);
cmyk[2] = colToByte(y - k);
cmyk[3] = colToByte(k);
}
#endif
//------------------------------------------------------------------------
// Blend functions
//------------------------------------------------------------------------
static void splashOutBlendMultiply(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
rgbBlend[i] = (rgbDest[i] * rgbSrc[i]) / 255;
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
blend[i] = (dest[i] * src[i]) / 255;
}
}
}
static void splashOutBlendScreen(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
rgbBlend[i] = rgbDest[i] + rgbSrc[i] - (rgbDest[i] * rgbSrc[i]) / 255;
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
blend[i] = dest[i] + src[i] - (dest[i] * src[i]) / 255;
}
}
}
static void splashOutBlendOverlay(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
rgbBlend[i] = rgbDest[i] < 0x80
? (rgbSrc[i] * 2 * rgbDest[i]) / 255
: 255 - 2 * ((255 - rgbSrc[i]) * (255 - rgbDest[i])) / 255;
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
blend[i] = dest[i] < 0x80
? (src[i] * 2 * dest[i]) / 255
: 255 - 2 * ((255 - src[i]) * (255 - dest[i])) / 255;
}
}
}
static void splashOutBlendDarken(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
rgbBlend[i] = rgbDest[i] < rgbSrc[i] ? rgbDest[i] : rgbSrc[i];
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
blend[i] = dest[i] < src[i] ? dest[i] : src[i];
}
}
}
static void splashOutBlendLighten(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
rgbBlend[i] = rgbDest[i] > rgbSrc[i] ? rgbDest[i] : rgbSrc[i];
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
blend[i] = dest[i] > src[i] ? dest[i] : src[i];
}
}
}
static void splashOutBlendColorDodge(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend,
SplashColorMode cm) {
int i, x;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
if (rgbSrc[i] == 255) {
rgbBlend[i] = 255;
} else {
x = (rgbDest[i] * 255) / (255 - rgbSrc[i]);
rgbBlend[i] = x <= 255 ? x : 255;
}
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
if (src[i] == 255) {
blend[i] = 255;
} else {
x = (dest[i] * 255) / (255 - src[i]);
blend[i] = x <= 255 ? x : 255;
}
}
}
}
static void splashOutBlendColorBurn(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i, x;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
if (rgbSrc[i] == 0) {
rgbBlend[i] = 0;
} else {
x = ((255 - rgbDest[i]) * 255) / rgbSrc[i];
rgbBlend[i] = x <= 255 ? 255 - x : 0;
}
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
if (src[i] == 0) {
blend[i] = 0;
} else {
x = ((255 - dest[i]) * 255) / src[i];
blend[i] = x <= 255 ? 255 - x : 0;
}
}
}
}
static void splashOutBlendHardLight(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
rgbBlend[i] = rgbSrc[i] < 0x80
? (rgbDest[i] * 2 * rgbSrc[i]) / 255
: 255 - 2 * ((255 - rgbDest[i]) * (255 - rgbSrc[i])) / 255;
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
blend[i] = src[i] < 0x80
? (dest[i] * 2 * src[i]) / 255
: 255 - 2 * ((255 - dest[i]) * (255 - src[i])) / 255;
}
}
}
static void splashOutBlendSoftLight(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i, x;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
for (i = 0; i < 4; i++) {
// convert back to subtractive (s. Splash.cc)
src[i] = 0xff - src[i];
dest[i] = 0xff - dest[i];
}
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
if (rgbSrc[i] < 0x80) {
rgbBlend[i] = rgbDest[i] - (255 - 2 * rgbSrc[i]) * rgbDest[i] * (255 - rgbDest[i]) / (255 * 255);
} else {
if (rgbDest[i] < 0x40) {
x = (((((16 * rgbDest[i] - 12 * 255) * rgbDest[i]) / 255) + 4 * 255) * rgbDest[i]) / 255;
} else {
x = (int)sqrt(255.0 * rgbDest[i]);
}
rgbBlend[i] = rgbDest[i] + (2 * rgbSrc[i] - 255) * (x - rgbDest[i]) / 255;
}
}
rgbToCMYK(rgbBlend, blend);
for (i = 0; i < 4; i++) {
// convert back to additive (s. Splash.cc)
blend[i] = 0xff - blend[i];
}
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
if (src[i] < 0x80) {
blend[i] = dest[i] - (255 - 2 * src[i]) * dest[i] * (255 - dest[i]) / (255 * 255);
} else {
if (dest[i] < 0x40) {
x = (((((16 * dest[i] - 12 * 255) * dest[i]) / 255) + 4 * 255) * dest[i]) / 255;
} else {
x = (int)sqrt(255.0 * dest[i]);
}
blend[i] = dest[i] + (2 * src[i] - 255) * (x - dest[i]) / 255;
}
}
}
}
static void splashOutBlendDifference(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend,
SplashColorMode cm) {
int i;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
rgbBlend[i] = rgbDest[i] < rgbSrc[i] ? rgbSrc[i] - rgbDest[i] : rgbDest[i] - rgbSrc[i];
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
blend[i] = dest[i] < src[i] ? src[i] - dest[i] : dest[i] - src[i];
}
}
}
static void splashOutBlendExclusion(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i;
#if SPLASH_CMYK
if (cm == splashModeCMYK8) {
SplashColor rgbSrc;
SplashColor rgbDest;
SplashColor rgbBlend;
cmykToRGB(src, rgbSrc);
cmykToRGB(dest, rgbDest);
for (i = 0; i < 3; ++i) {
rgbBlend[i] = rgbDest[i] + rgbSrc[i] - (2 * rgbDest[i] * rgbSrc[i]) / 255;
}
rgbToCMYK(rgbBlend, blend);
} else
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
blend[i] = dest[i] + src[i] - (2 * dest[i] * src[i]) / 255;
}
}
}
static int getLum(int r, int g, int b) {
return (int)(0.3 * r + 0.59 * g + 0.11 * b);
}
static int getSat(int r, int g, int b) {
int rgbMin, rgbMax;
rgbMin = rgbMax = r;
if (g < rgbMin) {
rgbMin = g;
} else if (g > rgbMax) {
rgbMax = g;
}
if (b < rgbMin) {
rgbMin = b;
} else if (b > rgbMax) {
rgbMax = b;
}
return rgbMax - rgbMin;
}
static void clipColor(int rIn, int gIn, int bIn,
Guchar *rOut, Guchar *gOut, Guchar *bOut) {
int lum, rgbMin, rgbMax;
lum = getLum(rIn, gIn, bIn);
rgbMin = rgbMax = rIn;
if (gIn < rgbMin) {
rgbMin = gIn;
} else if (gIn > rgbMax) {
rgbMax = gIn;
}
if (bIn < rgbMin) {
rgbMin = bIn;
} else if (bIn > rgbMax) {
rgbMax = bIn;
}
if (rgbMin < 0) {
*rOut = (Guchar)(lum + ((rIn - lum) * lum) / (lum - rgbMin));
*gOut = (Guchar)(lum + ((gIn - lum) * lum) / (lum - rgbMin));
*bOut = (Guchar)(lum + ((bIn - lum) * lum) / (lum - rgbMin));
} else if (rgbMax > 255) {
*rOut = (Guchar)(lum + ((rIn - lum) * (255 - lum)) / (rgbMax - lum));
*gOut = (Guchar)(lum + ((gIn - lum) * (255 - lum)) / (rgbMax - lum));
*bOut = (Guchar)(lum + ((bIn - lum) * (255 - lum)) / (rgbMax - lum));
} else {
*rOut = rIn;
*gOut = gIn;
*bOut = bIn;
}
}
static void setLum(Guchar rIn, Guchar gIn, Guchar bIn, int lum,
Guchar *rOut, Guchar *gOut, Guchar *bOut) {
int d;
d = lum - getLum(rIn, gIn, bIn);
clipColor(rIn + d, gIn + d, bIn + d, rOut, gOut, bOut);
}
static void setSat(Guchar rIn, Guchar gIn, Guchar bIn, int sat,
Guchar *rOut, Guchar *gOut, Guchar *bOut) {
int rgbMin, rgbMid, rgbMax;
Guchar *minOut, *midOut, *maxOut;
if (rIn < gIn) {
rgbMin = rIn; minOut = rOut;
rgbMid = gIn; midOut = gOut;
} else {
rgbMin = gIn; minOut = gOut;
rgbMid = rIn; midOut = rOut;
}
if (bIn > rgbMid) {
rgbMax = bIn; maxOut = bOut;
} else if (bIn > rgbMin) {
rgbMax = rgbMid; maxOut = midOut;
rgbMid = bIn; midOut = bOut;
} else {
rgbMax = rgbMid; maxOut = midOut;
rgbMid = rgbMin; midOut = minOut;
rgbMin = bIn; minOut = bOut;
}
if (rgbMax > rgbMin) {
*midOut = (Guchar)((rgbMid - rgbMin) * sat) / (rgbMax - rgbMin);
*maxOut = (Guchar)sat;
} else {
*midOut = *maxOut = 0;
}
*minOut = 0;
}
static void splashOutBlendHue(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
Guchar r0, g0, b0;
#ifdef SPLASH_CMYK
Guchar r1, g1, b1;
#endif
switch (cm) {
case splashModeMono1:
case splashModeMono8:
blend[0] = dest[0];
break;
case splashModeXBGR8:
src[3] = 255;
case splashModeRGB8:
case splashModeBGR8:
setSat(src[0], src[1], src[2], getSat(dest[0], dest[1], dest[2]),
&r0, &g0, &b0);
setLum(r0, g0, b0, getLum(dest[0], dest[1], dest[2]),
&blend[0], &blend[1], &blend[2]);
break;
#if SPLASH_CMYK
case splashModeCMYK8:
// NB: inputs have already been converted to additive mode
setSat(src[0], src[1], src[2], getSat(dest[0], dest[1], dest[2]),
&r0, &g0, &b0);
setLum(r0, g0, b0, getLum(dest[0], dest[1], dest[2]),
&r1, &g1, &b1);
blend[0] = r1;
blend[1] = g1;
blend[2] = b1;
blend[3] = dest[3];
break;
#endif
}
}
static void splashOutBlendSaturation(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend,
SplashColorMode cm) {
Guchar r0, g0, b0;
#ifdef SPLASH_CMYK
Guchar r1, g1, b1;
#endif
switch (cm) {
case splashModeMono1:
case splashModeMono8:
blend[0] = dest[0];
break;
case splashModeXBGR8:
src[3] = 255;
case splashModeRGB8:
case splashModeBGR8:
setSat(dest[0], dest[1], dest[2], getSat(src[0], src[1], src[2]),
&r0, &g0, &b0);
setLum(r0, g0, b0, getLum(dest[0], dest[1], dest[2]),
&blend[0], &blend[1], &blend[2]);
break;
#if SPLASH_CMYK
case splashModeCMYK8:
// NB: inputs have already been converted to additive mode
setSat(dest[0], dest[1], dest[2], getSat(src[0], src[1], src[2]),
&r0, &g0, &b0);
setLum(r0, g0, b0, getLum(dest[0], dest[1], dest[2]),
&r1, &g1, &b1);
blend[0] = r1;
blend[1] = g1;
blend[2] = b1;
blend[3] = dest[3];
break;
#endif
}
}
static void splashOutBlendColor(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
#if SPLASH_CMYK
Guchar r, g, b;
#endif
switch (cm) {
case splashModeMono1:
case splashModeMono8:
blend[0] = dest[0];
break;
case splashModeXBGR8:
src[3] = 255;
case splashModeRGB8:
case splashModeBGR8:
setLum(src[0], src[1], src[2], getLum(dest[0], dest[1], dest[2]),
&blend[0], &blend[1], &blend[2]);
break;
#if SPLASH_CMYK
case splashModeCMYK8:
// NB: inputs have already been converted to additive mode
setLum(src[0], src[1], src[2], getLum(dest[0], dest[1], dest[2]),
&r, &g, &b);
blend[0] = r;
blend[1] = g;
blend[2] = b;
blend[3] = dest[3];
break;
#endif
}
}
static void splashOutBlendLuminosity(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend,
SplashColorMode cm) {
#if SPLASH_CMYK
Guchar r, g, b;
#endif
switch (cm) {
case splashModeMono1:
case splashModeMono8:
blend[0] = dest[0];
break;
case splashModeXBGR8:
src[3] = 255;
case splashModeRGB8:
case splashModeBGR8:
setLum(dest[0], dest[1], dest[2], getLum(src[0], src[1], src[2]),
&blend[0], &blend[1], &blend[2]);
break;
#if SPLASH_CMYK
case splashModeCMYK8:
// NB: inputs have already been converted to additive mode
setLum(dest[0], dest[1], dest[2], getLum(src[0], src[1], src[2]),
&r, &g, &b);
blend[0] = r;
blend[1] = g;
blend[2] = b;
blend[3] = src[3];
break;
#endif
}
}
// NB: This must match the GfxBlendMode enum defined in GfxState.h.
static const SplashBlendFunc splashOutBlendFuncs[] = {
NULL,
&splashOutBlendMultiply,
&splashOutBlendScreen,
&splashOutBlendOverlay,
&splashOutBlendDarken,
&splashOutBlendLighten,
&splashOutBlendColorDodge,
&splashOutBlendColorBurn,
&splashOutBlendHardLight,
&splashOutBlendSoftLight,
&splashOutBlendDifference,
&splashOutBlendExclusion,
&splashOutBlendHue,
&splashOutBlendSaturation,
&splashOutBlendColor,
&splashOutBlendLuminosity
};
//------------------------------------------------------------------------
// SplashOutFontFileID
//------------------------------------------------------------------------
class SplashOutFontFileID: public SplashFontFileID {
public:
SplashOutFontFileID(Ref *rA) { r = *rA; }
~SplashOutFontFileID() {}
GBool matches(SplashFontFileID *id) {
return ((SplashOutFontFileID *)id)->r.num == r.num &&
((SplashOutFontFileID *)id)->r.gen == r.gen;
}
private:
Ref r;
};
//------------------------------------------------------------------------
// T3FontCache
//------------------------------------------------------------------------
struct T3FontCacheTag {
Gushort code;
Gushort mru; // valid bit (0x8000) and MRU index
};
class T3FontCache {
public:
T3FontCache(Ref *fontID, double m11A, double m12A,
double m21A, double m22A,
int glyphXA, int glyphYA, int glyphWA, int glyphHA,
GBool aa, GBool validBBoxA);
~T3FontCache();
GBool matches(Ref *idA, double m11A, double m12A,
double m21A, double m22A)
{ return fontID.num == idA->num && fontID.gen == idA->gen &&
m11 == m11A && m12 == m12A && m21 == m21A && m22 == m22A; }
Ref fontID; // PDF font ID
double m11, m12, m21, m22; // transform matrix
int glyphX, glyphY; // pixel offset of glyph bitmaps
int glyphW, glyphH; // size of glyph bitmaps, in pixels
GBool validBBox; // false if the bbox was [0 0 0 0]
int glyphSize; // size of glyph bitmaps, in bytes
int cacheSets; // number of sets in cache
int cacheAssoc; // cache associativity (glyphs per set)
Guchar *cacheData; // glyph pixmap cache
T3FontCacheTag *cacheTags; // cache tags, i.e., char codes
};
T3FontCache::T3FontCache(Ref *fontIDA, double m11A, double m12A,
double m21A, double m22A,
int glyphXA, int glyphYA, int glyphWA, int glyphHA,
GBool validBBoxA, GBool aa) {
int i;
fontID = *fontIDA;
m11 = m11A;
m12 = m12A;
m21 = m21A;
m22 = m22A;
glyphX = glyphXA;
glyphY = glyphYA;
glyphW = glyphWA;
glyphH = glyphHA;
validBBox = validBBoxA;
// sanity check for excessively large glyphs (which most likely
// indicate an incorrect BBox)
i = glyphW * glyphH;
if (i > 100000 || glyphW > INT_MAX / glyphH || glyphW <= 0 || glyphH <= 0) {
glyphW = glyphH = 100;
validBBox = gFalse;
}
if (aa) {
glyphSize = glyphW * glyphH;
} else {
glyphSize = ((glyphW + 7) >> 3) * glyphH;
}
cacheAssoc = type3FontCacheAssoc;
for (cacheSets = type3FontCacheMaxSets;
cacheSets > 1 &&
cacheSets * cacheAssoc * glyphSize > type3FontCacheSize;
cacheSets >>= 1) ;
if (glyphSize < 10485760 / cacheAssoc / cacheSets) {
cacheData = (Guchar *)gmallocn_checkoverflow(cacheSets * cacheAssoc, glyphSize);
} else {
error(errSyntaxWarning, -1, "Not creating cacheData for T3FontCache, it asked for too much memory.\n"
" This could teoretically result in wrong rendering,\n"
" but most probably the document is bogus.\n"
" Please report a bug if you think the rendering may be wrong because of this.");
cacheData = NULL;
}
if (cacheData != NULL)
{
cacheTags = (T3FontCacheTag *)gmallocn(cacheSets * cacheAssoc,
sizeof(T3FontCacheTag));
for (i = 0; i < cacheSets * cacheAssoc; ++i) {
cacheTags[i].mru = i & (cacheAssoc - 1);
}
}
else
{
cacheTags = NULL;
}
}
T3FontCache::~T3FontCache() {
gfree(cacheData);
gfree(cacheTags);
}
struct T3GlyphStack {
Gushort code; // character code
//----- cache info
T3FontCache *cache; // font cache for the current font
T3FontCacheTag *cacheTag; // pointer to cache tag for the glyph
Guchar *cacheData; // pointer to cache data for the glyph
//----- saved state
SplashBitmap *origBitmap;
Splash *origSplash;
double origCTM4, origCTM5;
T3GlyphStack *next; // next object on stack
};
//------------------------------------------------------------------------
// SplashTransparencyGroup
//------------------------------------------------------------------------
struct SplashTransparencyGroup {
int tx, ty; // translation coordinates
SplashBitmap *tBitmap; // bitmap for transparency group
GfxColorSpace *blendingColorSpace;
GBool isolated;
//----- saved state
SplashBitmap *origBitmap;
Splash *origSplash;
SplashTransparencyGroup *next;
};
//------------------------------------------------------------------------
// SplashOutputDev
//------------------------------------------------------------------------
SplashOutputDev::SplashOutputDev(SplashColorMode colorModeA,
int bitmapRowPadA,
GBool reverseVideoA,
SplashColorPtr paperColorA,
GBool bitmapTopDownA,
GBool allowAntialiasA) {
colorMode = colorModeA;
bitmapRowPad = bitmapRowPadA;
bitmapTopDown = bitmapTopDownA;
bitmapUpsideDown = gFalse;
allowAntialias = allowAntialiasA;
vectorAntialias = allowAntialias &&
globalParams->getVectorAntialias() &&
colorMode != splashModeMono1;
enableFreeTypeHinting = gFalse;
enableSlightHinting = gFalse;
setupScreenParams(72.0, 72.0);
reverseVideo = reverseVideoA;
if (paperColorA != NULL) {
splashColorCopy(paperColor, paperColorA);
} else {
splashClearColor(paperColor);
}
skipHorizText = gFalse;
skipRotatedText = gFalse;
keepAlphaChannel = paperColorA == NULL;
doc = NULL;
bitmap = new SplashBitmap(1, 1, bitmapRowPad, colorMode,
colorMode != splashModeMono1, bitmapTopDown);
splash = new Splash(bitmap, vectorAntialias, &screenParams);
splash->setMinLineWidth(globalParams->getMinLineWidth());
splash->clear(paperColor, 0);
fontEngine = NULL;
nT3Fonts = 0;
t3GlyphStack = NULL;
font = NULL;
needFontUpdate = gFalse;
textClipPath = NULL;
transpGroupStack = NULL;
nestCount = 0;
}
void SplashOutputDev::setupScreenParams(double hDPI, double vDPI) {
screenParams.size = globalParams->getScreenSize();
screenParams.dotRadius = globalParams->getScreenDotRadius();
screenParams.gamma = (SplashCoord)globalParams->getScreenGamma();
screenParams.blackThreshold =
(SplashCoord)globalParams->getScreenBlackThreshold();
screenParams.whiteThreshold =
(SplashCoord)globalParams->getScreenWhiteThreshold();
switch (globalParams->getScreenType()) {
case screenDispersed:
screenParams.type = splashScreenDispersed;
if (screenParams.size < 0) {
screenParams.size = 4;
}
break;
case screenClustered:
screenParams.type = splashScreenClustered;
if (screenParams.size < 0) {
screenParams.size = 10;
}
break;
case screenStochasticClustered:
screenParams.type = splashScreenStochasticClustered;
if (screenParams.size < 0) {
screenParams.size = 64;
}
if (screenParams.dotRadius < 0) {
screenParams.dotRadius = 2;
}
break;
case screenUnset:
default:
// use clustered dithering for resolution >= 300 dpi
// (compare to 299.9 to avoid floating point issues)
if (hDPI > 299.9 && vDPI > 299.9) {
screenParams.type = splashScreenStochasticClustered;
if (screenParams.size < 0) {
screenParams.size = 64;
}
if (screenParams.dotRadius < 0) {
screenParams.dotRadius = 2;
}
} else {
screenParams.type = splashScreenDispersed;
if (screenParams.size < 0) {
screenParams.size = 4;
}
}
}
}
SplashOutputDev::~SplashOutputDev() {
int i;
for (i = 0; i < nT3Fonts; ++i) {
delete t3FontCache[i];
}
if (fontEngine) {
delete fontEngine;
}
if (splash) {
delete splash;
}
if (bitmap) {
delete bitmap;
}
}
void SplashOutputDev::startDoc(PDFDoc *docA) {
int i;
doc = docA;
if (fontEngine) {
delete fontEngine;
}
fontEngine = new SplashFontEngine(
#if HAVE_T1LIB_H
globalParams->getEnableT1lib(),
#endif
#if HAVE_FREETYPE_FREETYPE_H || HAVE_FREETYPE_H
globalParams->getEnableFreeType(),
enableFreeTypeHinting,
enableSlightHinting,
#endif
allowAntialias &&
globalParams->getAntialias() &&
colorMode != splashModeMono1);
for (i = 0; i < nT3Fonts; ++i) {
delete t3FontCache[i];
}
nT3Fonts = 0;
}
void SplashOutputDev::startPage(int pageNum, GfxState *state) {
int w, h;
double *ctm;
SplashCoord mat[6];
SplashColor color;
if (state) {
setupScreenParams(state->getHDPI(), state->getVDPI());
w = (int)(state->getPageWidth() + 0.5);
if (w <= 0) {
w = 1;
}
h = (int)(state->getPageHeight() + 0.5);
if (h <= 0) {
h = 1;
}
} else {
w = h = 1;
}
if (splash) {
delete splash;
splash = NULL;
}
if (!bitmap || w != bitmap->getWidth() || h != bitmap->getHeight()) {
if (bitmap) {
delete bitmap;
bitmap = NULL;
}
bitmap = new SplashBitmap(w, h, bitmapRowPad, colorMode,
colorMode != splashModeMono1, bitmapTopDown);
}
splash = new Splash(bitmap, vectorAntialias, &screenParams);
splash->setMinLineWidth(globalParams->getMinLineWidth());
if (state) {
ctm = state->getCTM();
mat[0] = (SplashCoord)ctm[0];
mat[1] = (SplashCoord)ctm[1];
mat[2] = (SplashCoord)ctm[2];
mat[3] = (SplashCoord)ctm[3];
mat[4] = (SplashCoord)ctm[4];
mat[5] = (SplashCoord)ctm[5];
splash->setMatrix(mat);
}
switch (colorMode) {
case splashModeMono1:
case splashModeMono8:
color[0] = 0;
break;
case splashModeXBGR8:
color[3] = 255;
case splashModeRGB8:
case splashModeBGR8:
color[0] = color[1] = color[2] = 0;
break;
#if SPLASH_CMYK
case splashModeCMYK8:
color[0] = color[1] = color[2] = color[3] = 0;
break;
#endif
}
splash->setStrokePattern(new SplashSolidColor(color));
splash->setFillPattern(new SplashSolidColor(color));
splash->setLineCap(splashLineCapButt);
splash->setLineJoin(splashLineJoinMiter);
splash->setLineDash(NULL, 0, 0);
splash->setMiterLimit(10);
splash->setFlatness(1);
// the SA parameter supposedly defaults to false, but Acrobat
// apparently hardwires it to true
splash->setStrokeAdjust(globalParams->getStrokeAdjust());
splash->clear(paperColor, 0);
}
void SplashOutputDev::endPage() {
if (colorMode != splashModeMono1 && !keepAlphaChannel) {
splash->compositeBackground(paperColor);
}
}
void SplashOutputDev::saveState(GfxState *state) {
splash->saveState();
}
void SplashOutputDev::restoreState(GfxState *state) {
splash->restoreState();
needFontUpdate = gTrue;
}
void SplashOutputDev::updateAll(GfxState *state) {
updateLineDash(state);
updateLineJoin(state);
updateLineCap(state);
updateLineWidth(state);
updateFlatness(state);
updateMiterLimit(state);
updateStrokeAdjust(state);
updateFillColor(state);
updateStrokeColor(state);
needFontUpdate = gTrue;
}
void SplashOutputDev::updateCTM(GfxState *state, double m11, double m12,
double m21, double m22,
double m31, double m32) {
double *ctm;
SplashCoord mat[6];
ctm = state->getCTM();
mat[0] = (SplashCoord)ctm[0];
mat[1] = (SplashCoord)ctm[1];
mat[2] = (SplashCoord)ctm[2];
mat[3] = (SplashCoord)ctm[3];
mat[4] = (SplashCoord)ctm[4];
mat[5] = (SplashCoord)ctm[5];
splash->setMatrix(mat);
}
void SplashOutputDev::updateLineDash(GfxState *state) {
double *dashPattern;
int dashLength;
double dashStart;
SplashCoord dash[20];
int i;
state->getLineDash(&dashPattern, &dashLength, &dashStart);
if (dashLength > 20) {
dashLength = 20;
}
for (i = 0; i < dashLength; ++i) {
dash[i] = (SplashCoord)dashPattern[i];
if (dash[i] < 0) {
dash[i] = 0;
}
}
splash->setLineDash(dash, dashLength, (SplashCoord)dashStart);
}
void SplashOutputDev::updateFlatness(GfxState *state) {
#if 0 // Acrobat ignores the flatness setting, and always renders curves
// with a fairly small flatness value
splash->setFlatness(state->getFlatness());
#endif
}
void SplashOutputDev::updateLineJoin(GfxState *state) {
splash->setLineJoin(state->getLineJoin());
}
void SplashOutputDev::updateLineCap(GfxState *state) {
splash->setLineCap(state->getLineCap());
}
void SplashOutputDev::updateMiterLimit(GfxState *state) {
splash->setMiterLimit(state->getMiterLimit());
}
void SplashOutputDev::updateLineWidth(GfxState *state) {
splash->setLineWidth(state->getLineWidth());
}
void SplashOutputDev::updateStrokeAdjust(GfxState * /*state*/) {
#if 0 // the SA parameter supposedly defaults to false, but Acrobat
// apparently hardwires it to true
splash->setStrokeAdjust(state->getStrokeAdjust());
#endif
}
void SplashOutputDev::updateFillColor(GfxState *state) {
GfxGray gray;
GfxRGB rgb;
#if SPLASH_CMYK
GfxCMYK cmyk;
#endif
switch (colorMode) {
case splashModeMono1:
case splashModeMono8:
state->getFillGray(&gray);
splash->setFillPattern(getColor(gray));
break;
case splashModeXBGR8:
case splashModeRGB8:
case splashModeBGR8:
state->getFillRGB(&rgb);
splash->setFillPattern(getColor(&rgb));
break;
#if SPLASH_CMYK
case splashModeCMYK8:
state->getFillCMYK(&cmyk);
splash->setFillPattern(getColor(&cmyk));
break;
#endif
}
}
void SplashOutputDev::updateStrokeColor(GfxState *state) {
GfxGray gray;
GfxRGB rgb;
#if SPLASH_CMYK
GfxCMYK cmyk;
#endif
switch (colorMode) {
case splashModeMono1:
case splashModeMono8:
state->getStrokeGray(&gray);
splash->setStrokePattern(getColor(gray));
break;
case splashModeXBGR8:
case splashModeRGB8:
case splashModeBGR8:
state->getStrokeRGB(&rgb);
splash->setStrokePattern(getColor(&rgb));
break;
#if SPLASH_CMYK
case splashModeCMYK8:
state->getStrokeCMYK(&cmyk);
splash->setStrokePattern(getColor(&cmyk));
break;
#endif
}
}
SplashPattern *SplashOutputDev::getColor(GfxGray gray) {
SplashColor color;
if (reverseVideo) {
gray = gfxColorComp1 - gray;
}
color[0] = colToByte(gray);
return new SplashSolidColor(color);
}
SplashPattern *SplashOutputDev::getColor(GfxRGB *rgb) {
GfxColorComp r, g, b;
SplashColor color;
if (reverseVideo) {
r = gfxColorComp1 - rgb->r;
g = gfxColorComp1 - rgb->g;
b = gfxColorComp1 - rgb->b;
} else {
r = rgb->r;
g = rgb->g;
b = rgb->b;
}
color[0] = colToByte(r);
color[1] = colToByte(g);
color[2] = colToByte(b);
if (colorMode == splashModeXBGR8) color[3] = 255;
return new SplashSolidColor(color);
}
#if SPLASH_CMYK
SplashPattern *SplashOutputDev::getColor(GfxCMYK *cmyk) {
SplashColor color;
color[0] = colToByte(cmyk->c);
color[1] = colToByte(cmyk->m);
color[2] = colToByte(cmyk->y);
color[3] = colToByte(cmyk->k);
return new SplashSolidColor(color);
}
#endif
void SplashOutputDev::setOverprintMask(GfxColorSpace *colorSpace,
GBool overprintFlag,
int overprintMode,
GfxColor *singleColor,
GBool grayIndexed) {
#if SPLASH_CMYK
Guint mask;
GfxCMYK cmyk;
GBool additive = gFalse;
int i;
if (colorSpace->getMode() == csIndexed) {
setOverprintMask(((GfxIndexedColorSpace *)colorSpace)->getBase(),
overprintFlag,
overprintMode,
singleColor,
grayIndexed);
return;
}
if (overprintFlag && globalParams->getOverprintPreview()) {
mask = colorSpace->getOverprintMask();
if (singleColor && overprintMode &&
colorSpace->getMode() == csDeviceCMYK) {
colorSpace->getCMYK(singleColor, &cmyk);
if (cmyk.c == 0) {
mask &= ~1;
}
if (cmyk.m == 0) {
mask &= ~2;
}
if (cmyk.y == 0) {
mask &= ~4;
}
if (cmyk.k == 0) {
mask &= ~8;
}
}
if (grayIndexed) {
mask &= ~7;
} else if (colorSpace->getMode() == csSeparation) {
GfxSeparationColorSpace *deviceSep = (GfxSeparationColorSpace *)colorSpace;
additive = deviceSep->getName()->cmp("All") != 0 && mask == 0x0f && !deviceSep->isNonMarking();
} else if (colorSpace->getMode() == csDeviceN) {
GfxDeviceNColorSpace *deviceNCS = (GfxDeviceNColorSpace *)colorSpace;
additive = mask == 0x0f && !deviceNCS->isNonMarking();
for (i = 0; i < deviceNCS->getNComps() && additive; i++) {
if (deviceNCS->getColorantName(i)->cmp("Cyan") == 0) {
additive = gFalse;
} else if (deviceNCS->getColorantName(i)->cmp("Magenta") == 0) {
additive = gFalse;
} else if (deviceNCS->getColorantName(i)->cmp("Yellow") == 0) {
additive = gFalse;
} else if (deviceNCS->getColorantName(i)->cmp("Black") == 0) {
additive = gFalse;
}
}
}
} else {
mask = 0xffffffff;
}
splash->setOverprintMask(mask, additive);
#endif
}
void SplashOutputDev::updateBlendMode(GfxState *state) {
splash->setBlendFunc(splashOutBlendFuncs[state->getBlendMode()]);
}
void SplashOutputDev::updateFillOpacity(GfxState *state) {
splash->setFillAlpha((SplashCoord)state->getFillOpacity());
}
void SplashOutputDev::updateStrokeOpacity(GfxState *state) {
splash->setStrokeAlpha((SplashCoord)state->getStrokeOpacity());
}
void SplashOutputDev::updateFillOverprint(GfxState *state) {
splash->setFillOverprint(state->getFillOverprint());
}
void SplashOutputDev::updateStrokeOverprint(GfxState *state) {
splash->setStrokeOverprint(state->getStrokeOverprint());
}
void SplashOutputDev::updateOverprintMode(GfxState *state) {
splash->setOverprintMode(state->getOverprintMode());
}
void SplashOutputDev::updateTransfer(GfxState *state) {
Function **transfer;
Guchar red[256], green[256], blue[256], gray[256];
double x, y;
int i;
transfer = state->getTransfer();
if (transfer[0] &&
transfer[0]->getInputSize() == 1 &&
transfer[0]->getOutputSize() == 1) {
if (transfer[1] &&
transfer[1]->getInputSize() == 1 &&
transfer[1]->getOutputSize() == 1 &&
transfer[2] &&
transfer[2]->getInputSize() == 1 &&
transfer[2]->getOutputSize() == 1 &&
transfer[3] &&
transfer[3]->getInputSize() == 1 &&
transfer[3]->getOutputSize() == 1) {
for (i = 0; i < 256; ++i) {
x = i / 255.0;
transfer[0]->transform(&x, &y);
red[i] = (Guchar)(y * 255.0 + 0.5);
transfer[1]->transform(&x, &y);
green[i] = (Guchar)(y * 255.0 + 0.5);
transfer[2]->transform(&x, &y);
blue[i] = (Guchar)(y * 255.0 + 0.5);
transfer[3]->transform(&x, &y);
gray[i] = (Guchar)(y * 255.0 + 0.5);
}
} else {
for (i = 0; i < 256; ++i) {
x = i / 255.0;
transfer[0]->transform(&x, &y);
red[i] = green[i] = blue[i] = gray[i] = (Guchar)(y * 255.0 + 0.5);
}
}
} else {
for (i = 0; i < 256; ++i) {
red[i] = green[i] = blue[i] = gray[i] = (Guchar)i;
}
}
splash->setTransfer(red, green, blue, gray);
}
void SplashOutputDev::updateFont(GfxState * /*state*/) {
needFontUpdate = gTrue;
}
void SplashOutputDev::doUpdateFont(GfxState *state) {
GfxFont *gfxFont;
GfxFontLoc *fontLoc;
GfxFontType fontType;
SplashOutFontFileID *id;
SplashFontFile *fontFile;
SplashFontSrc *fontsrc = NULL;
FoFiTrueType *ff;
Object refObj, strObj;
GooString *fileName;
char *tmpBuf;
int tmpBufLen;
int *codeToGID;
double *textMat;
double m11, m12, m21, m22, fontSize;
int faceIndex = 0;
SplashCoord mat[4];
int n, i;
GBool recreateFont = gFalse;
GBool doAdjustFontMatrix = gFalse;
needFontUpdate = gFalse;
font = NULL;
fileName = NULL;
tmpBuf = NULL;
fontLoc = NULL;
if (!(gfxFont = state->getFont())) {
goto err1;
}
fontType = gfxFont->getType();
if (fontType == fontType3) {
goto err1;
}
// sanity-check the font size - skip anything larger than 10 inches
// (this avoids problems allocating memory for the font cache)
if (state->getTransformedFontSize()
> 10 * (state->getHDPI() + state->getVDPI())) {
goto err1;
}
// check the font file cache
id = new SplashOutFontFileID(gfxFont->getID());
if ((fontFile = fontEngine->getFontFile(id))) {
delete id;
} else {
if (!(fontLoc = gfxFont->locateFont(doc->getXRef(), gFalse))) {
error(errSyntaxError, -1, "Couldn't find a font for '{0:s}'",
gfxFont->getName() ? gfxFont->getName()->getCString()
: "(unnamed)");
goto err2;
}
// embedded font
if (fontLoc->locType == gfxFontLocEmbedded) {
// if there is an embedded font, read it to memory
tmpBuf = gfxFont->readEmbFontFile(doc->getXRef(), &tmpBufLen);
if (! tmpBuf)
goto err2;
// external font
} else { // gfxFontLocExternal
fileName = fontLoc->path;
fontType = fontLoc->fontType;
doAdjustFontMatrix = gTrue;
}
fontsrc = new SplashFontSrc;
if (fileName)
fontsrc->setFile(fileName, gFalse);
else
fontsrc->setBuf(tmpBuf, tmpBufLen, gTrue);
// load the font file
switch (fontType) {
case fontType1:
if (!(fontFile = fontEngine->loadType1Font(
id,
fontsrc,
(const char **)((Gfx8BitFont *)gfxFont)->getEncoding()))) {
error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
gfxFont->getName() ? gfxFont->getName()->getCString()
: "(unnamed)");
goto err2;
}
break;
case fontType1C:
if (!(fontFile = fontEngine->loadType1CFont(
id,
fontsrc,
(const char **)((Gfx8BitFont *)gfxFont)->getEncoding()))) {
error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
gfxFont->getName() ? gfxFont->getName()->getCString()
: "(unnamed)");
goto err2;
}
break;
case fontType1COT:
if (!(fontFile = fontEngine->loadOpenTypeT1CFont(
id,
fontsrc,
(const char **)((Gfx8BitFont *)gfxFont)->getEncoding()))) {
error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
gfxFont->getName() ? gfxFont->getName()->getCString()
: "(unnamed)");
goto err2;
}
break;
case fontTrueType:
case fontTrueTypeOT:
if (fileName)
ff = FoFiTrueType::load(fileName->getCString());
else
ff = FoFiTrueType::make(tmpBuf, tmpBufLen);
if (ff) {
codeToGID = ((Gfx8BitFont *)gfxFont)->getCodeToGIDMap(ff);
n = 256;
delete ff;
// if we're substituting for a non-TrueType font, we need to mark
// all notdef codes as "do not draw" (rather than drawing TrueType
// notdef glyphs)
if (gfxFont->getType() != fontTrueType &&
gfxFont->getType() != fontTrueTypeOT) {
for (i = 0; i < 256; ++i) {
if (codeToGID[i] == 0) {
codeToGID[i] = -1;
}
}
}
} else {
codeToGID = NULL;
n = 0;
}
if (!(fontFile = fontEngine->loadTrueTypeFont(
id,
fontsrc,
codeToGID, n))) {
error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
gfxFont->getName() ? gfxFont->getName()->getCString()
: "(unnamed)");
goto err2;
}
break;
case fontCIDType0:
case fontCIDType0C:
if (!(fontFile = fontEngine->loadCIDFont(
id,
fontsrc))) {
error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
gfxFont->getName() ? gfxFont->getName()->getCString()
: "(unnamed)");
goto err2;
}
break;
case fontCIDType0COT:
if (((GfxCIDFont *)gfxFont)->getCIDToGID()) {
n = ((GfxCIDFont *)gfxFont)->getCIDToGIDLen();
codeToGID = (int *)gmallocn(n, sizeof(int));
memcpy(codeToGID, ((GfxCIDFont *)gfxFont)->getCIDToGID(),
n * sizeof(int));
} else {
codeToGID = NULL;
n = 0;
}
if (!(fontFile = fontEngine->loadOpenTypeCFFFont(
id,
fontsrc,
codeToGID, n))) {
error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
gfxFont->getName() ? gfxFont->getName()->getCString()
: "(unnamed)");
goto err2;
}
break;
case fontCIDType2:
case fontCIDType2OT:
codeToGID = NULL;
n = 0;
if (((GfxCIDFont *)gfxFont)->getCIDToGID()) {
n = ((GfxCIDFont *)gfxFont)->getCIDToGIDLen();
if (n) {
codeToGID = (int *)gmallocn(n, sizeof(int));
memcpy(codeToGID, ((GfxCIDFont *)gfxFont)->getCIDToGID(),
n * sizeof(int));
}
} else {
if (fileName)
ff = FoFiTrueType::load(fileName->getCString());
else
ff = FoFiTrueType::make(tmpBuf, tmpBufLen);
if (! ff)
{
error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
gfxFont->getName() ? gfxFont->getName()->getCString()
: "(unnamed)");
goto err2;
}
codeToGID = ((GfxCIDFont *)gfxFont)->getCodeToGIDMap(ff, &n);
delete ff;
}
if (!(fontFile = fontEngine->loadTrueTypeFont(
id,
fontsrc,
codeToGID, n, faceIndex))) {
error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
gfxFont->getName() ? gfxFont->getName()->getCString()
: "(unnamed)");
goto err2;
}
break;
default:
// this shouldn't happen
goto err2;
}
fontFile->doAdjustMatrix = doAdjustFontMatrix;
}
// get the font matrix
textMat = state->getTextMat();
fontSize = state->getFontSize();
m11 = textMat[0] * fontSize * state->getHorizScaling();
m12 = textMat[1] * fontSize * state->getHorizScaling();
m21 = textMat[2] * fontSize;
m22 = textMat[3] * fontSize;
// create the scaled font
mat[0] = m11; mat[1] = m12;
mat[2] = m21; mat[3] = m22;
font = fontEngine->getFont(fontFile, mat, splash->getMatrix());
// for substituted fonts: adjust the font matrix -- compare the
// width of 'm' in the original font and the substituted font
if (fontFile->doAdjustMatrix && !gfxFont->isCIDFont()) {
double w1, w2;
CharCode code;
char *name;
for (code = 0; code < 256; ++code) {
if ((name = ((Gfx8BitFont *)gfxFont)->getCharName(code)) &&
name[0] == 'm' && name[1] == '\0') {
break;
}
}
if (code < 256) {
w1 = ((Gfx8BitFont *)gfxFont)->getWidth(code);
w2 = font->getGlyphAdvance(code);
if (!gfxFont->isSymbolic() && w2 > 0) {
// if real font is substantially narrower than substituted
// font, reduce the font size accordingly
if (w1 > 0.01 && w1 < 0.9 * w2) {
w1 /= w2;
m11 *= w1;
m21 *= w1;
recreateFont = gTrue;
}
}
}
}
if (recreateFont)
{
mat[0] = m11; mat[1] = m12;
mat[2] = m21; mat[3] = m22;
font = fontEngine->getFont(fontFile, mat, splash->getMatrix());
}
delete fontLoc;
if (fontsrc && !fontsrc->isFile)
fontsrc->unref();
return;
err2:
delete id;
delete fontLoc;
err1:
if (fontsrc && !fontsrc->isFile)
fontsrc->unref();
return;
}
void SplashOutputDev::stroke(GfxState *state) {
SplashPath *path;
if (state->getStrokeColorSpace()->isNonMarking()) {
return;
}
setOverprintMask(state->getStrokeColorSpace(), state->getStrokeOverprint(),
state->getOverprintMode(), state->getStrokeColor());
path = convertPath(state, state->getPath(), gFalse);
splash->stroke(path);
delete path;
}
void SplashOutputDev::fill(GfxState *state) {
SplashPath *path;
if (state->getFillColorSpace()->isNonMarking()) {
return;
}
setOverprintMask(state->getFillColorSpace(), state->getFillOverprint(),
state->getOverprintMode(), state->getFillColor());
path = convertPath(state, state->getPath(), gTrue);
splash->fill(path, gFalse);
delete path;
}
void SplashOutputDev::eoFill(GfxState *state) {
SplashPath *path;
if (state->getFillColorSpace()->isNonMarking()) {
return;
}
setOverprintMask(state->getFillColorSpace(), state->getFillOverprint(),
state->getOverprintMode(), state->getFillColor());
path = convertPath(state, state->getPath(), gTrue);
splash->fill(path, gTrue);
delete path;
}
void SplashOutputDev::clip(GfxState *state) {
SplashPath *path;
path = convertPath(state, state->getPath(), gTrue);
splash->clipToPath(path, gFalse);
delete path;
}
void SplashOutputDev::eoClip(GfxState *state) {
SplashPath *path;
path = convertPath(state, state->getPath(), gTrue);
splash->clipToPath(path, gTrue);
delete path;
}
void SplashOutputDev::clipToStrokePath(GfxState *state) {
SplashPath *path, *path2;
path = convertPath(state, state->getPath(), gFalse);
path2 = splash->makeStrokePath(path, state->getLineWidth());
delete path;
splash->clipToPath(path2, gFalse);
delete path2;
}
SplashPath *SplashOutputDev::convertPath(GfxState *state, GfxPath *path,
GBool dropEmptySubpaths) {
SplashPath *sPath;
GfxSubpath *subpath;
int n, i, j;
n = dropEmptySubpaths ? 1 : 0;
sPath = new SplashPath();
for (i = 0; i < path->getNumSubpaths(); ++i) {
subpath = path->getSubpath(i);
if (subpath->getNumPoints() > n) {
sPath->moveTo((SplashCoord)subpath->getX(0),
(SplashCoord)subpath->getY(0));
j = 1;
while (j < subpath->getNumPoints()) {
if (subpath->getCurve(j)) {
sPath->curveTo((SplashCoord)subpath->getX(j),
(SplashCoord)subpath->getY(j),
(SplashCoord)subpath->getX(j+1),
(SplashCoord)subpath->getY(j+1),
(SplashCoord)subpath->getX(j+2),
(SplashCoord)subpath->getY(j+2));
j += 3;
} else {
sPath->lineTo((SplashCoord)subpath->getX(j),
(SplashCoord)subpath->getY(j));
++j;
}
}
if (subpath->isClosed()) {
sPath->close();
}
}
}
return sPath;
}
void SplashOutputDev::drawChar(GfxState *state, double x, double y,
double dx, double dy,
double originX, double originY,
CharCode code, int nBytes,
Unicode *u, int uLen) {
SplashPath *path;
int render;
GBool doFill, doStroke, doClip, strokeAdjust;
double m[4];
GBool horiz;
if (skipHorizText || skipRotatedText) {
state->getFontTransMat(&m[0], &m[1], &m[2], &m[3]);
horiz = m[0] > 0 && fabs(m[1]) < 0.001 &&
fabs(m[2]) < 0.001 && m[3] < 0;
if ((skipHorizText && horiz) || (skipRotatedText && !horiz)) {
return;
}
}
// check for invisible text -- this is used by Acrobat Capture
render = state->getRender();
if (render == 3) {
return;
}
if (needFontUpdate) {
doUpdateFont(state);
}
if (!font) {
return;
}
x -= originX;
y -= originY;
doFill = !(render & 1) && !state->getFillColorSpace()->isNonMarking();
doStroke = ((render & 3) == 1 || (render & 3) == 2) &&
!state->getStrokeColorSpace()->isNonMarking();
doClip = render & 4;
path = NULL;
if (doStroke || doClip) {
if ((path = font->getGlyphPath(code))) {
path->offset((SplashCoord)x, (SplashCoord)y);
}
}
// don't use stroke adjustment when stroking text -- the results
// tend to be ugly (because characters with horizontal upper or
// lower edges get misaligned relative to the other characters)
strokeAdjust = gFalse; // make gcc happy
if (doStroke) {
strokeAdjust = splash->getStrokeAdjust();
splash->setStrokeAdjust(gFalse);
}
// fill and stroke
if (doFill && doStroke) {
if (path) {
setOverprintMask(state->getFillColorSpace(), state->getFillOverprint(),
state->getOverprintMode(), state->getFillColor());
splash->fill(path, gFalse);
setOverprintMask(state->getStrokeColorSpace(),
state->getStrokeOverprint(),
state->getOverprintMode(),
state->getStrokeColor());
splash->stroke(path);
}
// fill
} else if (doFill) {
setOverprintMask(state->getFillColorSpace(), state->getFillOverprint(),
state->getOverprintMode(), state->getFillColor());
splash->fillChar((SplashCoord)x, (SplashCoord)y, code, font);
// stroke
} else if (doStroke) {
if (path) {
setOverprintMask(state->getStrokeColorSpace(),
state->getStrokeOverprint(),
state->getOverprintMode(),
state->getStrokeColor());
splash->stroke(path);
}
}
// clip
if (doClip) {
if (path) {
if (textClipPath) {
textClipPath->append(path);
} else {
textClipPath = path;
path = NULL;
}
}
}
if (doStroke) {
splash->setStrokeAdjust(strokeAdjust);
}
if (path) {
delete path;
}
}
GBool SplashOutputDev::beginType3Char(GfxState *state, double x, double y,
double dx, double dy,
CharCode code, Unicode *u, int uLen) {
GfxFont *gfxFont;
Ref *fontID;
double *ctm, *bbox;
T3FontCache *t3Font;
T3GlyphStack *t3gs;
GBool validBBox;
double m[4];
GBool horiz;
double x1, y1, xMin, yMin, xMax, yMax, xt, yt;
int i, j;
if (skipHorizText || skipRotatedText) {
state->getFontTransMat(&m[0], &m[1], &m[2], &m[3]);
horiz = m[0] > 0 && fabs(m[1]) < 0.001 &&
fabs(m[2]) < 0.001 && m[3] < 0;
if ((skipHorizText && horiz) || (skipRotatedText && !horiz)) {
return gTrue;
}
}
if (!(gfxFont = state->getFont())) {
return gFalse;
}
fontID = gfxFont->getID();
ctm = state->getCTM();
state->transform(0, 0, &xt, &yt);
// is it the first (MRU) font in the cache?
if (!(nT3Fonts > 0 &&
t3FontCache[0]->matches(fontID, ctm[0], ctm[1], ctm[2], ctm[3]))) {
// is the font elsewhere in the cache?
for (i = 1; i < nT3Fonts; ++i) {
if (t3FontCache[i]->matches(fontID, ctm[0], ctm[1], ctm[2], ctm[3])) {
t3Font = t3FontCache[i];
for (j = i; j > 0; --j) {
t3FontCache[j] = t3FontCache[j - 1];
}
t3FontCache[0] = t3Font;
break;
}
}
if (i >= nT3Fonts) {
// create new entry in the font cache
if (nT3Fonts == splashOutT3FontCacheSize) {
delete t3FontCache[nT3Fonts - 1];
--nT3Fonts;
}
for (j = nT3Fonts; j > 0; --j) {
t3FontCache[j] = t3FontCache[j - 1];
}
++nT3Fonts;
bbox = gfxFont->getFontBBox();
if (bbox[0] == 0 && bbox[1] == 0 && bbox[2] == 0 && bbox[3] == 0) {
// unspecified bounding box -- just take a guess
xMin = xt - 5;
xMax = xMin + 30;
yMax = yt + 15;
yMin = yMax - 45;
validBBox = gFalse;
} else {
state->transform(bbox[0], bbox[1], &x1, &y1);
xMin = xMax = x1;
yMin = yMax = y1;
state->transform(bbox[0], bbox[3], &x1, &y1);
if (x1 < xMin) {
xMin = x1;
} else if (x1 > xMax) {
xMax = x1;
}
if (y1 < yMin) {
yMin = y1;
} else if (y1 > yMax) {
yMax = y1;
}
state->transform(bbox[2], bbox[1], &x1, &y1);
if (x1 < xMin) {
xMin = x1;
} else if (x1 > xMax) {
xMax = x1;
}
if (y1 < yMin) {
yMin = y1;
} else if (y1 > yMax) {
yMax = y1;
}
state->transform(bbox[2], bbox[3], &x1, &y1);
if (x1 < xMin) {
xMin = x1;
} else if (x1 > xMax) {
xMax = x1;
}
if (y1 < yMin) {
yMin = y1;
} else if (y1 > yMax) {
yMax = y1;
}
validBBox = gTrue;
}
t3FontCache[0] = new T3FontCache(fontID, ctm[0], ctm[1], ctm[2], ctm[3],
(int)floor(xMin - xt) - 2,
(int)floor(yMin - yt) - 2,
(int)ceil(xMax) - (int)floor(xMin) + 4,
(int)ceil(yMax) - (int)floor(yMin) + 4,
validBBox,
colorMode != splashModeMono1);
}
}
t3Font = t3FontCache[0];
// is the glyph in the cache?
i = (code & (t3Font->cacheSets - 1)) * t3Font->cacheAssoc;
for (j = 0; j < t3Font->cacheAssoc; ++j) {
if (t3Font->cacheTags != NULL) {
if ((t3Font->cacheTags[i+j].mru & 0x8000) &&
t3Font->cacheTags[i+j].code == code) {
drawType3Glyph(state, t3Font, &t3Font->cacheTags[i+j],
t3Font->cacheData + (i+j) * t3Font->glyphSize);
return gTrue;
}
}
}
// push a new Type 3 glyph record
t3gs = new T3GlyphStack();
t3gs->next = t3GlyphStack;
t3GlyphStack = t3gs;
t3GlyphStack->code = code;
t3GlyphStack->cache = t3Font;
t3GlyphStack->cacheTag = NULL;
t3GlyphStack->cacheData = NULL;
haveT3Dx = gFalse;
return gFalse;
}
void SplashOutputDev::endType3Char(GfxState *state) {
T3GlyphStack *t3gs;
double *ctm;
if (t3GlyphStack->cacheTag) {
--nestCount;
memcpy(t3GlyphStack->cacheData, bitmap->getDataPtr(),
t3GlyphStack->cache->glyphSize);
delete bitmap;
delete splash;
bitmap = t3GlyphStack->origBitmap;
splash = t3GlyphStack->origSplash;
ctm = state->getCTM();
state->setCTM(ctm[0], ctm[1], ctm[2], ctm[3],
t3GlyphStack->origCTM4, t3GlyphStack->origCTM5);
updateCTM(state, 0, 0, 0, 0, 0, 0);
drawType3Glyph(state, t3GlyphStack->cache,
t3GlyphStack->cacheTag, t3GlyphStack->cacheData);
}
t3gs = t3GlyphStack;
t3GlyphStack = t3gs->next;
delete t3gs;
}
void SplashOutputDev::type3D0(GfxState *state, double wx, double wy) {
haveT3Dx = gTrue;
}
void SplashOutputDev::type3D1(GfxState *state, double wx, double wy,
double llx, double lly, double urx, double ury) {
double *ctm;
T3FontCache *t3Font;
SplashColor color;
double xt, yt, xMin, xMax, yMin, yMax, x1, y1;
int i, j;
// ignore multiple d0/d1 operators
if (haveT3Dx) {
return;
}
haveT3Dx = gTrue;
if (unlikely(t3GlyphStack == NULL)) {
error(errSyntaxWarning, -1, "t3GlyphStack was null in SplashOutputDev::type3D1");
return;
}
if (unlikely(t3GlyphStack->origBitmap != NULL)) {
error(errSyntaxWarning, -1, "t3GlyphStack origBitmap was not null in SplashOutputDev::type3D1");
return;
}
if (unlikely(t3GlyphStack->origSplash != NULL)) {
error(errSyntaxWarning, -1, "t3GlyphStack origSplash was not null in SplashOutputDev::type3D1");
return;
}
t3Font = t3GlyphStack->cache;
// check for a valid bbox
state->transform(0, 0, &xt, &yt);
state->transform(llx, lly, &x1, &y1);
xMin = xMax = x1;
yMin = yMax = y1;
state->transform(llx, ury, &x1, &y1);
if (x1 < xMin) {
xMin = x1;
} else if (x1 > xMax) {
xMax = x1;
}
if (y1 < yMin) {
yMin = y1;
} else if (y1 > yMax) {
yMax = y1;
}
state->transform(urx, lly, &x1, &y1);
if (x1 < xMin) {
xMin = x1;
} else if (x1 > xMax) {
xMax = x1;
}
if (y1 < yMin) {
yMin = y1;
} else if (y1 > yMax) {
yMax = y1;
}
state->transform(urx, ury, &x1, &y1);
if (x1 < xMin) {
xMin = x1;
} else if (x1 > xMax) {
xMax = x1;
}
if (y1 < yMin) {
yMin = y1;
} else if (y1 > yMax) {
yMax = y1;
}
if (xMin - xt < t3Font->glyphX ||
yMin - yt < t3Font->glyphY ||
xMax - xt > t3Font->glyphX + t3Font->glyphW ||
yMax - yt > t3Font->glyphY + t3Font->glyphH) {
if (t3Font->validBBox) {
error(errSyntaxWarning, -1, "Bad bounding box in Type 3 glyph");
}
return;
}
if (t3Font->cacheTags == NULL)
return;
// allocate a cache entry
i = (t3GlyphStack->code & (t3Font->cacheSets - 1)) * t3Font->cacheAssoc;
for (j = 0; j < t3Font->cacheAssoc; ++j) {
if ((t3Font->cacheTags[i+j].mru & 0x7fff) == t3Font->cacheAssoc - 1) {
t3Font->cacheTags[i+j].mru = 0x8000;
t3Font->cacheTags[i+j].code = t3GlyphStack->code;
t3GlyphStack->cacheTag = &t3Font->cacheTags[i+j];
t3GlyphStack->cacheData = t3Font->cacheData + (i+j) * t3Font->glyphSize;
} else {
++t3Font->cacheTags[i+j].mru;
}
}
// save state
t3GlyphStack->origBitmap = bitmap;
t3GlyphStack->origSplash = splash;
ctm = state->getCTM();
t3GlyphStack->origCTM4 = ctm[4];
t3GlyphStack->origCTM5 = ctm[5];
// create the temporary bitmap
if (colorMode == splashModeMono1) {
bitmap = new SplashBitmap(t3Font->glyphW, t3Font->glyphH, 1,
splashModeMono1, gFalse);
splash = new Splash(bitmap, gFalse,
t3GlyphStack->origSplash->getScreen());
color[0] = 0;
splash->clear(color);
color[0] = 0xff;
} else {
bitmap = new SplashBitmap(t3Font->glyphW, t3Font->glyphH, 1,
splashModeMono8, gFalse);
splash = new Splash(bitmap, vectorAntialias,
t3GlyphStack->origSplash->getScreen());
color[0] = 0x00;
splash->clear(color);
color[0] = 0xff;
}
splash->setMinLineWidth(globalParams->getMinLineWidth());
splash->setFillPattern(new SplashSolidColor(color));
splash->setStrokePattern(new SplashSolidColor(color));
</