/src/xpdf-4.04/splash/SplashMath.h

Source (jump to first uncovered line)
//========================================================================
//
// SplashMath.h
//
// Copyright 2003-2013 Glyph & Cog, LLC
//
//========================================================================

#ifndef SPLASHMATH_H
#define SPLASHMATH_H

#include <aconf.h>

#if USE_FIXEDPONT
#  include "FixedPoint.h"
#else
#  include <math.h>
#  if (defined(__GNUC__) && defined(__SSE2__)) || \
      (defined(_WIN32) && (_M_IX86_FP == 2 || defined(_M_X64)))
#    include <emmintrin.h>
#  endif
#endif
#include "SplashTypes.h"

static inline SplashCoord splashAbs(SplashCoord x) {
#if USE_FIXEDPOINT
  return FixedPoint::abs(x);
#else
  return fabs(x);
#endif
}

// floor() and (int)() are implemented separately, which results
// in changing the FPCW multiple times - so we optimize it with
// some inline assembly or SSE intrinsics.
static inline int splashFloor(SplashCoord x) {
#if USE_FIXEDPOINT

  //--- fixed point

  return FixedPoint::floor(x);

#elif (defined(__GNUC__) && defined(__SSE2__)) || \
      (defined(_WIN32) && (_M_IX86_FP == 2 || defined(_M_X64)))

  //--- SSE2 intrinsics
  // NB: 64-bit x86 guarantees availability of SSE2.

  __m128d m1, m2;
  int i, s;

  m1 = _mm_set_sd(x);
  i = _mm_cvttsd_si32(m1);
  m2 = _mm_cvtsi32_sd(m1, i);
  s = _mm_ucomigt_sd(m2, m1);
  return i - s;

#elif defined(__GNUC__) && defined(__i386__) && !defined(__APPLE__)

  //--- x87 inline assembly (gcc/clang)
  // (this code fails on OSX for reasons I don't understand)

  Gushort oldCW, newCW, t;
  int result;

  __asm__ volatile("fnstcw %0\n"
       "movw   %0, %3\n"
       "andw   $0xf3ff, %3\n"
       "orw    $0x0400, %3\n"
       "movw   %3, %1\n"       // round down
       "fldcw  %1\n"
       "fistl %2\n"
       "fldcw  %0\n"
       : "=m" (oldCW), "=m" (newCW), "=m" (result), "=r" (t)
       : "t" (x));
  return result;

#elif defined(_WIN32) && defined(_M_IX86)

  //--- x87 inline assembly (VC)

  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

  //--- all others

  return (int)floor(x);

#endif
}

// ceil() and (int)() are implemented separately, which results
// in changing the FPCW multiple times - so we optimize it with
// some inline assembly or SSE intrinsics.
static inline int splashCeil(SplashCoord x) {
#if USE_FIXEDPOINT

  //--- fixed point

  return FixedPoint::ceil(x);

#elif (defined(__GNUC__) && defined(__SSE2__)) || \
      (defined(_WIN32) && (_M_IX86_FP == 2 || defined(_M_X64)))

  //--- SSE2 intrinsics
  // NB: 64-bit x86 guarantees availability of SSE2.

  __m128d m1, m2;
  int i, s;

  m1 = _mm_set_sd(x);
  i = _mm_cvttsd_si32(m1);
  m2 = _mm_cvtsi32_sd(m1, i);
  s = _mm_ucomilt_sd(m2, m1);
  return i + s;

#elif defined(__GNUC__) && defined(__i386__) && !defined(__APPLE__)

  //--- x87 inline assembly (gcc/clang)
  // (this code fails on OSX for reasons I don't understand)

  Gushort oldCW, newCW, t;
  int result;

  __asm__ volatile("fnstcw %0\n"
       "movw   %0, %3\n"
       "andw   $0xf3ff, %3\n"
       "orw    $0x0800, %3\n"
       "movw   %3, %1\n"       // round up
       "fldcw  %1\n"
       "fistl %2\n"
       "fldcw  %0\n"
       : "=m" (oldCW), "=m" (newCW), "=m" (result), "=r" (t)
       : "t" (x));
  return result;

#elif defined(_WIN32) && defined(_M_IX86)

  //--- x87 inline assembly (VC)

  // 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

  //--- all others

  return (int)ceil(x);

#endif
}

