1 //========================================================================
2 //
3 // SplashT1Font.cc
4 //
5 //========================================================================
6
7 //========================================================================
8 //
9 // Modified under the Poppler project - http://poppler.freedesktop.org
10 //
11 // All changes made under the Poppler project to this file are licensed
12 // under GPL version 2 or later
13 //
14 // Copyright (C) 2007 Albert Astals Cid <aacid@kde.org>
15 //
16 // To see a description of the changes please see the Changelog file that
17 // came with your tarball or type make ChangeLog if you are building from git
18 //
19 //========================================================================
20
21 #include <config.h>
22
23 #if HAVE_T1LIB_H
24
25 #ifdef USE_GCC_PRAGMAS
26 #pragma implementation
27 #endif
28
29 #include <stdlib.h>
30 #include <t1lib.h>
31 #include "goo/gmem.h"
32 #include "SplashMath.h"
33 #include "SplashGlyphBitmap.h"
34 #include "SplashPath.h"
35 #include "SplashT1FontEngine.h"
36 #include "SplashT1FontFile.h"
37 #include "SplashT1Font.h"
38
39 //------------------------------------------------------------------------
40
41 static Guchar bitReverse[256] = {
42 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
43 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
44 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
45 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
46 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
47 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
48 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
49 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
50 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
51 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
52 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
53 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
54 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
55 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
56 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
57 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
58 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
59 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
60 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
61 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
62 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
63 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
64 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
65 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
66 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
67 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
68 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
69 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
70 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
71 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
72 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
73 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
74 };
75
76 //------------------------------------------------------------------------
77 // SplashT1Font
78 //------------------------------------------------------------------------
79
SplashT1Font(SplashT1FontFile * fontFileA,SplashCoord * matA,SplashCoord * textMatA)80 SplashT1Font::SplashT1Font(SplashT1FontFile *fontFileA, SplashCoord *matA,
81 SplashCoord *textMatA):
82 SplashFont(fontFileA, matA, textMatA, fontFileA->engine->aa)
83 {
84 T1_TMATRIX matrix;
85 BBox bbox;
86 SplashCoord bbx0, bby0, bbx1, bby1;
87 int x, y;
88
89 t1libID = T1_CopyFont(fontFileA->t1libID);
90 outlineID = -1;
91
92 // compute font size
93 size = (float)splashDist(0, 0, mat[2], mat[3]);
94
95 // transform the four corners of the font bounding box -- the min
96 // and max values form the bounding box of the transformed font
97 bbox = T1_GetFontBBox(t1libID);
98 bbx0 = 0.001 * bbox.llx;
99 bby0 = 0.001 * bbox.lly;
100 bbx1 = 0.001 * bbox.urx;
101 bby1 = 0.001 * bbox.ury;
102 // some fonts are completely broken, so we fake it (with values
103 // large enough that most glyphs should fit)
104 if (bbx0 == 0 && bby0 == 0 && bbx1 == 0 && bby1 == 0) {
105 bbx0 = bby0 = -0.5;
106 bbx1 = bby1 = 1.5;
107 }
108 x = (int)(mat[0] * bbx0 + mat[2] * bby0);
109 xMin = xMax = x;
110 y = (int)(mat[1] * bbx0 + mat[3] * bby0);
111 yMin = yMax = y;
112 x = (int)(mat[0] * bbx0 + mat[2] * bby1);
113 if (x < xMin) {
114 xMin = x;
115 } else if (x > xMax) {
116 xMax = x;
117 }
118 y = (int)(mat[1] * bbx0 + mat[3] * bby1);
119 if (y < yMin) {
120 yMin = y;
121 } else if (y > yMax) {
122 yMax = y;
123 }
124 x = (int)(mat[0] * bbx1 + mat[2] * bby0);
125 if (x < xMin) {
126 xMin = x;
127 } else if (x > xMax) {
128 xMax = x;
129 }
130 y = (int)(mat[1] * bbx1 + mat[3] * bby0);
131 if (y < yMin) {
132 yMin = y;
133 } else if (y > yMax) {
134 yMax = y;
135 }
136 x = (int)(mat[0] * bbx1 + mat[2] * bby1);
137 if (x < xMin) {
138 xMin = x;
139 } else if (x > xMax) {
140 xMax = x;
141 }
142 y = (int)(mat[1] * bbx1 + mat[3] * bby1);
143 if (y < yMin) {
144 yMin = y;
145 } else if (y > yMax) {
146 yMax = y;
147 }
148 // This is a kludge: some buggy PDF generators embed fonts with
149 // zero bounding boxes.
150 if (xMax == xMin) {
151 xMin = 0;
152 xMax = (int)size;
153 }
154 if (yMax == yMin) {
155 yMin = 0;
156 yMax = (int)(1.2 * size);
157 }
158 // Another kludge: an unusually large xMin or yMin coordinate is
159 // probably wrong.
160 if (xMin > 0) {
161 xMin = 0;
162 }
163 if (yMin > 0) {
164 yMin = 0;
165 }
166 // Another kludge: t1lib doesn't correctly handle fonts with
167 // real (non-integer) bounding box coordinates.
168 if (xMax - xMin > 5000) {
169 xMin = 0;
170 xMax = (int)size;
171 }
172 if (yMax - yMin > 5000) {
173 yMin = 0;
174 yMax = (int)(1.2 * size);
175 }
176
177 // transform the font
178 matrix.cxx = (double)mat[0] / size;
179 matrix.cxy = (double)mat[1] / size;
180 matrix.cyx = (double)mat[2] / size;
181 matrix.cyy = (double)mat[3] / size;
182 T1_TransformFont(t1libID, &matrix);
183 }
184
~SplashT1Font()185 SplashT1Font::~SplashT1Font() {
186 T1_DeleteFont(t1libID);
187 if (outlineID >= 0) {
188 T1_DeleteFont(outlineID);
189 }
190 }
191
getGlyph(int c,int xFrac,int yFrac,SplashGlyphBitmap * bitmap,int x0,int y0,SplashClip * clip,SplashClipResult * clipRes)192 GBool SplashT1Font::getGlyph(int c, int xFrac, int yFrac,
193 SplashGlyphBitmap *bitmap, int x0, int y0, SplashClip *clip, SplashClipResult *clipRes) {
194 return SplashFont::getGlyph(c, 0, 0, bitmap, x0, y0, clip, clipRes);
195 }
196
makeGlyph(int c,int xFrac,int yFrac,SplashGlyphBitmap * bitmap,int x0,int y0,SplashClip * clip,SplashClipResult * clipRes)197 GBool SplashT1Font::makeGlyph(int c, int xFrac, int yFrac,
198 SplashGlyphBitmap *bitmap, int x0, int y0, SplashClip *clip, SplashClipResult *clipRes) {
199 GLYPH *glyph;
200 int n, i;
201
202 if (aa) {
203 glyph = T1_AASetChar(t1libID, c, size, NULL);
204 } else {
205 glyph = T1_SetChar(t1libID, c, size, NULL);
206 }
207 if (!glyph) {
208 return gFalse;
209 }
210
211 bitmap->x = -glyph->metrics.leftSideBearing;
212 bitmap->y = glyph->metrics.ascent;
213 bitmap->w = glyph->metrics.rightSideBearing - glyph->metrics.leftSideBearing;
214 bitmap->h = glyph->metrics.ascent - glyph->metrics.descent;
215 bitmap->aa = aa;
216 if (aa) {
217 bitmap->data = (Guchar *)glyph->bits;
218 bitmap->freeData = gFalse;
219 } else {
220 n = bitmap->h * ((bitmap->w + 7) >> 3);
221 bitmap->data = (Guchar *)gmalloc(n);
222 for (i = 0; i < n; ++i) {
223 bitmap->data[i] = bitReverse[glyph->bits[i] & 0xff];
224 }
225 bitmap->freeData = gTrue;
226 }
227
228 *clipRes = clip->testRect(x0 - bitmap->x,
229 y0 - bitmap->y,
230 x0 - bitmap->x + bitmap->w - 1,
231 y0 - bitmap->y + bitmap->h - 1);
232
233 return gTrue;
234 }
235
getGlyphPath(int c)236 SplashPath *SplashT1Font::getGlyphPath(int c) {
237 T1_TMATRIX matrix;
238 SplashPath *path;
239 T1_OUTLINE *outline;
240 T1_PATHSEGMENT *seg;
241 T1_BEZIERSEGMENT *bez;
242 int x, y, x1, y1;
243 GBool needClose;
244
245 if (outlineID < 0) {
246 outlineID = T1_CopyFont(((SplashT1FontFile *)fontFile)->t1libID);
247 outlineSize = (float)splashDist(0, 0, textMat[2], textMat[3]);
248 matrix.cxx = (double)textMat[0] / outlineSize;
249 matrix.cxy = (double)textMat[1] / outlineSize;
250 matrix.cyx = (double)textMat[2] / outlineSize;
251 matrix.cyy = (double)textMat[3] / outlineSize;
252 // t1lib doesn't seem to handle small sizes correctly here, so set
253 // the size to 1000, and scale the resulting coordinates later
254 outlineMul = (float)(outlineSize / 65536000.0);
255 outlineSize = 1000;
256 T1_TransformFont(outlineID, &matrix);
257 }
258
259 path = new SplashPath();
260 if ((outline = T1_GetCharOutline(outlineID, c, outlineSize, NULL))) {
261 // NB: t1lib uses integer coordinates here; we keep a running
262 // (x,y) total as integers, so that the final point in the path is
263 // exactly the same as the first point, thus avoiding weird
264 // mitered join glitches
265 x = y = 0;
266 needClose = gFalse;
267 for (seg = outline; seg; seg = seg->link) {
268 switch (seg->type) {
269 case T1_PATHTYPE_MOVE:
270 if (needClose) {
271 path->close();
272 needClose = gFalse;
273 }
274 x += seg->dest.x;
275 y += seg->dest.y;
276 path->moveTo(outlineMul * x, -outlineMul * y);
277 break;
278 case T1_PATHTYPE_LINE:
279 x += seg->dest.x;
280 y += seg->dest.y;
281 path->lineTo(outlineMul * x, -outlineMul * y);
282 needClose = gTrue;
283 break;
284 case T1_PATHTYPE_BEZIER:
285 bez = (T1_BEZIERSEGMENT *)seg;
286 x1 = x + bez->dest.x;
287 y1 = y + bez->dest.y;
288 path->curveTo(outlineMul * (x + bez->B.x),
289 -outlineMul * (y + bez->B.y),
290 outlineMul * (x + bez->C.x),
291 -outlineMul * (y + bez->C.y),
292 outlineMul * x1,
293 -outlineMul * y1);
294 x = x1;
295 y = y1;
296 needClose = gTrue;
297 break;
298 }
299 }
300 if (needClose) {
301 path->close();
302 }
303 T1_FreeOutline(outline);
304 }
305
306 return path;
307 }
308
309 #endif // HAVE_T1LIB_H
310