ReactOS  0.4.14-dev-614-gbfd8a84
psfont.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* psfont.c */
4 /* */
5 /* Adobe's code for font instances (body). */
6 /* */
7 /* Copyright 2007-2014 Adobe Systems Incorporated. */
8 /* */
9 /* This software, and all works of authorship, whether in source or */
10 /* object code form as indicated by the copyright notice(s) included */
11 /* herein (collectively, the "Work") is made available, and may only be */
12 /* used, modified, and distributed under the FreeType Project License, */
13 /* LICENSE.TXT. Additionally, subject to the terms and conditions of the */
14 /* FreeType Project License, each contributor to the Work hereby grants */
15 /* to any individual or legal entity exercising permissions granted by */
16 /* the FreeType Project License and this section (hereafter, "You" or */
17 /* "Your") a perpetual, worldwide, non-exclusive, no-charge, */
18 /* royalty-free, irrevocable (except as stated in this section) patent */
19 /* license to make, have made, use, offer to sell, sell, import, and */
20 /* otherwise transfer the Work, where such license applies only to those */
21 /* patent claims licensable by such contributor that are necessarily */
22 /* infringed by their contribution(s) alone or by combination of their */
23 /* contribution(s) with the Work to which such contribution(s) was */
24 /* submitted. If You institute patent litigation against any entity */
25 /* (including a cross-claim or counterclaim in a lawsuit) alleging that */
26 /* the Work or a contribution incorporated within the Work constitutes */
27 /* direct or contributory patent infringement, then any patent licenses */
28 /* granted to You under this License for that Work shall terminate as of */
29 /* the date such litigation is filed. */
30 /* */
31 /* By using, modifying, or distributing the Work you indicate that you */
32 /* have read and understood the terms and conditions of the */
33 /* FreeType Project License as well as those provided in this section, */
34 /* and you accept them fully. */
35 /* */
36 /***************************************************************************/
37 
38 
39 #include <ft2build.h>
40 #include FT_INTERNAL_CALC_H
41 
42 #include "psft.h"
43 
44 #include "psglue.h"
45 #include "psfont.h"
46 #include "pserror.h"
47 #include "psintrp.h"
48 
49 
50  /* Compute a stem darkening amount in character space. */
51  static void
53  CF2_Fixed ppem,
54  CF2_Fixed stemWidth,
55  CF2_Fixed* darkenAmount,
56  CF2_Fixed boldenAmount,
57  FT_Bool stemDarkened,
58  FT_Int* darkenParams )
59  {
60  /*
61  * Total darkening amount is computed in 1000 unit character space
62  * using the modified 5 part curve as Adobe's Avalon rasterizer.
63  * The darkening amount is smaller for thicker stems.
64  * It becomes zero when the stem is thicker than 2.333 pixels.
65  *
66  * By default, we use
67  *
68  * darkenAmount = 0.4 pixels if scaledStem <= 0.5 pixels,
69  * darkenAmount = 0.275 pixels if 1 <= scaledStem <= 1.667 pixels,
70  * darkenAmount = 0 pixel if scaledStem >= 2.333 pixels,
71  *
72  * and piecewise linear in-between:
73  *
74  *
75  * darkening
76  * ^
77  * |
78  * | (x1,y1)
79  * |--------+
80  * | \
81  * | \
82  * | \ (x3,y3)
83  * | +----------+
84  * | (x2,y2) \
85  * | \
86  * | \
87  * | +-----------------
88  * | (x4,y4)
89  * +---------------------------------------------> stem
90  * thickness
91  *
92  *
93  * This corresponds to the following values for the
94  * `darkening-parameters' property:
95  *
96  * (x1, y1) = (500, 400)
97  * (x2, y2) = (1000, 275)
98  * (x3, y3) = (1667, 275)
99  * (x4, y4) = (2333, 0)
100  *
101  */
102 
103  /* Internal calculations are done in units per thousand for */
104  /* convenience. The x axis is scaled stem width in */
105  /* thousandths of a pixel. That is, 1000 is 1 pixel. */
106  /* The y axis is darkening amount in thousandths of a pixel.*/
107  /* In the code, below, dividing by ppem and */
108  /* adjusting for emRatio converts darkenAmount to character */
109  /* space (font units). */
110  CF2_Fixed stemWidthPer1000, scaledStem;
111  FT_Int logBase2;
112 
113 
114  *darkenAmount = 0;
115 
116  if ( boldenAmount == 0 && !stemDarkened )
117  return;
118 
119  /* protect against range problems and divide by zero */
120  if ( emRatio < cf2_doubleToFixed( .01 ) )
121  return;
122 
123  if ( stemDarkened )
124  {
125  FT_Int x1 = darkenParams[0];
126  FT_Int y1 = darkenParams[1];
127  FT_Int x2 = darkenParams[2];
128  FT_Int y2 = darkenParams[3];
129  FT_Int x3 = darkenParams[4];
130  FT_Int y3 = darkenParams[5];
131  FT_Int x4 = darkenParams[6];
132  FT_Int y4 = darkenParams[7];
133 
134 
135  /* convert from true character space to 1000 unit character space; */
136  /* add synthetic emboldening effect */
137 
138  /* `stemWidthPer1000' will not overflow for a legitimate font */
139 
140  stemWidthPer1000 = FT_MulFix( stemWidth + boldenAmount, emRatio );
141 
142  /* `scaledStem' can easily overflow, so we must clamp its maximum */
143  /* value; the test doesn't need to be precise, but must be */
144  /* conservative. The clamp value (default 2333) where */
145  /* `darkenAmount' is zero is well below the overflow value of */
146  /* 32767. */
147  /* */
148  /* FT_MSB computes the integer part of the base 2 logarithm. The */
149  /* number of bits for the product is 1 or 2 more than the sum of */
150  /* logarithms; remembering that the 16 lowest bits of the fraction */
151  /* are dropped this is correct to within a factor of almost 4. */
152  /* For example, 0x80.0000 * 0x80.0000 = 0x4000.0000 is 23+23 and */
153  /* is flagged as possible overflow because 0xFF.FFFF * 0xFF.FFFF = */
154  /* 0xFFFF.FE00 is also 23+23. */
155 
156  logBase2 = FT_MSB( (FT_UInt32)stemWidthPer1000 ) +
157  FT_MSB( (FT_UInt32)ppem );
158 
159  if ( logBase2 >= 46 )
160  /* possible overflow */
161  scaledStem = cf2_intToFixed( x4 );
162  else
163  scaledStem = FT_MulFix( stemWidthPer1000, ppem );
164 
165  /* now apply the darkening parameters */
166 
167  if ( scaledStem < cf2_intToFixed( x1 ) )
168  *darkenAmount = FT_DivFix( cf2_intToFixed( y1 ), ppem );
169 
170  else if ( scaledStem < cf2_intToFixed( x2 ) )
171  {
172  FT_Int xdelta = x2 - x1;
173  FT_Int ydelta = y2 - y1;
174  FT_Int x = stemWidthPer1000 -
175  FT_DivFix( cf2_intToFixed( x1 ), ppem );
176 
177 
178  if ( !xdelta )
179  goto Try_x3;
180 
181  *darkenAmount = FT_MulDiv( x, ydelta, xdelta ) +
182  FT_DivFix( cf2_intToFixed( y1 ), ppem );
183  }
184 
185  else if ( scaledStem < cf2_intToFixed( x3 ) )
186  {
187  Try_x3:
188  {
189  FT_Int xdelta = x3 - x2;
190  FT_Int ydelta = y3 - y2;
191  FT_Int x = stemWidthPer1000 -
192  FT_DivFix( cf2_intToFixed( x2 ), ppem );
193 
194 
195  if ( !xdelta )
196  goto Try_x4;
197 
198  *darkenAmount = FT_MulDiv( x, ydelta, xdelta ) +
199  FT_DivFix( cf2_intToFixed( y2 ), ppem );
200  }
201  }
202 
203  else if ( scaledStem < cf2_intToFixed( x4 ) )
204  {
205  Try_x4:
206  {
207  FT_Int xdelta = x4 - x3;
208  FT_Int ydelta = y4 - y3;
209  FT_Int x = stemWidthPer1000 -
210  FT_DivFix( cf2_intToFixed( x3 ), ppem );
211 
212 
213  if ( !xdelta )
214  goto Use_y4;
215 
216  *darkenAmount = FT_MulDiv( x, ydelta, xdelta ) +
217  FT_DivFix( cf2_intToFixed( y3 ), ppem );
218  }
219  }
220 
221  else
222  {
223  Use_y4:
224  *darkenAmount = FT_DivFix( cf2_intToFixed( y4 ), ppem );
225  }
226 
227  /* use half the amount on each side and convert back to true */
228  /* character space */
229  *darkenAmount = FT_DivFix( *darkenAmount, 2 * emRatio );
230  }
231 
232  /* add synthetic emboldening effect in character space */
233  *darkenAmount += boldenAmount / 2;
234  }
235 
236 
237  /* set up values for the current FontDict and matrix; */
238  /* called for each glyph to be rendered */
239 
240  /* caller's transform is adjusted for subpixel positioning */
241  static void
243  const CF2_Matrix* transform )
244  {
245  /* pointer to parsed font object */
246  PS_Decoder* decoder = font->decoder;
247 
248  FT_Bool needExtraSetup = FALSE;
249 
250  CFF_VStoreRec* vstore;
251  FT_Bool hasVariations = FALSE;
252 
253  /* character space units */
254  CF2_Fixed boldenX = font->syntheticEmboldeningAmountX;
255  CF2_Fixed boldenY = font->syntheticEmboldeningAmountY;
256 
257  CFF_SubFont subFont;
258  CF2_Fixed ppem;
259 
260  CF2_UInt lenNormalizedV = 0;
261  FT_Fixed* normalizedV = NULL;
262 
263  /* clear previous error */
264  font->error = FT_Err_Ok;
265 
266  /* if a CID fontDict has changed, we need to recompute some cached */
267  /* data */
268  subFont = cf2_getSubfont( decoder );
269  if ( font->lastSubfont != subFont )
270  {
271  font->lastSubfont = subFont;
272  needExtraSetup = TRUE;
273  }
274 
275  if ( !font->isT1 )
276  {
277  FT_Service_CFFLoad cffload = (FT_Service_CFFLoad)font->cffload;
278 
279 
280  /* check for variation vectors */
281  vstore = cf2_getVStore( decoder );
282  hasVariations = ( vstore->dataCount != 0 );
283 
284  if ( hasVariations )
285  {
286 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
287  /* check whether Private DICT in this subfont needs to be reparsed */
288  font->error = cf2_getNormalizedVector( decoder,
289  &lenNormalizedV,
290  &normalizedV );
291  if ( font->error )
292  return;
293 
294  if ( cffload->blend_check_vector( &subFont->blend,
295  subFont->private_dict.vsindex,
296  lenNormalizedV,
297  normalizedV ) )
298  {
299  /* blend has changed, reparse */
300  cffload->load_private_dict( decoder->cff,
301  subFont,
302  lenNormalizedV,
303  normalizedV );
304  needExtraSetup = TRUE;
305  }
306 #endif
307 
308  /* copy from subfont */
309  font->blend.font = subFont->blend.font;
310 
311  /* clear state of charstring blend */
312  font->blend.usedBV = FALSE;
313 
314  /* initialize value for charstring */
315  font->vsindex = subFont->private_dict.vsindex;
316 
317  /* store vector inputs for blends in charstring */
318  font->lenNDV = lenNormalizedV;
319  font->NDV = normalizedV;
320  }
321  }
322 
323  /* if ppem has changed, we need to recompute some cached data */
324  /* note: because of CID font matrix concatenation, ppem and transform */
325  /* do not necessarily track. */
326  ppem = cf2_getPpemY( decoder );
327  if ( font->ppem != ppem )
328  {
329  font->ppem = ppem;
330  needExtraSetup = TRUE;
331  }
332 
333  /* copy hinted flag on each call */
334  font->hinted = (FT_Bool)( font->renderingFlags & CF2_FlagsHinted );
335 
336  /* determine if transform has changed; */
337  /* include Fontmatrix but ignore translation */
338  if ( ft_memcmp( transform,
339  &font->currentTransform,
340  4 * sizeof ( CF2_Fixed ) ) != 0 )
341  {
342  /* save `key' information for `cache of one' matrix data; */
343  /* save client transform, without the translation */
344  font->currentTransform = *transform;
345  font->currentTransform.tx =
346  font->currentTransform.ty = cf2_intToFixed( 0 );
347 
348  /* TODO: FreeType transform is simple scalar; for now, use identity */
349  /* for outer */
350  font->innerTransform = *transform;
351  font->outerTransform.a =
352  font->outerTransform.d = cf2_intToFixed( 1 );
353  font->outerTransform.b =
354  font->outerTransform.c = cf2_intToFixed( 0 );
355 
356  needExtraSetup = TRUE;
357  }
358 
359  /*
360  * font->darkened is set to true if there is a stem darkening request or
361  * the font is synthetic emboldened.
362  * font->darkened controls whether to adjust blue zones, winding order,
363  * and hinting.
364  *
365  */
366  if ( font->stemDarkened != ( font->renderingFlags & CF2_FlagsDarkened ) )
367  {
368  font->stemDarkened =
369  (FT_Bool)( font->renderingFlags & CF2_FlagsDarkened );
370 
371  /* blue zones depend on darkened flag */
372  needExtraSetup = TRUE;
373  }
374 
375  /* recompute variables that are dependent on transform or FontDict or */
376  /* darken flag */
377  if ( needExtraSetup )
378  {
379  /* StdVW is found in the private dictionary; */
380  /* recompute darkening amounts whenever private dictionary or */
381  /* transform change */
382  /* Note: a rendering flag turns darkening on or off, so we want to */
383  /* store the `on' amounts; */
384  /* darkening amount is computed in character space */
385  /* TODO: testing size-dependent darkening here; */
386  /* what to do for rotations? */
387 
388  CF2_Fixed emRatio;
389  CF2_Fixed stdHW;
390  CF2_Int unitsPerEm = font->unitsPerEm;
391 
392 
393  if ( unitsPerEm == 0 )
394  unitsPerEm = 1000;
395 
396  ppem = FT_MAX( cf2_intToFixed( 4 ),
397  font->ppem ); /* use minimum ppem of 4 */
398 
399 #if 0
400  /* since vstem is measured in the x-direction, we use the `a' member */
401  /* of the fontMatrix */
402  emRatio = cf2_fixedFracMul( cf2_intToFixed( 1000 ), fontMatrix->a );
403 #endif
404 
405  /* Freetype does not preserve the fontMatrix when parsing; use */
406  /* unitsPerEm instead. */
407  /* TODO: check precision of this */
408  emRatio = cf2_intToFixed( 1000 ) / unitsPerEm;
409  font->stdVW = cf2_getStdVW( decoder );
410 
411  if ( font->stdVW <= 0 )
412  font->stdVW = FT_DivFix( cf2_intToFixed( 75 ), emRatio );
413 
414  if ( boldenX > 0 )
415  {
416  /* Ensure that boldenX is at least 1 pixel for synthetic bold font */
417  /* (similar to what Avalon does) */
418  boldenX = FT_MAX( boldenX,
419  FT_DivFix( cf2_intToFixed( unitsPerEm ), ppem ) );
420 
421  /* Synthetic emboldening adds at least 1 pixel to darkenX, while */
422  /* stem darkening adds at most half pixel. Since the purpose of */
423  /* stem darkening (readability at small sizes) is met with */
424  /* synthetic emboldening, no need to add stem darkening for a */
425  /* synthetic bold font. */
426  cf2_computeDarkening( emRatio,
427  ppem,
428  font->stdVW,
429  &font->darkenX,
430  boldenX,
431  FALSE,
432  font->darkenParams );
433  }
434  else
435  cf2_computeDarkening( emRatio,
436  ppem,
437  font->stdVW,
438  &font->darkenX,
439  0,
440  font->stemDarkened,
441  font->darkenParams );
442 
443 #if 0
444  /* since hstem is measured in the y-direction, we use the `d' member */
445  /* of the fontMatrix */
446  /* TODO: use the same units per em as above; check this */
447  emRatio = cf2_fixedFracMul( cf2_intToFixed( 1000 ), fontMatrix->d );
448 #endif
449 
450  /* set the default stem width, because it must be the same for all */
451  /* family members; */
452  /* choose a constant for StdHW that depends on font contrast */
453  stdHW = cf2_getStdHW( decoder );
454 
455  if ( stdHW > 0 && font->stdVW > MUL_INT32( 2, stdHW ) )
456  font->stdHW = FT_DivFix( cf2_intToFixed( 75 ), emRatio );
457  else
458  {
459  /* low contrast font gets less hstem darkening */
460  font->stdHW = FT_DivFix( cf2_intToFixed( 110 ), emRatio );
461  }
462 
463  cf2_computeDarkening( emRatio,
464  ppem,
465  font->stdHW,
466  &font->darkenY,
467  boldenY,
468  font->stemDarkened,
469  font->darkenParams );
470 
471  if ( font->darkenX != 0 || font->darkenY != 0 )
472  font->darkened = TRUE;
473  else
474  font->darkened = FALSE;
475 
476  font->reverseWinding = FALSE; /* initial expectation is CCW */
477 
478  /* compute blue zones for this instance */
479  cf2_blues_init( &font->blues, font );
480 
481  } /* needExtraSetup */
482  }
483 
484 
485  /* equivalent to AdobeGetOutline */
488  CF2_Buffer charstring,
490  CF2_F16Dot16* glyphWidth )
491  {
492  FT_Error lastError = FT_Err_Ok;
493 
494  FT_Vector translation;
495 
496 #if 0
497  FT_Vector advancePoint;
498 #endif
499 
500  CF2_Fixed advWidth = 0;
501  FT_Bool needWinding;
502 
503 
504  /* Note: use both integer and fraction for outlines. This allows bbox */
505  /* to come out directly. */
506 
507  translation.x = transform->tx;
508  translation.y = transform->ty;
509 
510  /* set up values based on transform */
512  if ( font->error )
513  goto exit; /* setup encountered an error */
514 
515  /* reset darken direction */
516  font->reverseWinding = FALSE;
517 
518  /* winding order only affects darkening */
519  needWinding = font->darkened;
520 
521  while ( 1 )
522  {
523  /* reset output buffer */
524  cf2_outline_reset( &font->outline );
525 
526  /* build the outline, passing the full translation */
528  charstring,
529  (CF2_OutlineCallbacks)&font->outline,
530  &translation,
531  FALSE,
532  0,
533  0,
534  &advWidth );
535 
536  if ( font->error )
537  goto exit;
538 
539  if ( !needWinding )
540  break;
541 
542  /* check winding order */
543  if ( font->outline.root.windingMomentum >= 0 ) /* CFF is CCW */
544  break;
545 
546  /* invert darkening and render again */
547  /* TODO: this should be a parameter to getOutline-computeOffset */
548  font->reverseWinding = TRUE;
549 
550  needWinding = FALSE; /* exit after next iteration */
551  }
552 
553  /* finish storing client outline */
554  cf2_outline_close( &font->outline );
555 
556  exit:
557  /* FreeType just wants the advance width; there is no translation */
558  *glyphWidth = advWidth;
559 
560  /* free resources and collect errors from objects we've used */
561  cf2_setError( &font->error, lastError );
562 
563  return font->error;
564  }
565 
566 
567 /* END */
#define CF2_UInt
Definition: pstypes.h:64
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG y1
Definition: winddi.h:3706
FT_BEGIN_HEADER struct CF2_BufferRec_ * CF2_Buffer
int FT_Error
Definition: fttypes.h:300
cf2_getPpemY(PS_Decoder *decoder)
Definition: psft.c:504
FT_DivFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:608
FT_Int32 CF2_F16Dot16
Definition: pstypes.h:69
FT_Pos y
Definition: ftimage.h:77
#define TRUE
Definition: types.h:120
CFF_Font font
Definition: cfftypes.h:170
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
cf2_getGlyphOutline(CF2_Font font, CF2_Buffer charstring, const CF2_Matrix *transform, CF2_F16Dot16 *glyphWidth)
Definition: psfont.c:487
FT_UInt vsindex
Definition: cfftypes.h:273
Definition: mk_font.cpp:20
FT_Pos x
Definition: ftimage.h:76
signed int FT_Int
Definition: fttypes.h:220
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
cf2_getStdVW(PS_Decoder *decoder)
Definition: psft.c:528
#define CF2_FlagsHinted
Definition: psglue.h:56
#define MUL_INT32(a, b)
Definition: ftcalc.h:433
#define cf2_intToFixed(i)
Definition: psfixed.h:60
cf2_outline_close(CF2_Outline outline)
Definition: psft.c:877
cf2_setError(FT_Error *error, FT_Error value)
Definition: pserror.c:44
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
return FT_Err_Ok
Definition: ftbbox.c:511
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
cf2_interpT2CharString(CF2_Font font, CF2_Buffer buf, CF2_OutlineCallbacks callbacks, const FT_Vector *translation, FT_Bool doingSeac, CF2_Fixed curX, CF2_Fixed curY, CF2_Fixed *width)
Definition: psintrp.c:471
cf2_blues_init(CF2_Blues blues, CF2_Font font)
Definition: psblues.c:66
smooth NULL
Definition: ftsmooth.c:416
cf2_outline_reset(CF2_Outline outline)
Definition: psft.c:863
CFF_PrivateRec private_dict
Definition: cfftypes.h:301
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:388
static void cf2_font_setup(CF2_Font font, const CF2_Matrix *transform)
Definition: psfont.c:242
FT_MulDiv(FT_Long a, FT_Long b, FT_Long c)
Definition: ftcalc.c:416
#define FT_MAX(a, b)
Definition: ftobjs.h:72
cf2_getVStore(PS_Decoder *decoder)
Definition: psft.c:458
cf2_getStdHW(PS_Decoder *decoder)
Definition: psft.c:538
CFF_BlendRec blend
Definition: cfftypes.h:304
FT_MSB(FT_UInt32 z)
Definition: ftcalc.c:114
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG _In_ LONG y2
Definition: winddi.h:3706
#define cf2_doubleToFixed(f)
Definition: psfixed.h:66
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:509
#define CF2_FlagsDarkened
Definition: psglue.h:58
signed long FT_Fixed
Definition: fttypes.h:288
#define ft_memcmp
Definition: ftstdlib.h:81
#define CF2_Int
Definition: pstypes.h:65
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706
cf2_getSubfont(PS_Decoder *decoder)
Definition: psft.c:448
static void cf2_computeDarkening(CF2_Fixed emRatio, CF2_Fixed ppem, CF2_Fixed stemWidth, CF2_Fixed *darkenAmount, CF2_Fixed boldenAmount, FT_Bool stemDarkened, FT_Int *darkenParams)
Definition: psfont.c:52
CFF_Font cff
Definition: psaux.h:613
#define const
Definition: zconf.h:230
GLuint GLenum GLenum transform
Definition: glext.h:9407
void exit(int exitcode)
Definition: _exit.c:33
FT_UInt dataCount
Definition: cfftypes.h:141
#define CF2_Fixed
Definition: psfixed.h:48