static inline int splashRound(SplashCoord x) {
#if USE_FIXEDPOINT

  //--- fixed point

  return FixedPoint::round(x);

#else

  //--- all others

  return splashFloor(x + 0.5);

#endif
}

static inline SplashCoord splashAvg(SplashCoord x, SplashCoord y) {
#if USE_FIXEDPOINT
  return FixedPoint::avg(x, y);
#else
  return 0.5 * (x + y);
#endif
}

static inline SplashCoord splashSqrt(SplashCoord x) {
#if USE_FIXEDPOINT
  return FixedPoint::sqrt(x);
#else
  return sqrt(x);
#endif
}

static inline SplashCoord splashPow(SplashCoord x, SplashCoord y) {
#if USE_FIXEDPOINT
  return FixedPoint::pow(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;
#if 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 sqrt(dx * dx + dy * dy);
#endif
}

static inline GBool splashCheckDet(SplashCoord m11, SplashCoord m12,
           SplashCoord m21, SplashCoord m22,
           SplashCoord epsilon) {
#if USE_FIXEDPOINT
  return FixedPoint::checkDet(m11, m12, m21, m22, epsilon);
#else
  return fabs(m11 * m22 - m12 * m21) >= epsilon;
#endif
}

// Perform stroke adjustment on a SplashCoord range [xMin, xMax),
// resulting in an int range [*xMinI, *xMaxI).
//
// There are several options:
//
// 1. Round both edge coordinates.
//    Pro: adjacent strokes/fills line up without any gaps or
//         overlaps
//    Con: lines with the same original floating point width can
//         end up with different integer widths, e.g.:
//               xMin  = 10.1   xMax  = 11.3   (width = 1.2)
//           --> xMinI = 10     xMaxI = 11     (width = 1)
//         but
//               xMin  = 10.4   xMax  = 11.6   (width = 1.2)
//           --> xMinI = 10     xMaxI = 12     (width = 2)
//
// 2. Round the min coordinate; add the ceiling of the width.
//    Pro: lines with the same original floating point width will
//         always end up with the same integer width
//    Con: adjacent strokes/fills can have overlaps (which is
//         problematic with transparency)
//    (This could use floor on the min coordinate, instead of
//    rounding, with similar results.)
//    (If the width is rounded instead of using ceiling, the results
//    Are similar, except that adjacent strokes/fills can have gaps
//    as well as overlaps.)
//
// 3. Use floor on the min coordinate and ceiling on the max
//    coordinate.
//    Pro: lines always end up at least as wide as the original
//         floating point width
//    Con: adjacent strokes/fills can have overlaps, and lines with
//         the same original floating point width can end up with
//         different integer widths; the integer width can be more
//         than one pixel wider than the original width, e.g.:
//               xMin  = 10.9   xMax  = 12.1   (width = 1.2)
//           --> xMinI = 10     xMaxI = 13     (width = 3)
//         but
//               xMin  = 10.1   xMax  = 11.3   (width = 1.2)
//           --> xMinI = 10     xMaxI = 12     (width = 2)
//
// 4. Use a hybrid approach, choosing between two of the above
//    options, based on width.  E.g., use #2 if width <= 4, and use #1
//    if width > 4.
//
// If w >= 0 and strokeAdjMode is splashStrokeAdjustCAD then a special
// mode for projecting line caps is enabled, with w being the
// transformed line width.

static inline void splashStrokeAdjust(SplashCoord xMin, SplashCoord xMax,
              int *xMinI, int *xMaxI,
              SplashStrokeAdjustMode strokeAdjMode,
              SplashCoord w = -1) {
  int x0, x1;

  // make sure the coords fit in 32-bit ints
#if USE_FIXEDPOINT
  if (xMin < -32767) {
    xMin = -32767;
  } else if (xMin > 32767) {
    xMin = 32767;
  }
  if (xMax < -32767) {
    xMax = -32767;
  } else if (xMax > 32767) {
    xMax = 32767;
  }
#else
  if (xMin < -1e9) {
    xMin = -1e9;
  } else if (xMin > 1e9) {
    xMin = 1e9;
  }
  if (xMax < -1e9) {
    xMax = -1e9;
  } else if (xMax > 1e9) {
    xMax = 1e9;
  }
#endif

  // this will never be called with strokeAdjMode == splashStrokeAdjustOff
  if (strokeAdjMode == splashStrokeAdjustCAD) {
    x0 = splashRound(xMin);
    if (w >= 0) {
      x1 = splashRound(xMax - w) + splashRound(w);
    } else {
      x1 = x0 + splashRound(xMax - xMin);
    }
  } else {
    // NB: enable exactly one of these.
#if 1 // 1. Round both edge coordinates.
    x0 = splashRound(xMin);
    x1 = splashRound(xMax);
#endif
#if 0 // 2. Round the min coordinate; add the ceiling of the width.
    x0 = splashRound(xMin);
    x1 = x0 + splashCeil(xMax - xMin);
#endif
#if 0 // 3. Use floor on the min coord and ceiling on the max coord.
    x0 = splashFloor(xMin);
    x1 = splashCeil(xMax);
#endif
#if 0 // 4. Hybrid.
    SplashCoord w = xMax - xMin;
    x0 = splashRound(xMin);
    if (w > 4) {
      x1 = splashRound(xMax);
    } else {
      x1 = x0 + splashRound(w);
    }
#endif
  }
  if (x0 == x1) {
    if (xMin + xMax < 2 * x0) {
      --x0;
    } else {
      ++x1;
    }
  }
  *xMinI = x0;
  *xMaxI = x1;
}

#endif

Coverage Report

Created: 2023-09-25 06:41

Line	Count	Source (jump to first uncovered line)
1		//========================================================================
2		//
3		// SplashMath.h
4		//
5		// Copyright 2003-2013 Glyph & Cog, LLC
6		//
7		//========================================================================
8
9		#ifndef SPLASHMATH_H
10		#define SPLASHMATH_H
11
12		#include <aconf.h>
13
14		#if USE_FIXEDPONT
15		# include "FixedPoint.h"
16		#else
17		# include <math.h>
18		# if (defined(__GNUC__) && defined(__SSE2__)) \|\| \
19		(defined(_WIN32) && (_M_IX86_FP == 2 \|\| defined(_M_X64)))
20		# include <emmintrin.h>
21		# endif
22		#endif
23		#include "SplashTypes.h"
24
25	0	static inline SplashCoord splashAbs(SplashCoord x) {
26		#if USE_FIXEDPOINT
27		return FixedPoint::abs(x);
28		#else
29	0	return fabs(x);
30	0	#endif
31	0	} Unexecuted instantiation: SplashOutputDev.cc:splashAbs(double) Unexecuted instantiation: Splash.cc:splashAbs(double) Unexecuted instantiation: SplashClip.cc:splashAbs(double) Unexecuted instantiation: SplashFontEngine.cc:splashAbs(double) Unexecuted instantiation: SplashPattern.cc:splashAbs(double) Unexecuted instantiation: SplashState.cc:splashAbs(double) Unexecuted instantiation: SplashXPath.cc:splashAbs(double) Unexecuted instantiation: SplashXPathScanner.cc:splashAbs(double) Unexecuted instantiation: ShadingImage.cc:splashAbs(double) Unexecuted instantiation: SplashFTFontFile.cc:splashAbs(double) Unexecuted instantiation: SplashFont.cc:splashAbs(double) Unexecuted instantiation: SplashScreen.cc:splashAbs(double) Unexecuted instantiation: SplashFTFont.cc:splashAbs(double)
32
33		// floor() and (int)() are implemented separately, which results
34		// in changing the FPCW multiple times - so we optimize it with
35		// some inline assembly or SSE intrinsics.
36	0	static inline int splashFloor(SplashCoord x) {
37		#if USE_FIXEDPOINT
38
39		//--- fixed point
40
41		return FixedPoint::floor(x);
42
43		#elif (defined(__GNUC__) && defined(__SSE2__)) \|\| \
44		(defined(_WIN32) && (_M_IX86_FP == 2 \|\| defined(_M_X64)))
45
46		//--- SSE2 intrinsics
47		// NB: 64-bit x86 guarantees availability of SSE2.
48
49	0	__m128d m1, m2;
50	0	int i, s;
51
52	0	m1 = _mm_set_sd(x);
53	0	i = _mm_cvttsd_si32(m1);
54	0	m2 = _mm_cvtsi32_sd(m1, i);
55	0	s = _mm_ucomigt_sd(m2, m1);
56	0	return i - s;
57
58		#elif defined(__GNUC__) && defined(__i386__) && !defined(__APPLE__)
59
60		//--- x87 inline assembly (gcc/clang)
61		// (this code fails on OSX for reasons I don't understand)
62
63		Gushort oldCW, newCW, t;
64		int result;
65
66		__asm__ volatile("fnstcw %0\n"
67		"movw %0, %3\n"
68		"andw $0xf3ff, %3\n"
69		"orw $0x0400, %3\n"
70		"movw %3, %1\n" // round down
71		"fldcw %1\n"
72		"fistl %2\n"
73		"fldcw %0\n"
74		: "=m" (oldCW), "=m" (newCW), "=m" (result), "=r" (t)
75		: "t" (x));
76		return result;
77
78		#elif defined(_WIN32) && defined(_M_IX86)
79
80		//--- x87 inline assembly (VC)
81
82		Gushort oldCW, newCW;
83		int result;
84
85		__asm fld QWORD PTR x
86		__asm fnstcw WORD PTR oldCW
87		__asm mov ax, WORD PTR oldCW
88		__asm and ax, 0xf3ff
89		__asm or ax, 0x0400
90		__asm mov WORD PTR newCW, ax // round down
91		__asm fldcw WORD PTR newCW
92		__asm fistp DWORD PTR result
93		__asm fldcw WORD PTR oldCW
94		return result;
95
96		#else
97
98		//--- all others
99
100		return (int)floor(x);
101
102		#endif
103	0	} Unexecuted instantiation: SplashOutputDev.cc:splashFloor(double) Unexecuted instantiation: Splash.cc:splashFloor(double) Unexecuted instantiation: SplashClip.cc:splashFloor(double) Unexecuted instantiation: SplashFontEngine.cc:splashFloor(double) Unexecuted instantiation: SplashPattern.cc:splashFloor(double) Unexecuted instantiation: SplashState.cc:splashFloor(double) Unexecuted instantiation: SplashXPath.cc:splashFloor(double) Unexecuted instantiation: SplashXPathScanner.cc:splashFloor(double) Unexecuted instantiation: ShadingImage.cc:splashFloor(double) Unexecuted instantiation: SplashFTFontFile.cc:splashFloor(double) Unexecuted instantiation: SplashFont.cc:splashFloor(double) Unexecuted instantiation: SplashScreen.cc:splashFloor(double) Unexecuted instantiation: SplashFTFont.cc:splashFloor(double)
104
105		// ceil() and (int)() are implemented separately, which results
106		// in changing the FPCW multiple times - so we optimize it with
107		// some inline assembly or SSE intrinsics.
108	0	static inline int splashCeil(SplashCoord x) {
109		#if USE_FIXEDPOINT
110
111		//--- fixed point
112
113		return FixedPoint::ceil(x);
114
115		#elif (defined(__GNUC__) && defined(__SSE2__)) \|\| \
116		(defined(_WIN32) && (_M_IX86_FP == 2 \|\| defined(_M_X64)))
117
118		//--- SSE2 intrinsics
119		// NB: 64-bit x86 guarantees availability of SSE2.
120
121	0	__m128d m1, m2;
122	0	int i, s;
123
124	0	m1 = _mm_set_sd(x);
125	0	i = _mm_cvttsd_si32(m1);
126	0	m2 = _mm_cvtsi32_sd(m1, i);
127	0	s = _mm_ucomilt_sd(m2, m1);
128	0	return i + s;
129
130		#elif defined(__GNUC__) && defined(__i386__) && !defined(__APPLE__)
131
132		//--- x87 inline assembly (gcc/clang)
133		// (this code fails on OSX for reasons I don't understand)
134
135		Gushort oldCW, newCW, t;
136		int result;
137
138		__asm__ volatile("fnstcw %0\n"
139		"movw %0, %3\n"
140		"andw $0xf3ff, %3\n"
141		"orw $0x0800, %3\n"
142		"movw %3, %1\n" // round up
143		"fldcw %1\n"
144		"fistl %2\n"
145		"fldcw %0\n"
146		: "=m" (oldCW), "=m" (newCW), "=m" (result), "=r" (t)
147		: "t" (x));
148		return result;
149
150		#elif defined(_WIN32) && defined(_M_IX86)
151
152		//--- x87 inline assembly (VC)
153
154		// ceil() and (int)() are implemented separately, which results
155		// in changing the FPCW multiple times - so we optimize it with
156		// some inline assembly
157		Gushort oldCW, newCW;
158		int result;
159
160		__asm fld QWORD PTR x
161		__asm fnstcw WORD PTR oldCW
162		__asm mov ax, WORD PTR oldCW
163		__asm and ax, 0xf3ff
164		__asm or ax, 0x0800
165		__asm mov WORD PTR newCW, ax // round up
166		__asm fldcw WORD PTR newCW
167		__asm fistp DWORD PTR result
168		__asm fldcw WORD PTR oldCW
169		return result;
170
171		#else
172
173		//--- all others
174
175		return (int)ceil(x);
176
177		#endif
178	0	} Unexecuted instantiation: SplashOutputDev.cc:splashCeil(double) Unexecuted instantiation: Splash.cc:splashCeil(double) Unexecuted instantiation: SplashClip.cc:splashCeil(double) Unexecuted instantiation: SplashFontEngine.cc:splashCeil(double) Unexecuted instantiation: SplashPattern.cc:splashCeil(double) Unexecuted instantiation: SplashState.cc:splashCeil(double) Unexecuted instantiation: SplashXPath.cc:splashCeil(double) Unexecuted instantiation: SplashXPathScanner.cc:splashCeil(double) Unexecuted instantiation: ShadingImage.cc:splashCeil(double) Unexecuted instantiation: SplashFTFontFile.cc:splashCeil(double) Unexecuted instantiation: SplashFont.cc:splashCeil(double) Unexecuted instantiation: SplashScreen.cc:splashCeil(double) Unexecuted instantiation: SplashFTFont.cc:splashCeil(double)
179
180	0	static inline int splashRound(SplashCoord x) {
181		#if USE_FIXEDPOINT
182
183		//--- fixed point
184
185		return FixedPoint::round(x);
186
187		#else
188
189		//--- all others
190
191	0	return splashFloor(x + 0.5);
192
193	0	#endif
194	0	} Unexecuted instantiation: SplashOutputDev.cc:splashRound(double) Unexecuted instantiation: Splash.cc:splashRound(double) Unexecuted instantiation: SplashClip.cc:splashRound(double) Unexecuted instantiation: SplashFontEngine.cc:splashRound(double) Unexecuted instantiation: SplashPattern.cc:splashRound(double) Unexecuted instantiation: SplashState.cc:splashRound(double) Unexecuted instantiation: SplashXPath.cc:splashRound(double) Unexecuted instantiation: SplashXPathScanner.cc:splashRound(double) Unexecuted instantiation: ShadingImage.cc:splashRound(double) Unexecuted instantiation: SplashFTFontFile.cc:splashRound(double) Unexecuted instantiation: SplashFont.cc:splashRound(double) Unexecuted instantiation: SplashScreen.cc:splashRound(double) Unexecuted instantiation: SplashFTFont.cc:splashRound(double)
195
196	0	static inline SplashCoord splashAvg(SplashCoord x, SplashCoord y) {
197		#if USE_FIXEDPOINT
198		return FixedPoint::avg(x, y);
199		#else
200	0	return 0.5 * (x + y);
201	0	#endif
202	0	} Unexecuted instantiation: SplashOutputDev.cc:splashAvg(double, double) Unexecuted instantiation: Splash.cc:splashAvg(double, double) Unexecuted instantiation: SplashClip.cc:splashAvg(double, double) Unexecuted instantiation: SplashFontEngine.cc:splashAvg(double, double) Unexecuted instantiation: SplashPattern.cc:splashAvg(double, double) Unexecuted instantiation: SplashState.cc:splashAvg(double, double) Unexecuted instantiation: SplashXPath.cc:splashAvg(double, double) Unexecuted instantiation: SplashXPathScanner.cc:splashAvg(double, double) Unexecuted instantiation: ShadingImage.cc:splashAvg(double, double) Unexecuted instantiation: SplashFTFontFile.cc:splashAvg(double, double) Unexecuted instantiation: SplashFont.cc:splashAvg(double, double) Unexecuted instantiation: SplashScreen.cc:splashAvg(double, double) Unexecuted instantiation: SplashFTFont.cc:splashAvg(double, double)
203
204	0	static inline SplashCoord splashSqrt(SplashCoord x) {
205		#if USE_FIXEDPOINT
206		return FixedPoint::sqrt(x);
207		#else
208	0	return sqrt(x);
209	0	#endif
210	0	} Unexecuted instantiation: SplashOutputDev.cc:splashSqrt(double) Unexecuted instantiation: Splash.cc:splashSqrt(double) Unexecuted instantiation: SplashClip.cc:splashSqrt(double) Unexecuted instantiation: SplashFontEngine.cc:splashSqrt(double) Unexecuted instantiation: SplashPattern.cc:splashSqrt(double) Unexecuted instantiation: SplashState.cc:splashSqrt(double) Unexecuted instantiation: SplashXPath.cc:splashSqrt(double) Unexecuted instantiation: SplashXPathScanner.cc:splashSqrt(double) Unexecuted instantiation: ShadingImage.cc:splashSqrt(double) Unexecuted instantiation: SplashFTFontFile.cc:splashSqrt(double) Unexecuted instantiation: SplashFont.cc:splashSqrt(double) Unexecuted instantiation: SplashScreen.cc:splashSqrt(double) Unexecuted instantiation: SplashFTFont.cc:splashSqrt(double)
211
212	0	static inline SplashCoord splashPow(SplashCoord x, SplashCoord y) {
213		#if USE_FIXEDPOINT
214		return FixedPoint::pow(x, y);
215		#else
216	0	return pow(x, y);
217	0	#endif
218	0	} Unexecuted instantiation: SplashOutputDev.cc:splashPow(double, double) Unexecuted instantiation: Splash.cc:splashPow(double, double) Unexecuted instantiation: SplashClip.cc:splashPow(double, double) Unexecuted instantiation: SplashFontEngine.cc:splashPow(double, double) Unexecuted instantiation: SplashPattern.cc:splashPow(double, double) Unexecuted instantiation: SplashState.cc:splashPow(double, double) Unexecuted instantiation: SplashXPath.cc:splashPow(double, double) Unexecuted instantiation: SplashXPathScanner.cc:splashPow(double, double) Unexecuted instantiation: ShadingImage.cc:splashPow(double, double) Unexecuted instantiation: SplashFTFontFile.cc:splashPow(double, double) Unexecuted instantiation: SplashFont.cc:splashPow(double, double) Unexecuted instantiation: SplashScreen.cc:splashPow(double, double) Unexecuted instantiation: SplashFTFont.cc:splashPow(double, double)
219
220		static inline SplashCoord splashDist(SplashCoord x0, SplashCoord y0,
221	0	SplashCoord x1, SplashCoord y1) {
222	0	SplashCoord dx, dy;
223	0	dx = x1 - x0;
224	0	dy = y1 - y0;
225		#if USE_FIXEDPOINT
226		// this handles the situation where dxdx or dydy is too large to
227		// fit in the 16.16 fixed point format
228		SplashCoord dxa, dya, d;
229		dxa = splashAbs(dx);
230		dya = splashAbs(dy);
231		if (dxa == 0 && dya == 0) {
232		return 0;
233		} else if (dxa > dya) {
234		d = dya / dxa;
235		return dxa * FixedPoint::sqrt(d*d + 1);
236		} else {
237		d = dxa / dya;
238		return dya * FixedPoint::sqrt(d*d + 1);
239		}
240		#else
241	0	return sqrt(dx * dx + dy * dy);
242	0	#endif
243	0	} Unexecuted instantiation: SplashOutputDev.cc:splashDist(double, double, double, double) Unexecuted instantiation: Splash.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashClip.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashFontEngine.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashPattern.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashState.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashXPath.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashXPathScanner.cc:splashDist(double, double, double, double) Unexecuted instantiation: ShadingImage.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashFTFontFile.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashFont.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashScreen.cc:splashDist(double, double, double, double) Unexecuted instantiation: SplashFTFont.cc:splashDist(double, double, double, double)
244
245		static inline GBool splashCheckDet(SplashCoord m11, SplashCoord m12,
246		SplashCoord m21, SplashCoord m22,
247	0	SplashCoord epsilon) {
248		#if USE_FIXEDPOINT
249		return FixedPoint::checkDet(m11, m12, m21, m22, epsilon);
250		#else
251	0	return fabs(m11 * m22 - m12 * m21) >= epsilon;
252	0	#endif
253	0	} Unexecuted instantiation: SplashOutputDev.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: Splash.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashClip.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashFontEngine.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashPattern.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashState.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashXPath.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashXPathScanner.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: ShadingImage.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashFTFontFile.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashFont.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashScreen.cc:splashCheckDet(double, double, double, double, double) Unexecuted instantiation: SplashFTFont.cc:splashCheckDet(double, double, double, double, double)
254
255		// Perform stroke adjustment on a SplashCoord range [xMin, xMax),
256		// resulting in an int range [xMinI, xMaxI).
257		//
258		// There are several options:
259		//
260		// 1. Round both edge coordinates.
261		// Pro: adjacent strokes/fills line up without any gaps or
262		// overlaps
263		// Con: lines with the same original floating point width can
264		// end up with different integer widths, e.g.:
265		// xMin = 10.1 xMax = 11.3 (width = 1.2)
266		// --> xMinI = 10 xMaxI = 11 (width = 1)
267		// but
268		// xMin = 10.4 xMax = 11.6 (width = 1.2)
269		// --> xMinI = 10 xMaxI = 12 (width = 2)
270		//
271		// 2. Round the min coordinate; add the ceiling of the width.
272		// Pro: lines with the same original floating point width will
273		// always end up with the same integer width
274		// Con: adjacent strokes/fills can have overlaps (which is
275		// problematic with transparency)
276		// (This could use floor on the min coordinate, instead of
277		// rounding, with similar results.)
278		// (If the width is rounded instead of using ceiling, the results
279		// Are similar, except that adjacent strokes/fills can have gaps
280		// as well as overlaps.)
281		//
282		// 3. Use floor on the min coordinate and ceiling on the max
283		// coordinate.
284		// Pro: lines always end up at least as wide as the original
285		// floating point width
286		// Con: adjacent strokes/fills can have overlaps, and lines with
287		// the same original floating point width can end up with
288		// different integer widths; the integer width can be more
289		// than one pixel wider than the original width, e.g.:
290		// xMin = 10.9 xMax = 12.1 (width = 1.2)
291		// --> xMinI = 10 xMaxI = 13 (width = 3)
292		// but
293		// xMin = 10.1 xMax = 11.3 (width = 1.2)
294		// --> xMinI = 10 xMaxI = 12 (width = 2)
295		//
296		// 4. Use a hybrid approach, choosing between two of the above
297		// options, based on width. E.g., use #2 if width <= 4, and use #1
298		// if width > 4.
299		//
300		// If w >= 0 and strokeAdjMode is splashStrokeAdjustCAD then a special
301		// mode for projecting line caps is enabled, with w being the
302		// transformed line width.
303
304		static inline void splashStrokeAdjust(SplashCoord xMin, SplashCoord xMax,
305		int xMinI, int xMaxI,
306		SplashStrokeAdjustMode strokeAdjMode,
307	0	SplashCoord w = -1) {
308	0	int x0, x1;
309
310		// make sure the coords fit in 32-bit ints
311		#if USE_FIXEDPOINT
312		if (xMin < -32767) {
313		xMin = -32767;
314		} else if (xMin > 32767) {
315		xMin = 32767;
316		}
317		if (xMax < -32767) {
318		xMax = -32767;
319		} else if (xMax > 32767) {
320		xMax = 32767;
321		}
322		#else
323	0	if (xMin < -1e9) {
324	0	xMin = -1e9;
325	0	} else if (xMin > 1e9) {
326	0	xMin = 1e9;
327	0	}
328	0	if (xMax < -1e9) {
329	0	xMax = -1e9;
330	0	} else if (xMax > 1e9) {
331	0	xMax = 1e9;
332	0	}
333	0	#endif
334
335		// this will never be called with strokeAdjMode == splashStrokeAdjustOff
336	0	if (strokeAdjMode == splashStrokeAdjustCAD) {
337	0	x0 = splashRound(xMin);
338	0	if (w >= 0) {
339	0	x1 = splashRound(xMax - w) + splashRound(w);
340	0	} else {
341	0	x1 = x0 + splashRound(xMax - xMin);
342	0	}
343	0	} else {
344		// NB: enable exactly one of these.
345	0	#if 1 // 1. Round both edge coordinates.
346	0	x0 = splashRound(xMin);
347	0	x1 = splashRound(xMax);
348	0	#endif
349		#if 0 // 2. Round the min coordinate; add the ceiling of the width.
350		x0 = splashRound(xMin);
351		x1 = x0 + splashCeil(xMax - xMin);
352		#endif
353		#if 0 // 3. Use floor on the min coord and ceiling on the max coord.
354		x0 = splashFloor(xMin);
355		x1 = splashCeil(xMax);
356		#endif
357		#if 0 // 4. Hybrid.
358		SplashCoord w = xMax - xMin;
359		x0 = splashRound(xMin);
360		if (w > 4) {
361		x1 = splashRound(xMax);
362		} else {
363		x1 = x0 + splashRound(w);
364		}
365		#endif
366	0	}
367	0	if (x0 == x1) {
368	0	if (xMin + xMax < 2 * x0) {
369	0	--x0;
370	0	} else {
371	0	++x1;
372	0	}
373	0	}
374	0	*xMinI = x0;
375	0	*xMaxI = x1;
376	0	} Unexecuted instantiation: SplashOutputDev.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: Splash.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashClip.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashFontEngine.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashPattern.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashState.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashXPath.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashXPathScanner.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: ShadingImage.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashFTFontFile.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashFont.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashScreen.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double) Unexecuted instantiation: SplashFTFont.cc:splashStrokeAdjust(double, double, int, int, SplashStrokeAdjustMode, double)
377
378		#endif