[poppler] CMakeLists.txt config.h.cmake goo/FixedPoint.cc goo/FixedPoint.h poppler/poppler-config.h.cmake splash/Splash.cc splash/SplashFTFont.cc splash/SplashMath.h splash/SplashTypes.h splash/SplashXPath.cc
GitLab Mirror
gitlab-mirror at kemper.freedesktop.org
Tue Aug 20 19:36:08 UTC 2019
CMakeLists.txt | 7 -
config.h.cmake | 3
goo/FixedPoint.cc | 145 ---------------------------------
goo/FixedPoint.h | 176 -----------------------------------------
poppler/poppler-config.h.cmake | 5 -
splash/Splash.cc | 30 ------
splash/SplashFTFont.cc | 69 ----------------
splash/SplashMath.h | 53 +-----------
splash/SplashTypes.h | 5 -
splash/SplashXPath.cc | 22 -----
10 files changed, 7 insertions(+), 508 deletions(-)
New commits:
commit 5b81ab6ce06f60daa63029a3eb12cd31d6852799
Author: Adrian Bunk <bunk at stusta.de>
Date: Tue Aug 20 21:00:40 2019 +0300
Remove USE_FIXEDPOINT support
This was already non-compiling for some time.
Closes #821
diff --git a/CMakeLists.txt b/CMakeLists.txt
index edcc5a23..06e8e709 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -62,7 +62,6 @@ option(ENABLE_LIBCURL "Build libcurl based HTTP support." ON)
option(ENABLE_ZLIB "Build with zlib." ON)
option(ENABLE_ZLIB_UNCOMPRESS "Use zlib to uncompress flate streams (not totally safe)." OFF)
option(SPLASH_CMYK "Include support for CMYK rasterization." OFF)
-option(USE_FIXEDPOINT "Use fixed point arithmetic in the Splash backend" OFF)
option(USE_FLOAT "Use single precision arithmetic in the Splash backend" OFF)
option(BUILD_SHARED_LIBS "Build poppler as a shared library" ON)
if(WIN32)
@@ -328,7 +327,6 @@ set(poppler_SRCS
goo/gfile.cc
goo/GooTimer.cc
goo/GooString.cc
- goo/FixedPoint.cc
goo/NetPBMWriter.cc
goo/PNGWriter.cc
goo/TiffWriter.cc
@@ -594,7 +592,6 @@ if(ENABLE_UNSTABLE_API_ABI_HEADERS)
goo/gmem.h
goo/gdir.h
goo/gfile.h
- goo/FixedPoint.h
goo/ImgWriter.h
goo/GooCheckedOps.h
goo/GooLikely.h
@@ -747,10 +744,6 @@ if(NOT ENABLE_SPLASH AND NOT CAIRO_FOUND)
message("Warning: There is no rendering backend enabled")
endif()
-if(USE_FIXEDPOINT AND USE_FLOAT)
- message("Warning: Single precision and fixed point options should not be enabled at the same time")
-endif()
-
if(NOT ENABLE_LIBJPEG AND HAVE_DCT_DECODER)
message("Warning: Using libjpeg is recommended. The internal DCT decoder is unmaintained.")
endif()
diff --git a/config.h.cmake b/config.h.cmake
index 7989cbfb..c9958130 100644
--- a/config.h.cmake
+++ b/config.h.cmake
@@ -165,9 +165,6 @@
/* Defines if use cms */
#cmakedefine USE_CMS 1
-/* Use fixed point arithmetic in the Splash backend */
-#cmakedefine USE_FIXEDPOINT 1
-
/* Use single precision arithmetic in the Splash backend */
#cmakedefine USE_FLOAT 1
diff --git a/goo/FixedPoint.cc b/goo/FixedPoint.cc
deleted file mode 100644
index 31e04b68..00000000
--- a/goo/FixedPoint.cc
+++ /dev/null
@@ -1,145 +0,0 @@
-//========================================================================
-//
-// FixedPoint.cc
-//
-// Fixed point type, with C++ operators.
-//
-// Copyright 2004 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) 2017 Adrian Johnson <ajohnson at 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_FIXEDPOINT
-
-#include "FixedPoint.h"
-
-#define ln2 ((FixedPoint)0.69314718)
-
-#define ln2 ((FixedPoint)0.69314718)
-
-FixedPoint FixedPoint::sqrt(FixedPoint x) {
- FixedPoint y0, y1, z;
-
- if (x.val <= 0) {
- y1.val = 0;
- } else {
- y1.val = x.val == 1 ? 2 : x.val >> 1;
- do {
- y0.val = y1.val;
- z = x / y0;
- y1.val = (y0.val + z.val) >> 1;
- } while (::abs(y0.val - y1.val) > 1);
- }
- return y1;
-}
-
-FixedPoint FixedPoint::pow(FixedPoint x, FixedPoint y) {
- FixedPoint t, t2, lnx0, lnx, z0, z;
- int d, n, i;
-
- if (y.val <= 0) {
- z.val = 0;
- } else {
- // y * ln(x)
- t = (x - 1) / (x + 1);
- t2 = t * t;
- d = 1;
- lnx = 0;
- do {
- lnx0 = lnx;
- lnx += t / d;
- t *= t2;
- d += 2;
- } while (::abs(lnx.val - lnx0.val) > 2);
- lnx.val <<= 1;
- t = y * lnx;
- // exp(y * ln(x))
- n = floor(t / ln2);
- t -= ln2 * n;
- t2 = t;
- d = 1;
- i = 1;
- z = 1;
- do {
- z0 = z;
- z += t2 / d;
- t2 *= t;
- ++i;
- d *= i;
- } while (::abs(z.val - z0.val) > 2 && d < (1 << fixptShift));
- if (n >= 0) {
- z.val <<= n;
- } else if (n < 0) {
- z.val >>= -n;
- }
- }
- return z;
-}
-
-int FixedPoint::mul(int x, int y) {
- FixPtInt64 z;
-
- z = ((FixPtInt64)x * y) >> fixptShift;
- if (z > 0x7fffffffLL) {
- return 0x7fffffff;
- } else if (z < -0x80000000LL) {
- return 0x80000000;
- } else {
- return (int)z;
- }
-}
-
-int FixedPoint::div(int x, int y) {
- FixPtInt64 z;
-
- z = ((FixPtInt64)x << fixptShift) / y;
- if (z > 0x7fffffffLL) {
- return 0x7fffffff;
- } else if (z < -0x80000000LL) {
- return 0x80000000;
- } else {
- return (int)z;
- }
-}
-
-bool FixedPoint::divCheck(FixedPoint x, FixedPoint y, FixedPoint *result) {
- FixPtInt64 z;
-
- z = ((FixPtInt64)x.val << fixptShift) / y.val;
- if ((z == 0 && x != 0) ||
- z >= ((FixPtInt64)1 << 31) || z < -((FixPtInt64)1 << 31)) {
- return false;
- }
- result->val = z;
- return true;
-}
-
-bool FixedPoint::checkDet(FixedPoint m11, FixedPoint m12,
- FixedPoint m21, FixedPoint m22,
- FixedPoint epsilon) {
- FixPtInt64 det, e;
-
- det = (FixPtInt64)m11.val * (FixPtInt64)m22.val
- - (FixPtInt64)m12.val * (FixPtInt64)m21.val;
- e = (FixPtInt64)epsilon.val << fixptShift;
- // NB: this comparison has to be >= not > because epsilon can be
- // truncated to zero as a fixed point value.
- return det >= e || det <= -e;
-}
-
-#endif // USE_FIXEDPOINT
diff --git a/goo/FixedPoint.h b/goo/FixedPoint.h
deleted file mode 100644
index 960c5bd0..00000000
--- a/goo/FixedPoint.h
+++ /dev/null
@@ -1,176 +0,0 @@
-//========================================================================
-//
-// FixedPoint.h
-//
-// Fixed point type, with C++ operators.
-//
-// Copyright 2004 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) 2017 Adrian Johnson <ajohnson at 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 FIXEDPOINT_H
-#define FIXEDPOINT_H
-
-#include "poppler-config.h"
-
-#ifdef USE_FIXEDPOINT
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#define fixptShift 16
-#define fixptMaskL ((1 << fixptShift) - 1)
-#define fixptMaskH (~fixptMaskL)
-
-typedef long long FixPtInt64;
-
-class FixedPoint {
-public:
-
- FixedPoint() { val = 0; }
- FixedPoint(const FixedPoint &x) { val = x.val; }
- FixedPoint(double x) { val = (int)(x * (1 << fixptShift) + 0.5); }
- FixedPoint(int x) { val = x << fixptShift; }
- FixedPoint(long x) { val = x << fixptShift; }
-
- operator float()
- { return (float) val * ((float)1 / (float)(1 << fixptShift)); }
- operator double()
- { return (double) val * (1.0 / (double)(1 << fixptShift)); }
- operator int()
- { return val >> fixptShift; }
-
- int get16Dot16() { return val; }
-
- FixedPoint operator =(FixedPoint x) { val = x.val; return *this; }
-
- int operator ==(FixedPoint x) { return val == x.val; }
- int operator ==(double x) { return *this == (FixedPoint)x; }
- int operator ==(int x) { return *this == (FixedPoint)x; }
- int operator ==(long x) { return *this == (FixedPoint)x; }
-
- int operator !=(FixedPoint x) { return val != x.val; }
- int operator !=(double x) { return *this != (FixedPoint)x; }
- int operator !=(int x) { return *this != (FixedPoint)x; }
- int operator !=(long x) { return *this != (FixedPoint)x; }
-
- int operator <(FixedPoint x) { return val < x.val; }
- int operator <(double x) { return *this < (FixedPoint)x; }
- int operator <(int x) { return *this < (FixedPoint)x; }
- int operator <(long x) { return *this < (FixedPoint)x; }
-
- int operator <=(FixedPoint x) { return val <= x.val; }
- int operator <=(double x) { return *this <= (FixedPoint)x; }
- int operator <=(int x) { return *this <= (FixedPoint)x; }
- int operator <=(long x) { return *this <= (FixedPoint)x; }
-
- int operator >(FixedPoint x) { return val > x.val; }
- int operator >(double x) { return *this > (FixedPoint)x; }
- int operator >(int x) { return *this > (FixedPoint)x; }
- int operator >(long x) { return *this > (FixedPoint)x; }
-
- int operator >=(FixedPoint x) { return val >= x.val; }
- int operator >=(double x) { return *this >= (FixedPoint)x; }
- int operator >=(int x) { return *this >= (FixedPoint)x; }
- int operator >=(long x) { return *this >= (FixedPoint)x; }
-
- FixedPoint operator -() { return make(-val); }
-
- FixedPoint operator +(FixedPoint x) { return make(val + x.val); }
- FixedPoint operator +(double x) { return *this + (FixedPoint)x; }
- FixedPoint operator +(int x) { return *this + (FixedPoint)x; }
- FixedPoint operator +(long x) { return *this + (FixedPoint)x; }
-
- FixedPoint operator +=(FixedPoint x) { val = val + x.val; return *this; }
- FixedPoint operator +=(double x) { return *this += (FixedPoint)x; }
- FixedPoint operator +=(int x) { return *this += (FixedPoint)x; }
- FixedPoint operator +=(long x) { return *this += (FixedPoint)x; }
-
- FixedPoint operator -(FixedPoint x) { return make(val - x.val); }
- FixedPoint operator -(double x) { return *this - (FixedPoint)x; }
- FixedPoint operator -(int x) { return *this - (FixedPoint)x; }
- FixedPoint operator -(long x) { return *this - (FixedPoint)x; }
-
- FixedPoint operator -=(FixedPoint x) { val = val - x.val; return *this; }
- FixedPoint operator -=(double x) { return *this -= (FixedPoint)x; }
- FixedPoint operator -=(int x) { return *this -= (FixedPoint)x; }
- FixedPoint operator -=(long x) { return *this -= (FixedPoint)x; }
-
- FixedPoint operator *(FixedPoint x) { return make(mul(val, x.val)); }
- FixedPoint operator *(double x) { return *this * (FixedPoint)x; }
- FixedPoint operator *(int x) { return *this * (FixedPoint)x; }
- FixedPoint operator *(long x) { return *this * (FixedPoint)x; }
-
- FixedPoint operator *=(FixedPoint x) { val = mul(val, x.val); return *this; }
- FixedPoint operator *=(double x) { return *this *= (FixedPoint)x; }
- FixedPoint operator *=(int x) { return *this *= (FixedPoint)x; }
- FixedPoint operator *=(long x) { return *this *= (FixedPoint)x; }
-
- FixedPoint operator /(FixedPoint x) { return make(div(val, x.val)); }
- FixedPoint operator /(double x) { return *this / (FixedPoint)x; }
- FixedPoint operator /(int x) { return *this / (FixedPoint)x; }
- FixedPoint operator /(long x) { return *this / (FixedPoint)x; }
-
- FixedPoint operator /=(FixedPoint x) { val = div(val, x.val); return *this; }
- FixedPoint operator /=(double x) { return *this /= (FixedPoint)x; }
- FixedPoint operator /=(int x) { return *this /= (FixedPoint)x; }
- FixedPoint operator /=(long x) { return *this /= (FixedPoint)x; }
-
- static FixedPoint abs(FixedPoint x) { return make(::abs(x.val)); }
-
- static int floor(FixedPoint x) { return x.val >> fixptShift; }
-
- static int ceil(FixedPoint x)
- { return (x.val & fixptMaskL) ? ((x.val >> fixptShift) + 1)
- : (x.val >> fixptShift); }
-
- static int round(FixedPoint x)
- { return (x.val + (1 << (fixptShift - 1))) >> fixptShift; }
-
- // Computes (x+y)/2 avoiding overflow and LSbit accuracy issues.
- static FixedPoint avg(FixedPoint x, FixedPoint y)
- { return make((x.val >> 1) + (y.val >> 1) + ((x.val | y.val) & 1)); }
-
-
- static FixedPoint sqrt(FixedPoint x);
-
- static FixedPoint pow(FixedPoint x, FixedPoint y);
-
- // Compute *result = x/y; return false if there is an underflow or
- // overflow.
- static bool divCheck(FixedPoint x, FixedPoint y, FixedPoint *result);
-
- // Compute abs(m11*m22 - m12*m21) >= epsilon, handling the case
- // where the multiplications overflow.
- static bool checkDet(FixedPoint m11, FixedPoint m12,
- FixedPoint m21, FixedPoint m22,
- FixedPoint epsilon);
-
-private:
-
- static FixedPoint make(int valA) { FixedPoint x; x.val = valA; return x; }
-
- static int mul(int x, int y);
- static int div(int x, int y);
-
- int val; // fixed point: (n-fixptShift).(fixptShift)
-};
-
-#endif // USE_FIXEDPOINT
-
-#endif
diff --git a/poppler/poppler-config.h.cmake b/poppler/poppler-config.h.cmake
index 746d8630..dd43d570 100644
--- a/poppler/poppler-config.h.cmake
+++ b/poppler/poppler-config.h.cmake
@@ -38,11 +38,6 @@
#define POPPLER_VERSION "${POPPLER_VERSION}"
#endif
-/* Use fixedpoint. */
-#ifndef USE_FIXEDPOINT
-#cmakedefine USE_FIXEDPOINT 1
-#endif
-
/* Use single precision arithmetic in the Splash backend */
#ifndef USE_FLOAT
#cmakedefine USE_FLOAT 1
diff --git a/splash/Splash.cc b/splash/Splash.cc
index 654608cf..074dfe6e 100644
--- a/splash/Splash.cc
+++ b/splash/Splash.cc
@@ -2214,11 +2214,7 @@ SplashPath *Splash::flattenPath(SplashPath *path, SplashCoord *matrix,
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];
@@ -2283,21 +2279,13 @@ void Splash::flattenCurve(SplashCoord x0, SplashCoord y0,
// 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
@@ -6087,19 +6075,10 @@ SplashPath *pathIn, *dashPath, *pathOut;
++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;
@@ -6188,19 +6167,10 @@ SplashPath *pathIn, *dashPath, *pathOut;
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;
diff --git a/splash/SplashFTFont.cc b/splash/SplashFTFont.cc
index 22c672af..1eafd3ee 100644
--- a/splash/SplashFTFont.cc
+++ b/splash/SplashFTFont.cc
@@ -65,9 +65,6 @@ SplashFTFont::SplashFTFont(SplashFTFontFile *fontFileA, SplashCoord *matA,
FT_Face face;
int div;
int x, y;
-#ifdef USE_FIXEDPOINT
- SplashCoord scale;
-#endif
face = fontFileA->face;
if (FT_New_Size(face, &sizeObj)) {
@@ -91,60 +88,6 @@ SplashFTFont::SplashFTFont(SplashFTFontFile *fontFileA, SplashCoord *matA,
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) /
@@ -195,7 +138,6 @@ SplashFTFont::SplashFTFont(SplashFTFontFile *fontFileA, SplashCoord *matA,
} 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) {
@@ -208,16 +150,6 @@ SplashFTFont::SplashFTFont(SplashFTFontFile *fontFileA, SplashCoord *matA,
}
// 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);
@@ -226,7 +158,6 @@ SplashFTFont::SplashFTFont(SplashFTFontFile *fontFileA, SplashCoord *matA,
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
isOk = true;
}
diff --git a/splash/SplashMath.h b/splash/SplashMath.h
index 8edcf188..bbbce367 100644
--- a/splash/SplashMath.h
+++ b/splash/SplashMath.h
@@ -24,17 +24,11 @@
#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)
+#if defined(USE_FLOAT)
return fabsf(x);
#else
return fabs(x);
@@ -42,9 +36,7 @@ static inline SplashCoord splashAbs(SplashCoord x) {
}
static inline int splashFloor(SplashCoord x) {
-#if defined(USE_FIXEDPOINT)
- return FixedPoint::floor(x);
-#elif defined(USE_FLOAT)
+#if defined(USE_FLOAT)
return (int)floorf(x);
#elif defined(__GNUC__) && defined(__i386__)
// floor() and (int)() are implemented separately, which results
@@ -89,9 +81,7 @@ static inline int splashFloor(SplashCoord x) {
}
static inline int splashCeil(SplashCoord x) {
-#if defined(USE_FIXEDPOINT)
- return FixedPoint::ceil(x);
-#elif defined(USE_FLOAT)
+#if defined(USE_FLOAT)
return (int)ceilf(x);
#elif defined(__GNUC__) && defined(__i386__)
// ceil() and (int)() are implemented separately, which results
@@ -135,9 +125,7 @@ static inline int splashCeil(SplashCoord x) {
}
static inline int splashRound(SplashCoord x) {
-#if defined(USE_FIXEDPOINT)
- return FixedPoint::round(x);
-#elif defined(__GNUC__) && defined(__i386__)
+#if 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)
@@ -181,17 +169,11 @@ static inline int splashRound(SplashCoord x) {
}
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)
+#if defined(USE_FLOAT)
return sqrtf(x);
#else
return sqrt(x);
@@ -199,9 +181,7 @@ static inline SplashCoord splashSqrt(SplashCoord x) {
}
static inline SplashCoord splashPow(SplashCoord x, SplashCoord y) {
-#if defined(USE_FIXEDPOINT)
- return FixedPoint::pow(x, y);
-#elif defined(USE_FLOAT)
+#if defined(USE_FLOAT)
return powf(x, y);
#else
return pow(x, y);
@@ -213,34 +193,13 @@ static inline SplashCoord splashDist(SplashCoord x0, SplashCoord y0,
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 bool 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/splash/SplashTypes.h b/splash/SplashTypes.h
index 812225a1..deb91881 100644
--- a/splash/SplashTypes.h
+++ b/splash/SplashTypes.h
@@ -31,10 +31,7 @@
// coordinates
//------------------------------------------------------------------------
-#if defined(USE_FIXEDPOINT)
-#include "goo/FixedPoint.h"
-typedef FixedPoint SplashCoord;
-#elif defined(USE_FLOAT)
+#if defined(USE_FLOAT)
typedef float SplashCoord;
#else
typedef double SplashCoord;
diff --git a/splash/SplashXPath.cc b/splash/SplashXPath.cc
index 3a939882..cfa065dc 100644
--- a/splash/SplashXPath.cc
+++ b/splash/SplashXPath.cc
@@ -293,11 +293,7 @@ void SplashXPath::addCurve(SplashCoord x0, SplashCoord y0,
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;
@@ -337,17 +333,12 @@ void SplashXPath::addCurve(SplashCoord x0, SplashCoord y0,
// 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
@@ -417,21 +408,8 @@ void SplashXPath::addSegment(SplashCoord x0, SplashCoord y0,
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;
More information about the poppler
mailing list