| File: | ./freetype/psfont.c |
| Warning: | line 277, column 27 Value stored to 'cffload' during its initialization is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 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"ftcalc.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 |
| 52 | cf2_computeDarkening( CF2_FixedCF2_F16Dot16 emRatio, |
| 53 | CF2_FixedCF2_F16Dot16 ppem, |
| 54 | CF2_FixedCF2_F16Dot16 stemWidth, |
| 55 | CF2_FixedCF2_F16Dot16* darkenAmount, |
| 56 | CF2_FixedCF2_F16Dot16 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_FixedCF2_F16Dot16 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 )( (CF2_F16Dot16)( (.01) * 65536.0 + 0.5 ) ) ) |
| 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 )FT_MulFix_x86_64( (FT_Int32)(stemWidth + boldenAmount), (FT_Int32 )(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 )( 31 - __builtin_clz( (FT_UInt32)stemWidthPer1000 ) ) + |
| 157 | FT_MSB( (FT_UInt32)ppem )( 31 - __builtin_clz( (FT_UInt32)ppem ) ); |
| 158 | |
| 159 | if ( logBase2 >= 46 ) |
| 160 | /* possible overflow */ |
| 161 | scaledStem = cf2_intToFixed( x4 )( (CF2_F16Dot16)( (FT_UInt32)(x4) << 16 ) ); |
| 162 | else |
| 163 | scaledStem = FT_MulFix( stemWidthPer1000, ppem )FT_MulFix_x86_64( (FT_Int32)(stemWidthPer1000), (FT_Int32)(ppem ) ); |
| 164 | |
| 165 | /* now apply the darkening parameters */ |
| 166 | |
| 167 | if ( scaledStem < cf2_intToFixed( x1 )( (CF2_F16Dot16)( (FT_UInt32)(x1) << 16 ) ) ) |
| 168 | *darkenAmount = FT_DivFix( cf2_intToFixed( y1 )( (CF2_F16Dot16)( (FT_UInt32)(y1) << 16 ) ), ppem ); |
| 169 | |
| 170 | else if ( scaledStem < cf2_intToFixed( x2 )( (CF2_F16Dot16)( (FT_UInt32)(x2) << 16 ) ) ) |
| 171 | { |
| 172 | FT_Int xdelta = x2 - x1; |
| 173 | FT_Int ydelta = y2 - y1; |
| 174 | FT_Int x = stemWidthPer1000 - |
| 175 | FT_DivFix( cf2_intToFixed( x1 )( (CF2_F16Dot16)( (FT_UInt32)(x1) << 16 ) ), ppem ); |
| 176 | |
| 177 | |
| 178 | if ( !xdelta ) |
| 179 | goto Try_x3; |
| 180 | |
| 181 | *darkenAmount = FT_MulDiv( x, ydelta, xdelta ) + |
| 182 | FT_DivFix( cf2_intToFixed( y1 )( (CF2_F16Dot16)( (FT_UInt32)(y1) << 16 ) ), ppem ); |
| 183 | } |
| 184 | |
| 185 | else if ( scaledStem < cf2_intToFixed( x3 )( (CF2_F16Dot16)( (FT_UInt32)(x3) << 16 ) ) ) |
| 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 )( (CF2_F16Dot16)( (FT_UInt32)(x2) << 16 ) ), ppem ); |
| 193 | |
| 194 | |
| 195 | if ( !xdelta ) |
| 196 | goto Try_x4; |
| 197 | |
| 198 | *darkenAmount = FT_MulDiv( x, ydelta, xdelta ) + |
| 199 | FT_DivFix( cf2_intToFixed( y2 )( (CF2_F16Dot16)( (FT_UInt32)(y2) << 16 ) ), ppem ); |
| 200 | } |
| 201 | } |
| 202 | |
| 203 | else if ( scaledStem < cf2_intToFixed( x4 )( (CF2_F16Dot16)( (FT_UInt32)(x4) << 16 ) ) ) |
| 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 )( (CF2_F16Dot16)( (FT_UInt32)(x3) << 16 ) ), ppem ); |
| 211 | |
| 212 | |
| 213 | if ( !xdelta ) |
| 214 | goto Use_y4; |
| 215 | |
| 216 | *darkenAmount = FT_MulDiv( x, ydelta, xdelta ) + |
| 217 | FT_DivFix( cf2_intToFixed( y3 )( (CF2_F16Dot16)( (FT_UInt32)(y3) << 16 ) ), ppem ); |
| 218 | } |
| 219 | } |
| 220 | |
| 221 | else |
| 222 | { |
| 223 | Use_y4: |
| 224 | *darkenAmount = FT_DivFix( cf2_intToFixed( y4 )( (CF2_F16Dot16)( (FT_UInt32)(y4) << 16 ) ), 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 |
| 242 | cf2_font_setup( CF2_Font font, |
| 243 | const CF2_Matrix* transform ) |
| 244 | { |
| 245 | /* pointer to parsed font object */ |
| 246 | PS_Decoder* decoder = font->decoder; |
| 247 | |
| 248 | FT_Bool needExtraSetup = FALSE0; |
| 249 | |
| 250 | CFF_VStoreRec* vstore; |
| 251 | FT_Bool hasVariations = FALSE0; |
| 252 | |
| 253 | /* character space units */ |
| 254 | CF2_FixedCF2_F16Dot16 boldenX = font->syntheticEmboldeningAmountX; |
| 255 | CF2_FixedCF2_F16Dot16 boldenY = font->syntheticEmboldeningAmountY; |
| 256 | |
| 257 | CFF_SubFont subFont; |
| 258 | CF2_FixedCF2_F16Dot16 ppem; |
| 259 | |
| 260 | CF2_UIntFT_UFast lenNormalizedV = 0; |
| 261 | FT_Fixed* normalizedV = NULL((void*)0); |
| 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 = TRUE1; |
| 273 | } |
| 274 | |
| 275 | if ( !font->isT1 ) |
| 276 | { |
| 277 | FT_Service_CFFLoad cffload = (FT_Service_CFFLoad)font->cffload; |
Value stored to 'cffload' during its initialization is never read | |
| 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 = TRUE1; |
| 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 = FALSE0; |
| 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 = TRUE1; |
| 331 | } |
| 332 | |
| 333 | /* copy hinted flag on each call */ |
| 334 | font->hinted = (FT_Bool)( font->renderingFlags & CF2_FlagsHinted1 ); |
| 335 | |
| 336 | /* determine if transform has changed; */ |
| 337 | /* include Fontmatrix but ignore translation */ |
| 338 | if ( ft_memcmpmemcmp( transform, |
| 339 | &font->currentTransform, |
| 340 | 4 * sizeof ( CF2_FixedCF2_F16Dot16 ) ) != 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 )( (CF2_F16Dot16)( (FT_UInt32)(0) << 16 ) ); |
| 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 )( (CF2_F16Dot16)( (FT_UInt32)(1) << 16 ) ); |
| 353 | font->outerTransform.b = |
| 354 | font->outerTransform.c = cf2_intToFixed( 0 )( (CF2_F16Dot16)( (FT_UInt32)(0) << 16 ) ); |
| 355 | |
| 356 | needExtraSetup = TRUE1; |
| 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_FlagsDarkened2 ) ) |
| 367 | { |
| 368 | font->stemDarkened = |
| 369 | (FT_Bool)( font->renderingFlags & CF2_FlagsDarkened2 ); |
| 370 | |
| 371 | /* blue zones depend on darkened flag */ |
| 372 | needExtraSetup = TRUE1; |
| 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_FixedCF2_F16Dot16 emRatio; |
| 389 | CF2_FixedCF2_F16Dot16 stdHW; |
| 390 | CF2_IntFT_Fast unitsPerEm = font->unitsPerEm; |
| 391 | |
| 392 | |
| 393 | if ( unitsPerEm == 0 ) |
| 394 | unitsPerEm = 1000; |
| 395 | |
| 396 | ppem = FT_MAX( cf2_intToFixed( 4 ),( (( (CF2_F16Dot16)( (FT_UInt32)(4) << 16 ) )) > (font ->ppem) ? (( (CF2_F16Dot16)( (FT_UInt32)(4) << 16 ) ) ) : (font->ppem) ) |
| 397 | font->ppem )( (( (CF2_F16Dot16)( (FT_UInt32)(4) << 16 ) )) > (font ->ppem) ? (( (CF2_F16Dot16)( (FT_UInt32)(4) << 16 ) ) ) : (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 )( (CF2_F16Dot16)( (FT_UInt32)(1000) << 16 ) ), 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 )( (CF2_F16Dot16)( (FT_UInt32)(1000) << 16 ) ) / unitsPerEm; |
| 409 | font->stdVW = cf2_getStdVW( decoder ); |
| 410 | |
| 411 | if ( font->stdVW <= 0 ) |
| 412 | font->stdVW = FT_DivFix( cf2_intToFixed( 75 )( (CF2_F16Dot16)( (FT_UInt32)(75) << 16 ) ), 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,( (boldenX) > (FT_DivFix( ( (CF2_F16Dot16)( (FT_UInt32)(unitsPerEm ) << 16 ) ), ppem )) ? (boldenX) : (FT_DivFix( ( (CF2_F16Dot16 )( (FT_UInt32)(unitsPerEm) << 16 ) ), ppem )) ) |
| 419 | FT_DivFix( cf2_intToFixed( unitsPerEm ), ppem ) )( (boldenX) > (FT_DivFix( ( (CF2_F16Dot16)( (FT_UInt32)(unitsPerEm ) << 16 ) ), ppem )) ? (boldenX) : (FT_DivFix( ( (CF2_F16Dot16 )( (FT_UInt32)(unitsPerEm) << 16 ) ), 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 | FALSE0, |
| 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 )( (CF2_F16Dot16)( (FT_UInt32)(1000) << 16 ) ), 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 )(FT_Int32)( (FT_UInt32)(2) * (FT_UInt32)(stdHW) ) ) |
| 456 | font->stdHW = FT_DivFix( cf2_intToFixed( 75 )( (CF2_F16Dot16)( (FT_UInt32)(75) << 16 ) ), emRatio ); |
| 457 | else |
| 458 | { |
| 459 | /* low contrast font gets less hstem darkening */ |
| 460 | font->stdHW = FT_DivFix( cf2_intToFixed( 110 )( (CF2_F16Dot16)( (FT_UInt32)(110) << 16 ) ), 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 = TRUE1; |
| 473 | else |
| 474 | font->darkened = FALSE0; |
| 475 | |
| 476 | font->reverseWinding = FALSE0; /* 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 */ |
| 486 | FT_LOCAL_DEF( FT_Error )static FT_Error |
| 487 | cf2_getGlyphOutline( CF2_Font font, |
| 488 | CF2_Buffer charstring, |
| 489 | const CF2_Matrix* transform, |
| 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_FixedCF2_F16Dot16 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 */ |
| 511 | cf2_font_setup( font, transform ); |
| 512 | if ( font->error ) |
| 513 | goto exit; /* setup encountered an error */ |
| 514 | |
| 515 | /* reset darken direction */ |
| 516 | font->reverseWinding = FALSE0; |
| 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 */ |
| 527 | cf2_interpT2CharString( font, |
| 528 | charstring, |
| 529 | (CF2_OutlineCallbacks)&font->outline, |
| 530 | &translation, |
| 531 | FALSE0, |
| 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 = TRUE1; |
| 549 | |
| 550 | needWinding = FALSE0; /* 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 */ |