1/****************************************************************************
2 *
3 * pshints.c
4 *
5 * Adobe's code for handling CFF hints (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 "psft.h"
40#include <freetype/internal/ftdebug.h>
41
42#include "psglue.h"
43#include "psfont.h"
44#include "pshints.h"
45#include "psintrp.h"
46
47
48 /**************************************************************************
49 *
50 * The macro FT_COMPONENT is used in trace mode. It is an implicit
51 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
52 * messages during execution.
53 */
54#undef FT_COMPONENT
55#define FT_COMPONENT cf2hints
56
57
58 typedef struct CF2_HintMoveRec_
59 {
60 size_t j; /* index of upper hint map edge */
61 CF2_Fixed moveUp; /* adjustment to optimum position */
62
63 } CF2_HintMoveRec, *CF2_HintMove;
64
65
66 /* Compute angular momentum for winding order detection. It is called */
67 /* for all lines and curves, but not necessarily in element order. */
68 static CF2_Int
69 cf2_getWindingMomentum( CF2_Fixed x1,
70 CF2_Fixed y1,
71 CF2_Fixed x2,
72 CF2_Fixed y2 )
73 {
74 /* cross product of pt1 position from origin with pt2 position from */
75 /* pt1; we reduce the precision so that the result fits into 32 bits */
76
77 return ( x1 >> 16 ) * ( SUB_INT32( y2, y1 ) >> 16 ) -
78 ( y1 >> 16 ) * ( SUB_INT32( x2, x1 ) >> 16 );
79 }
80
81
82 /*
83 * Construct from a StemHint; this is used as a parameter to
84 * `cf2_blues_capture'.
85 * `hintOrigin' is the character space displacement of a seac accent.
86 * Adjust stem hint for darkening here.
87 *
88 */
89 static void
90 cf2_hint_init( CF2_Hint hint,
91 const CF2_ArrStack stemHintArray,
92 size_t indexStemHint,
93 const CF2_Font font,
94 CF2_Fixed hintOrigin,
95 CF2_Fixed scale,
96 FT_Bool bottom )
97 {
98 CF2_Fixed width;
99 const CF2_StemHintRec* stemHint;
100
101
102 FT_ZERO( hint );
103
104 stemHint = (const CF2_StemHintRec*)cf2_arrstack_getPointer(
105 stemHintArray,
106 indexStemHint );
107
108 width = SUB_INT32( stemHint->max, stemHint->min );
109
110 if ( width == cf2_intToFixed( -21 ) )
111 {
112 /* ghost bottom */
113
114 if ( bottom )
115 {
116 hint->csCoord = stemHint->max;
117 hint->flags = CF2_GhostBottom;
118 }
119 else
120 hint->flags = 0;
121 }
122
123 else if ( width == cf2_intToFixed( -20 ) )
124 {
125 /* ghost top */
126
127 if ( bottom )
128 hint->flags = 0;
129 else
130 {
131 hint->csCoord = stemHint->min;
132 hint->flags = CF2_GhostTop;
133 }
134 }
135
136 else if ( width < 0 )
137 {
138 /* inverted pair */
139
140 /*
141 * Hints with negative widths were produced by an early version of a
142 * non-Adobe font tool. The Type 2 spec allows edge (ghost) hints
143 * with negative widths, but says
144 *
145 * All other negative widths have undefined meaning.
146 *
147 * CoolType has a silent workaround that negates the hint width; for
148 * permissive mode, we do the same here.
149 *
150 * Note: Such fonts cannot use ghost hints, but should otherwise work.
151 * Note: Some poor hints in our faux fonts can produce negative
152 * widths at some blends. For example, see a light weight of
153 * `u' in ASerifMM.
154 *
155 */
156 if ( bottom )
157 {
158 hint->csCoord = stemHint->max;
159 hint->flags = CF2_PairBottom;
160 }
161 else
162 {
163 hint->csCoord = stemHint->min;
164 hint->flags = CF2_PairTop;
165 }
166 }
167
168 else
169 {
170 /* normal pair */
171
172 if ( bottom )
173 {
174 hint->csCoord = stemHint->min;
175 hint->flags = CF2_PairBottom;
176 }
177 else
178 {
179 hint->csCoord = stemHint->max;
180 hint->flags = CF2_PairTop;
181 }
182 }
183
184 /* Now that ghost hints have been detected, adjust this edge for */
185 /* darkening. Bottoms are not changed; tops are incremented by twice */
186 /* `darkenY'. */
187 if ( cf2_hint_isTop( hint ) )
188 hint->csCoord = ADD_INT32( hint->csCoord, 2 * font->darkenY );
189
190 hint->csCoord = ADD_INT32( hint->csCoord, hintOrigin );
191 hint->scale = scale;
192 hint->index = indexStemHint; /* index in original stem hint array */
193
194 /* if original stem hint has been used, use the same position */
195 if ( hint->flags != 0 && stemHint->used )
196 {
197 if ( cf2_hint_isTop( hint ) )
198 hint->dsCoord = stemHint->maxDS;
199 else
200 hint->dsCoord = stemHint->minDS;
201
202 cf2_hint_lock( hint );
203 }
204 else
205 hint->dsCoord = FT_MulFix( hint->csCoord, scale );
206 }
207
208
209 /* initialize an invalid hint map element */
210 static void
211 cf2_hint_initZero( CF2_Hint hint )
212 {
213 FT_ZERO( hint );
214 }
215
216
217 FT_LOCAL_DEF( FT_Bool )
218 cf2_hint_isValid( const CF2_Hint hint )
219 {
220 return FT_BOOL( hint->flags );
221 }
222
223
224 static FT_Bool
225 cf2_hint_isPair( const CF2_Hint hint )
226 {
227 return FT_BOOL( hint->flags & ( CF2_PairBottom | CF2_PairTop ) );
228 }
229
230
231 static FT_Bool
232 cf2_hint_isPairTop( const CF2_Hint hint )
233 {
234 return FT_BOOL( hint->flags & CF2_PairTop );
235 }
236
237
238 FT_LOCAL_DEF( FT_Bool )
239 cf2_hint_isTop( const CF2_Hint hint )
240 {
241 return FT_BOOL( hint->flags & ( CF2_PairTop | CF2_GhostTop ) );
242 }
243
244
245 FT_LOCAL_DEF( FT_Bool )
246 cf2_hint_isBottom( const CF2_Hint hint )
247 {
248 return FT_BOOL( hint->flags & ( CF2_PairBottom | CF2_GhostBottom ) );
249 }
250
251
252 static FT_Bool
253 cf2_hint_isLocked( const CF2_Hint hint )
254 {
255 return FT_BOOL( hint->flags & CF2_Locked );
256 }
257
258
259 static FT_Bool
260 cf2_hint_isSynthetic( const CF2_Hint hint )
261 {
262 return FT_BOOL( hint->flags & CF2_Synthetic );
263 }
264
265
266 FT_LOCAL_DEF( void )
267 cf2_hint_lock( CF2_Hint hint )
268 {
269 hint->flags |= CF2_Locked;
270 }
271
272
273 FT_LOCAL_DEF( void )
274 cf2_hintmap_init( CF2_HintMap hintmap,
275 CF2_Font font,
276 CF2_HintMap initialMap,
277 CF2_ArrStack hintMoves,
278 CF2_Fixed scale )
279 {
280 FT_ZERO( hintmap );
281
282 /* copy parameters from font instance */
283 hintmap->hinted = font->hinted;
284 hintmap->scale = scale;
285 hintmap->font = font;
286 hintmap->initialHintMap = initialMap;
287 /* will clear in `cf2_hintmap_adjustHints' */
288 hintmap->hintMoves = hintMoves;
289 }
290
291
292 static FT_Bool
293 cf2_hintmap_isValid( const CF2_HintMap hintmap )
294 {
295 return hintmap->isValid;
296 }
297
298
299 static void
300 cf2_hintmap_dump( CF2_HintMap hintmap )
301 {
302#ifdef FT_DEBUG_LEVEL_TRACE
303 CF2_UInt i;
304
305
306 FT_TRACE6(( " index csCoord dsCoord scale flags\n" ));
307
308 for ( i = 0; i < hintmap->count; i++ )
309 {
310 CF2_Hint hint = &hintmap->edge[i];
311
312
313 FT_TRACE6(( " %3zu %7.2f %7.2f %5d %s%s%s%s\n",
314 hint->index,
315 hint->csCoord / 65536.0,
316 hint->dsCoord / ( hint->scale * 1.0 ),
317 hint->scale,
318 ( cf2_hint_isPair( hint ) ? "p" : "g" ),
319 ( cf2_hint_isTop( hint ) ? "t" : "b" ),
320 ( cf2_hint_isLocked( hint ) ? "L" : ""),
321 ( cf2_hint_isSynthetic( hint ) ? "S" : "" ) ));
322 }
323#else
324 FT_UNUSED( hintmap );
325#endif
326 }
327
328
329 /* transform character space coordinate to device space using hint map */
330 static CF2_Fixed
331 cf2_hintmap_map( CF2_HintMap hintmap,
332 CF2_Fixed csCoord )
333 {
334 if ( hintmap->count == 0 || !hintmap->hinted )
335 {
336 /* there are no hints; use uniform scale and zero offset */
337 return FT_MulFix( csCoord, hintmap->scale );
338 }
339 else
340 {
341 /* start linear search from last hit */
342 CF2_UInt i = hintmap->lastIndex;
343
344
345 FT_ASSERT( hintmap->lastIndex < CF2_MAX_HINT_EDGES );
346
347 /* search up */
348 while ( i < hintmap->count - 1 &&
349 csCoord >= hintmap->edge[i + 1].csCoord )
350 i += 1;
351
352 /* search down */
353 while ( i > 0 && csCoord < hintmap->edge[i].csCoord )
354 i -= 1;
355
356 hintmap->lastIndex = i;
357
358 if ( i == 0 && csCoord < hintmap->edge[0].csCoord )
359 {
360 /* special case for points below first edge: use uniform scale */
361 return ADD_INT32( FT_MulFix( SUB_INT32( csCoord,
362 hintmap->edge[0].csCoord ),
363 hintmap->scale ),
364 hintmap->edge[0].dsCoord );
365 }
366 else
367 {
368 /*
369 * Note: entries with duplicate csCoord are allowed.
370 * Use edge[i], the highest entry where csCoord >= entry[i].csCoord
371 */
372 return ADD_INT32( FT_MulFix( SUB_INT32( csCoord,
373 hintmap->edge[i].csCoord ),
374 hintmap->edge[i].scale ),
375 hintmap->edge[i].dsCoord );
376 }
377 }
378 }
379
380
381 /*
382 * This hinting policy moves a hint pair in device space so that one of
383 * its two edges is on a device pixel boundary (its fractional part is
384 * zero). `cf2_hintmap_insertHint' guarantees no overlap in CS
385 * space. Ensure here that there is no overlap in DS.
386 *
387 * In the first pass, edges are adjusted relative to adjacent hints.
388 * Those that are below have already been adjusted. Those that are
389 * above have not yet been adjusted. If a hint above blocks an
390 * adjustment to an optimal position, we will try again in a second
391 * pass. The second pass is top-down.
392 *
393 */
394
395 static void
396 cf2_hintmap_adjustHints( CF2_HintMap hintmap )
397 {
398 size_t i, j;
399
400
401 cf2_arrstack_clear( hintmap->hintMoves ); /* working storage */
402
403 /*
404 * First pass is bottom-up (font hint order) without look-ahead.
405 * Locked edges are already adjusted.
406 * Unlocked edges begin with dsCoord from `initialHintMap'.
407 * Save edges that are not optimally adjusted in `hintMoves' array,
408 * and process them in second pass.
409 */
410
411 for ( i = 0; i < hintmap->count; i++ )
412 {
413 FT_Bool isPair = cf2_hint_isPair( &hintmap->edge[i] );
414
415 /* final amount to move edge or edge pair */
416 CF2_Fixed move = 0;
417
418 CF2_Fixed dsCoord_i;
419 CF2_Fixed dsCoord_j;
420
421
422 /* index of upper edge (same value for ghost hint) */
423 j = isPair ? i + 1 : i;
424
425 FT_ASSERT( j < hintmap->count );
426 FT_ASSERT( cf2_hint_isValid( &hintmap->edge[i] ) );
427 FT_ASSERT( cf2_hint_isValid( &hintmap->edge[j] ) );
428 FT_ASSERT( cf2_hint_isLocked( &hintmap->edge[i] ) ==
429 cf2_hint_isLocked( &hintmap->edge[j] ) );
430
431 dsCoord_i = hintmap->edge[i].dsCoord;
432 dsCoord_j = hintmap->edge[j].dsCoord;
433
434 if ( !cf2_hint_isLocked( &hintmap->edge[i] ) )
435 {
436 /* hint edge is not locked, we can adjust it */
437 CF2_Fixed fracDown = cf2_fixedFraction( dsCoord_i );
438 CF2_Fixed fracUp = cf2_fixedFraction( dsCoord_j );
439
440 /* calculate all four possibilities; moves down are negative */
441 CF2_Fixed downMoveDown = 0 - fracDown;
442 CF2_Fixed upMoveDown = 0 - fracUp;
443 CF2_Fixed downMoveUp = ( fracDown == 0 )
444 ? 0
445 : cf2_intToFixed( 1 ) - fracDown;
446 CF2_Fixed upMoveUp = ( fracUp == 0 )
447 ? 0
448 : cf2_intToFixed( 1 ) - fracUp;
449
450 /* smallest move up */
451 CF2_Fixed moveUp = FT_MIN( downMoveUp, upMoveUp );
452 /* smallest move down */
453 CF2_Fixed moveDown = FT_MAX( downMoveDown, upMoveDown );
454
455 CF2_Fixed downMinCounter = CF2_MIN_COUNTER;
456 CF2_Fixed upMinCounter = CF2_MIN_COUNTER;
457 FT_Bool saveEdge = FALSE;
458
459
460 /* minimum counter constraint doesn't apply when adjacent edges */
461 /* are synthetic */
462 /* TODO: doesn't seem a big effect; for now, reduce the code */
463#if 0
464 if ( i == 0 ||
465 cf2_hint_isSynthetic( &hintmap->edge[i - 1] ) )
466 downMinCounter = 0;
467
468 if ( j >= hintmap->count - 1 ||
469 cf2_hint_isSynthetic( &hintmap->edge[j + 1] ) )
470 upMinCounter = 0;
471#endif
472
473 /* is there room to move up? */
474 /* there is if we are at top of array or the next edge is at or */
475 /* beyond proposed move up? */
476 if ( j >= hintmap->count - 1 ||
477 hintmap->edge[j + 1].dsCoord >=
478 ADD_INT32( dsCoord_j, moveUp + upMinCounter ) )
479 {
480 /* there is room to move up; is there also room to move down? */
481 if ( i == 0 ||
482 hintmap->edge[i - 1].dsCoord <=
483 ADD_INT32( dsCoord_i, moveDown - downMinCounter ) )
484 {
485 /* move smaller absolute amount */
486 move = ( -moveDown < moveUp ) ? moveDown : moveUp; /* optimum */
487 }
488 else
489 move = moveUp;
490 }
491 else
492 {
493 /* is there room to move down? */
494 if ( i == 0 ||
495 hintmap->edge[i - 1].dsCoord <=
496 ADD_INT32( dsCoord_i, moveDown - downMinCounter ) )
497 {
498 move = moveDown;
499 /* true if non-optimum move */
500 saveEdge = FT_BOOL( moveUp < -moveDown );
501 }
502 else
503 {
504 /* no room to move either way without overlapping or reducing */
505 /* the counter too much */
506 move = 0;
507 saveEdge = TRUE;
508 }
509 }
510
511 /* Identify non-moves and moves down that aren't optimal, and save */
512 /* them for second pass. */
513 /* Do this only if there is an unlocked edge above (which could */
514 /* possibly move). */
515 if ( saveEdge &&
516 j < hintmap->count - 1 &&
517 !cf2_hint_isLocked( &hintmap->edge[j + 1] ) )
518 {
519 CF2_HintMoveRec savedMove;
520
521
522 savedMove.j = j;
523 /* desired adjustment in second pass */
524 savedMove.moveUp = moveUp - move;
525
526 cf2_arrstack_push( hintmap->hintMoves, &savedMove );
527 }
528
529 /* move the edge(s) */
530 hintmap->edge[i].dsCoord = ADD_INT32( dsCoord_i, move );
531 if ( isPair )
532 hintmap->edge[j].dsCoord = ADD_INT32( dsCoord_j, move );
533 }
534
535 /* assert there are no overlaps in device space; */
536 /* ignore tests if there was overflow (that is, if */
537 /* operands have the same sign but the sum does not) */
538 FT_ASSERT( i == 0 ||
539 ( ( dsCoord_i ^ move ) >= 0 &&
540 ( dsCoord_i ^ hintmap->edge[i].dsCoord ) < 0 ) ||
541 hintmap->edge[i - 1].dsCoord <= hintmap->edge[i].dsCoord );
542 FT_ASSERT( i < j ||
543 ( ( dsCoord_j ^ move ) >= 0 &&
544 ( dsCoord_j ^ hintmap->edge[j].dsCoord ) < 0 ) ||
545 hintmap->edge[i].dsCoord <= hintmap->edge[j].dsCoord );
546
547 /* adjust the scales, avoiding divide by zero */
548 if ( i > 0 )
549 {
550 if ( hintmap->edge[i].csCoord != hintmap->edge[i - 1].csCoord )
551 hintmap->edge[i - 1].scale =
552 FT_DivFix( SUB_INT32( hintmap->edge[i].dsCoord,
553 hintmap->edge[i - 1].dsCoord ),
554 SUB_INT32( hintmap->edge[i].csCoord,
555 hintmap->edge[i - 1].csCoord ) );
556 }
557
558 if ( isPair )
559 {
560 if ( hintmap->edge[j].csCoord != hintmap->edge[j - 1].csCoord )
561 hintmap->edge[j - 1].scale =
562 FT_DivFix( SUB_INT32( hintmap->edge[j].dsCoord,
563 hintmap->edge[j - 1].dsCoord ),
564 SUB_INT32( hintmap->edge[j].csCoord,
565 hintmap->edge[j - 1].csCoord ) );
566
567 i += 1; /* skip upper edge on next loop */
568 }
569 }
570
571 /* second pass tries to move non-optimal hints up, in case there is */
572 /* room now */
573 for ( i = cf2_arrstack_size( hintmap->hintMoves ); i > 0; i-- )
574 {
575 CF2_HintMove hintMove = (CF2_HintMove)
576 cf2_arrstack_getPointer( hintmap->hintMoves, i - 1 );
577
578
579 j = hintMove->j;
580
581 /* this was tested before the push, above */
582 FT_ASSERT( j < hintmap->count - 1 );
583
584 /* is there room to move up? */
585 if ( hintmap->edge[j + 1].dsCoord >=
586 ADD_INT32( hintmap->edge[j].dsCoord,
587 hintMove->moveUp + CF2_MIN_COUNTER ) )
588 {
589 /* there is more room now, move edge up */
590 hintmap->edge[j].dsCoord = ADD_INT32( hintmap->edge[j].dsCoord,
591 hintMove->moveUp );
592
593 if ( cf2_hint_isPair( &hintmap->edge[j] ) )
594 {
595 FT_ASSERT( j > 0 );
596 hintmap->edge[j - 1].dsCoord =
597 ADD_INT32( hintmap->edge[j - 1].dsCoord, hintMove->moveUp );
598 }
599 }
600 }
601 }
602
603
604 /* insert hint edges into map, sorted by csCoord */
605 static void
606 cf2_hintmap_insertHint( CF2_HintMap hintmap,
607 CF2_Hint bottomHintEdge,
608 CF2_Hint topHintEdge )
609 {
610 CF2_UInt indexInsert;
611
612 /* set default values, then check for edge hints */
613 FT_Bool isPair = TRUE;
614 CF2_Hint firstHintEdge = bottomHintEdge;
615 CF2_Hint secondHintEdge = topHintEdge;
616
617
618 /* one or none of the input params may be invalid when dealing with */
619 /* edge hints; at least one edge must be valid */
620 FT_ASSERT( cf2_hint_isValid( bottomHintEdge ) ||
621 cf2_hint_isValid( topHintEdge ) );
622
623 /* determine how many and which edges to insert */
624 if ( !cf2_hint_isValid( bottomHintEdge ) )
625 {
626 /* insert only the top edge */
627 firstHintEdge = topHintEdge;
628 isPair = FALSE;
629 }
630 else if ( !cf2_hint_isValid( topHintEdge ) )
631 {
632 /* insert only the bottom edge */
633 isPair = FALSE;
634 }
635
636 /* paired edges must be in proper order */
637 if ( isPair &&
638 topHintEdge->csCoord < bottomHintEdge->csCoord )
639 return;
640
641 /* linear search to find index value of insertion point */
642 indexInsert = 0;
643 for ( ; indexInsert < hintmap->count; indexInsert++ )
644 {
645 if ( hintmap->edge[indexInsert].csCoord >= firstHintEdge->csCoord )
646 break;
647 }
648
649 FT_TRACE7(( " Got hint at %.2f (%.2f)\n",
650 firstHintEdge->csCoord / 65536.0,
651 firstHintEdge->dsCoord / 65536.0 ));
652 if ( isPair )
653 FT_TRACE7(( " Got hint at %.2f (%.2f)\n",
654 secondHintEdge->csCoord / 65536.0,
655 secondHintEdge->dsCoord / 65536.0 ));
656
657 /*
658 * Discard any hints that overlap in character space. Most often, this
659 * is while building the initial map, where captured hints from all
660 * zones are combined. Define overlap to include hints that `touch'
661 * (overlap zero). Hiragino Sans/Gothic fonts have numerous hints that
662 * touch. Some fonts have non-ideographic glyphs that overlap our
663 * synthetic hints.
664 *
665 * Overlap also occurs when darkening stem hints that are close.
666 *
667 */
668 if ( indexInsert < hintmap->count )
669 {
670 /* we are inserting before an existing edge: */
671 /* verify that an existing edge is not the same */
672 if ( hintmap->edge[indexInsert].csCoord == firstHintEdge->csCoord )
673 return; /* ignore overlapping stem hint */
674
675 /* verify that a new pair does not straddle the next edge */
676 if ( isPair &&
677 hintmap->edge[indexInsert].csCoord <= secondHintEdge->csCoord )
678 return; /* ignore overlapping stem hint */
679
680 /* verify that we are not inserting between paired edges */
681 if ( cf2_hint_isPairTop( &hintmap->edge[indexInsert] ) )
682 return; /* ignore overlapping stem hint */
683 }
684
685 /* recompute device space locations using initial hint map */
686 if ( cf2_hintmap_isValid( hintmap->initialHintMap ) &&
687 !cf2_hint_isLocked( firstHintEdge ) )
688 {
689 if ( isPair )
690 {
691 /* Use hint map to position the center of stem, and nominal scale */
692 /* to position the two edges. This preserves the stem width. */
693 CF2_Fixed midpoint =
694 cf2_hintmap_map(
695 hintmap->initialHintMap,
696 ADD_INT32(
697 firstHintEdge->csCoord,
698 SUB_INT32 ( secondHintEdge->csCoord,
699 firstHintEdge->csCoord ) / 2 ) );
700 CF2_Fixed halfWidth =
701 FT_MulFix( SUB_INT32( secondHintEdge->csCoord,
702 firstHintEdge->csCoord ) / 2,
703 hintmap->scale );
704
705
706 firstHintEdge->dsCoord = SUB_INT32( midpoint, halfWidth );
707 secondHintEdge->dsCoord = ADD_INT32( midpoint, halfWidth );
708 }
709 else
710 firstHintEdge->dsCoord = cf2_hintmap_map( hintmap->initialHintMap,
711 firstHintEdge->csCoord );
712 }
713
714 /*
715 * Discard any hints that overlap in device space; this can occur
716 * because locked hints have been moved to align with blue zones.
717 *
718 * TODO: Although we might correct this later during adjustment, we
719 * don't currently have a way to delete a conflicting hint once it has
720 * been inserted. See v2.030 MinionPro-Regular, 12 ppem darkened,
721 * initial hint map for second path, glyph 945 (the perispomeni (tilde)
722 * in U+1F6E, Greek omega with psili and perispomeni). Darkening is
723 * 25. Pair 667,747 initially conflicts in design space with top edge
724 * 660. This is because 667 maps to 7.87, and the top edge was
725 * captured by a zone at 8.0. The pair is later successfully inserted
726 * in a zone without the top edge. In this zone it is adjusted to 8.0,
727 * and no longer conflicts with the top edge in design space. This
728 * means it can be included in yet a later zone which does have the top
729 * edge hint. This produces a small mismatch between the first and
730 * last points of this path, even though the hint masks are the same.
731 * The density map difference is tiny (1/256).
732 *
733 */
734
735 if ( indexInsert > 0 )
736 {
737 /* we are inserting after an existing edge */
738 if ( firstHintEdge->dsCoord < hintmap->edge[indexInsert - 1].dsCoord )
739 return;
740 }
741
742 if ( indexInsert < hintmap->count )
743 {
744 /* we are inserting before an existing edge */
745 if ( isPair )
746 {
747 if ( secondHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord )
748 return;
749 }
750 else
751 {
752 if ( firstHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord )
753 return;
754 }
755 }
756
757 /* make room to insert */
758 {
759 CF2_UInt iSrc = hintmap->count - 1;
760 CF2_UInt iDst = isPair ? hintmap->count + 1 : hintmap->count;
761
762 CF2_UInt count = hintmap->count - indexInsert;
763
764
765 if ( iDst >= CF2_MAX_HINT_EDGES )
766 {
767 FT_TRACE4(( "cf2_hintmap_insertHint: too many hintmaps\n" ));
768 return;
769 }
770
771 while ( count-- )
772 hintmap->edge[iDst--] = hintmap->edge[iSrc--];
773
774 /* insert first edge */
775 hintmap->edge[indexInsert] = *firstHintEdge; /* copy struct */
776 hintmap->count += 1;
777
778 FT_TRACE7(( " Inserting hint %.2f (%.2f)\n",
779 firstHintEdge->csCoord / 65536.0,
780 firstHintEdge->dsCoord / 65536.0 ));
781
782 if ( isPair )
783 {
784 /* insert second edge */
785 hintmap->edge[indexInsert + 1] = *secondHintEdge; /* copy struct */
786 hintmap->count += 1;
787
788 FT_TRACE7(( " Inserting hint %.2f (%.2f)\n",
789 secondHintEdge->csCoord / 65536.0,
790 secondHintEdge->dsCoord / 65536.0 ));
791
792 }
793 }
794
795 return;
796 }
797
798
799 /*
800 * Build a map from hints and mask.
801 *
802 * This function may recur one level if `hintmap->initialHintMap' is not yet
803 * valid.
804 * If `initialMap' is true, simply build initial map.
805 *
806 * Synthetic hints are used in two ways. A hint at zero is inserted, if
807 * needed, in the initial hint map, to prevent translations from
808 * propagating across the origin. If synthetic em box hints are enabled
809 * for ideographic dictionaries, then they are inserted in all hint
810 * maps, including the initial one.
811 *
812 */
813 FT_LOCAL_DEF( void )
814 cf2_hintmap_build( CF2_HintMap hintmap,
815 CF2_ArrStack hStemHintArray,
816 CF2_ArrStack vStemHintArray,
817 CF2_HintMask hintMask,
818 CF2_Fixed hintOrigin,
819 FT_Bool initialMap )
820 {
821 FT_Byte* maskPtr;
822
823 CF2_Font font = hintmap->font;
824 CF2_HintMaskRec tempHintMask;
825
826 size_t bitCount, i;
827 FT_Byte maskByte;
828
829
830 /* check whether initial map is constructed */
831 if ( !initialMap && !cf2_hintmap_isValid( hintmap->initialHintMap ) )
832 {
833 /* make recursive call with initialHintMap and temporary mask; */
834 /* temporary mask will get all bits set, below */
835 cf2_hintmask_init( &tempHintMask, hintMask->error );
836 cf2_hintmap_build( hintmap->initialHintMap,
837 hStemHintArray,
838 vStemHintArray,
839 &tempHintMask,
840 hintOrigin,
841 TRUE );
842 }
843
844 if ( !cf2_hintmask_isValid( hintMask ) )
845 {
846 /* without a hint mask, assume all hints are active */
847 cf2_hintmask_setAll( hintMask,
848 cf2_arrstack_size( hStemHintArray ) +
849 cf2_arrstack_size( vStemHintArray ) );
850 if ( !cf2_hintmask_isValid( hintMask ) )
851 {
852 if ( font->isT1 )
853 {
854 /* no error, just continue unhinted */
855 *hintMask->error = FT_Err_Ok;
856 hintmap->hinted = FALSE;
857 }
858 return; /* too many stem hints */
859 }
860 }
861
862 /* begin by clearing the map */
863 hintmap->count = 0;
864 hintmap->lastIndex = 0;
865
866 /* make a copy of the hint mask so we can modify it */
867 tempHintMask = *hintMask;
868 maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask );
869
870 /* use the hStem hints only, which are first in the mask */
871 bitCount = cf2_arrstack_size( hStemHintArray );
872
873 /* Defense-in-depth. Should never return here. */
874 if ( bitCount > hintMask->bitCount )
875 return;
876
877 /* synthetic embox hints get highest priority */
878 if ( font->blues.doEmBoxHints )
879 {
880 CF2_HintRec dummy;
881
882
883 cf2_hint_initZero( &dummy ); /* invalid hint map element */
884
885 /* ghost bottom */
886 cf2_hintmap_insertHint( hintmap,
887 &font->blues.emBoxBottomEdge,
888 &dummy );
889 /* ghost top */
890 cf2_hintmap_insertHint( hintmap,
891 &dummy,
892 &font->blues.emBoxTopEdge );
893 }
894
895 /* insert hints captured by a blue zone or already locked (higher */
896 /* priority) */
897 for ( i = 0, maskByte = 0x80; i < bitCount; i++ )
898 {
899 if ( maskByte & *maskPtr )
900 {
901 /* expand StemHint into two `CF2_Hint' elements */
902 CF2_HintRec bottomHintEdge, topHintEdge;
903
904
905 cf2_hint_init( &bottomHintEdge,
906 hStemHintArray,
907 i,
908 font,
909 hintOrigin,
910 hintmap->scale,
911 TRUE /* bottom */ );
912 cf2_hint_init( &topHintEdge,
913 hStemHintArray,
914 i,
915 font,
916 hintOrigin,
917 hintmap->scale,
918 FALSE /* top */ );
919
920 if ( cf2_hint_isLocked( &bottomHintEdge ) ||
921 cf2_hint_isLocked( &topHintEdge ) ||
922 cf2_blues_capture( &font->blues,
923 &bottomHintEdge,
924 &topHintEdge ) )
925 {
926 /* insert captured hint into map */
927 cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge );
928
929 *maskPtr &= ~maskByte; /* turn off the bit for this hint */
930 }
931 }
932
933 if ( ( i & 7 ) == 7 )
934 {
935 /* move to next mask byte */
936 maskPtr++;
937 maskByte = 0x80;
938 }
939 else
940 maskByte >>= 1;
941 }
942
943 /* initial hint map includes only captured hints plus maybe one at 0 */
944
945 /*
946 * TODO: There is a problem here because we are trying to build a
947 * single hint map containing all captured hints. It is
948 * possible for there to be conflicts between captured hints,
949 * either because of darkening or because the hints are in
950 * separate hint zones (we are ignoring hint zones for the
951 * initial map). An example of the latter is MinionPro-Regular
952 * v2.030 glyph 883 (Greek Capital Alpha with Psili) at 15ppem.
953 * A stem hint for the psili conflicts with the top edge hint
954 * for the base character. The stem hint gets priority because
955 * of its sort order. In glyph 884 (Greek Capital Alpha with
956 * Psili and Oxia), the top of the base character gets a stem
957 * hint, and the psili does not. This creates different initial
958 * maps for the two glyphs resulting in different renderings of
959 * the base character. Will probably defer this either as not
960 * worth the cost or as a font bug. I don't think there is any
961 * good reason for an accent to be captured by an alignment
962 * zone. -darnold 2/12/10
963 */
964
965 if ( initialMap )
966 {
967 /* Apply a heuristic that inserts a point for (0,0), unless it's */
968 /* already covered by a mapping. This locks the baseline for glyphs */
969 /* that have no baseline hints. */
970
971 if ( hintmap->count == 0 ||
972 hintmap->edge[0].csCoord > 0 ||
973 hintmap->edge[hintmap->count - 1].csCoord < 0 )
974 {
975 /* all edges are above 0 or all edges are below 0; */
976 /* construct a locked edge hint at 0 */
977
978 CF2_HintRec edge, invalid;
979
980
981 cf2_hint_initZero( &edge );
982
983 edge.flags = CF2_GhostBottom |
984 CF2_Locked |
985 CF2_Synthetic;
986 edge.scale = hintmap->scale;
987
988 cf2_hint_initZero( &invalid );
989 cf2_hintmap_insertHint( hintmap, &edge, &invalid );
990 }
991 }
992 else
993 {
994 /* insert remaining hints */
995
996 maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask );
997
998 for ( i = 0, maskByte = 0x80; i < bitCount; i++ )
999 {
1000 if ( maskByte & *maskPtr )
1001 {
1002 CF2_HintRec bottomHintEdge, topHintEdge;
1003
1004
1005 cf2_hint_init( &bottomHintEdge,
1006 hStemHintArray,
1007 i,
1008 font,
1009 hintOrigin,
1010 hintmap->scale,
1011 TRUE /* bottom */ );
1012 cf2_hint_init( &topHintEdge,
1013 hStemHintArray,
1014 i,
1015 font,
1016 hintOrigin,
1017 hintmap->scale,
1018 FALSE /* top */ );
1019
1020 cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge );
1021 }
1022
1023 if ( ( i & 7 ) == 7 )
1024 {
1025 /* move to next mask byte */
1026 maskPtr++;
1027 maskByte = 0x80;
1028 }
1029 else
1030 maskByte >>= 1;
1031 }
1032 }
1033
1034#ifdef FT_DEBUG_LEVEL_TRACE
1035 if ( initialMap )
1036 {
1037 FT_TRACE6(( "flags: [p]air [g]host [t]op"
1038 " [b]ottom [L]ocked [S]ynthetic\n" ));
1039 FT_TRACE6(( "Initial hintmap:\n" ));
1040 }
1041 else
1042 FT_TRACE6(( "Hints:\n" ));
1043#endif
1044
1045 cf2_hintmap_dump( hintmap );
1046
1047 /*
1048 * Note: The following line is a convenient place to break when
1049 * debugging hinting. Examine `hintmap->edge' for the list of
1050 * enabled hints, then step over the call to see the effect of
1051 * adjustment. We stop here first on the recursive call that
1052 * creates the initial map, and then on each counter group and
1053 * hint zone.
1054 */
1055
1056 /* adjust positions of hint edges that are not locked to blue zones */
1057 cf2_hintmap_adjustHints( hintmap );
1058
1059 FT_TRACE6(( "Hints adjusted:\n" ));
1060 cf2_hintmap_dump( hintmap );
1061
1062 /* save the position of all hints that were used in this hint map; */
1063 /* if we use them again, we'll locate them in the same position */
1064 if ( !initialMap )
1065 {
1066 for ( i = 0; i < hintmap->count; i++ )
1067 {
1068 if ( !cf2_hint_isSynthetic( &hintmap->edge[i] ) )
1069 {
1070 /* Note: include both valid and invalid edges */
1071 /* Note: top and bottom edges are copied back separately */
1072 CF2_StemHint stemhint = (CF2_StemHint)
1073 cf2_arrstack_getPointer( hStemHintArray,
1074 hintmap->edge[i].index );
1075
1076
1077 if ( cf2_hint_isTop( &hintmap->edge[i] ) )
1078 stemhint->maxDS = hintmap->edge[i].dsCoord;
1079 else
1080 stemhint->minDS = hintmap->edge[i].dsCoord;
1081
1082 stemhint->used = TRUE;
1083 }
1084 }
1085 }
1086
1087 /* hint map is ready to use */
1088 hintmap->isValid = TRUE;
1089
1090 /* remember this mask has been used */
1091 cf2_hintmask_setNew( hintMask, FALSE );
1092 }
1093
1094
1095 FT_LOCAL_DEF( void )
1096 cf2_glyphpath_init( CF2_GlyphPath glyphpath,
1097 CF2_Font font,
1098 CF2_OutlineCallbacks callbacks,
1099 CF2_Fixed scaleY,
1100 /* CF2_Fixed hShift, */
1101 CF2_ArrStack hStemHintArray,
1102 CF2_ArrStack vStemHintArray,
1103 CF2_HintMask hintMask,
1104 CF2_Fixed hintOriginY,
1105 const CF2_Blues blues,
1106 const FT_Vector* fractionalTranslation )
1107 {
1108 FT_ZERO( glyphpath );
1109
1110 glyphpath->font = font;
1111 glyphpath->callbacks = callbacks;
1112
1113 cf2_arrstack_init( &glyphpath->hintMoves,
1114 font->memory,
1115 &font->error,
1116 sizeof ( CF2_HintMoveRec ) );
1117
1118 cf2_hintmap_init( &glyphpath->initialHintMap,
1119 font,
1120 &glyphpath->initialHintMap,
1121 &glyphpath->hintMoves,
1122 scaleY );
1123 cf2_hintmap_init( &glyphpath->firstHintMap,
1124 font,
1125 &glyphpath->initialHintMap,
1126 &glyphpath->hintMoves,
1127 scaleY );
1128 cf2_hintmap_init( &glyphpath->hintMap,
1129 font,
1130 &glyphpath->initialHintMap,
1131 &glyphpath->hintMoves,
1132 scaleY );
1133
1134 glyphpath->scaleX = font->innerTransform.a;
1135 glyphpath->scaleC = font->innerTransform.c;
1136 glyphpath->scaleY = font->innerTransform.d;
1137
1138 glyphpath->fractionalTranslation = *fractionalTranslation;
1139
1140#if 0
1141 glyphpath->hShift = hShift; /* for fauxing */
1142#endif
1143
1144 glyphpath->hStemHintArray = hStemHintArray;
1145 glyphpath->vStemHintArray = vStemHintArray;
1146 glyphpath->hintMask = hintMask; /* ptr to current mask */
1147 glyphpath->hintOriginY = hintOriginY;
1148 glyphpath->blues = blues;
1149 glyphpath->darken = font->darkened; /* TODO: should we make copies? */
1150 glyphpath->xOffset = font->darkenX;
1151 glyphpath->yOffset = font->darkenY;
1152 glyphpath->miterLimit = 2 * FT_MAX(
1153 cf2_fixedAbs( glyphpath->xOffset ),
1154 cf2_fixedAbs( glyphpath->yOffset ) );
1155
1156 /* .1 character space unit */
1157 glyphpath->snapThreshold = cf2_doubleToFixed( 0.1 );
1158
1159 glyphpath->moveIsPending = TRUE;
1160 glyphpath->pathIsOpen = FALSE;
1161 glyphpath->pathIsClosing = FALSE;
1162 glyphpath->elemIsQueued = FALSE;
1163 }
1164
1165
1166 FT_LOCAL_DEF( void )
1167 cf2_glyphpath_finalize( CF2_GlyphPath glyphpath )
1168 {
1169 cf2_arrstack_finalize( &glyphpath->hintMoves );
1170 }
1171
1172
1173 /*
1174 * Hint point in y-direction and apply outerTransform.
1175 * Input `current' hint map (which is actually delayed by one element).
1176 * Input x,y point in Character Space.
1177 * Output x,y point in Device Space, including translation.
1178 */
1179 static void
1180 cf2_glyphpath_hintPoint( CF2_GlyphPath glyphpath,
1181 CF2_HintMap hintmap,
1182 FT_Vector* ppt,
1183 CF2_Fixed x,
1184 CF2_Fixed y )
1185 {
1186 FT_Vector pt; /* hinted point in upright DS */
1187
1188
1189 pt.x = ADD_INT32( FT_MulFix( glyphpath->scaleX, x ),
1190 FT_MulFix( glyphpath->scaleC, y ) );
1191 pt.y = cf2_hintmap_map( hintmap, y );
1192
1193 ppt->x = ADD_INT32(
1194 FT_MulFix( glyphpath->font->outerTransform.a, pt.x ),
1195 ADD_INT32(
1196 FT_MulFix( glyphpath->font->outerTransform.c, pt.y ),
1197 glyphpath->fractionalTranslation.x ) );
1198 ppt->y = ADD_INT32(
1199 FT_MulFix( glyphpath->font->outerTransform.b, pt.x ),
1200 ADD_INT32(
1201 FT_MulFix( glyphpath->font->outerTransform.d, pt.y ),
1202 glyphpath->fractionalTranslation.y ) );
1203 }
1204
1205
1206 /*
1207 * From two line segments, (u1,u2) and (v1,v2), compute a point of
1208 * intersection on the corresponding lines.
1209 * Return false if no intersection is found, or if the intersection is
1210 * too far away from the ends of the line segments, u2 and v1.
1211 *
1212 */
1213 static FT_Bool
1214 cf2_glyphpath_computeIntersection( CF2_GlyphPath glyphpath,
1215 const FT_Vector* u1,
1216 const FT_Vector* u2,
1217 const FT_Vector* v1,
1218 const FT_Vector* v2,
1219 FT_Vector* intersection )
1220 {
1221 /*
1222 * Let `u' be a zero-based vector from the first segment, `v' from the
1223 * second segment.
1224 * Let `w 'be the zero-based vector from `u1' to `v1'.
1225 * `perp' is the `perpendicular dot product'; see
1226 * https://mathworld.wolfram.com/PerpDotProduct.html.
1227 * `s' is the parameter for the parametric line for the first segment
1228 * (`u').
1229 *
1230 * See notation in
1231 * http://geomalgorithms.com/a05-_intersect-1.html.
1232 * Calculations are done in 16.16, but must handle the squaring of
1233 * line lengths in character space. We scale all vectors by 1/32 to
1234 * avoid overflow. This allows values up to 4095 to be squared. The
1235 * scale factor cancels in the divide.
1236 *
1237 * TODO: the scale factor could be computed from UnitsPerEm.
1238 *
1239 */
1240
1241#define cf2_perp( a, b ) \
1242 ( FT_MulFix( a.x, b.y ) - FT_MulFix( a.y, b.x ) )
1243
1244 /* round and divide by 32 */
1245#define CF2_CS_SCALE( x ) \
1246 ( ( (x) + 0x10 ) >> 5 )
1247
1248 FT_Vector u, v, w; /* scaled vectors */
1249 CF2_Fixed denominator, s;
1250
1251
1252 u.x = CF2_CS_SCALE( SUB_INT32( u2->x, u1->x ) );
1253 u.y = CF2_CS_SCALE( SUB_INT32( u2->y, u1->y ) );
1254 v.x = CF2_CS_SCALE( SUB_INT32( v2->x, v1->x ) );
1255 v.y = CF2_CS_SCALE( SUB_INT32( v2->y, v1->y ) );
1256 w.x = CF2_CS_SCALE( SUB_INT32( v1->x, u1->x ) );
1257 w.y = CF2_CS_SCALE( SUB_INT32( v1->y, u1->y ) );
1258
1259 denominator = cf2_perp( u, v );
1260
1261 if ( denominator == 0 )
1262 return FALSE; /* parallel or coincident lines */
1263
1264 s = FT_DivFix( cf2_perp( w, v ), denominator );
1265
1266 intersection->x = ADD_INT32( u1->x,
1267 FT_MulFix( s, SUB_INT32( u2->x, u1->x ) ) );
1268 intersection->y = ADD_INT32( u1->y,
1269 FT_MulFix( s, SUB_INT32( u2->y, u1->y ) ) );
1270
1271
1272 /*
1273 * Special case snapping for horizontal and vertical lines.
1274 * This cleans up intersections and reduces problems with winding
1275 * order detection.
1276 * Sample case is sbc cd KozGoPr6N-Medium.otf 20 16685.
1277 * Note: these calculations are in character space.
1278 *
1279 */
1280
1281 if ( u1->x == u2->x &&
1282 cf2_fixedAbs( SUB_INT32( intersection->x,
1283 u1->x ) ) < glyphpath->snapThreshold )
1284 intersection->x = u1->x;
1285 if ( u1->y == u2->y &&
1286 cf2_fixedAbs( SUB_INT32( intersection->y,
1287 u1->y ) ) < glyphpath->snapThreshold )
1288 intersection->y = u1->y;
1289
1290 if ( v1->x == v2->x &&
1291 cf2_fixedAbs( SUB_INT32( intersection->x,
1292 v1->x ) ) < glyphpath->snapThreshold )
1293 intersection->x = v1->x;
1294 if ( v1->y == v2->y &&
1295 cf2_fixedAbs( SUB_INT32( intersection->y,
1296 v1->y ) ) < glyphpath->snapThreshold )
1297 intersection->y = v1->y;
1298
1299 /* limit the intersection distance from midpoint of u2 and v1 */
1300 if ( cf2_fixedAbs( intersection->x - ADD_INT32( u2->x, v1->x ) / 2 ) >
1301 glyphpath->miterLimit ||
1302 cf2_fixedAbs( intersection->y - ADD_INT32( u2->y, v1->y ) / 2 ) >
1303 glyphpath->miterLimit )
1304 return FALSE;
1305
1306 return TRUE;
1307 }
1308
1309
1310 /*
1311 * Push the cached element (glyphpath->prevElem*) to the outline
1312 * consumer. When a darkening offset is used, the end point of the
1313 * cached element may be adjusted to an intersection point or we may
1314 * synthesize a connecting line to the current element. If we are
1315 * closing a subpath, we may also generate a connecting line to the start
1316 * point.
1317 *
1318 * This is where Character Space (CS) is converted to Device Space (DS)
1319 * using a hint map. This calculation must use a HintMap that was valid
1320 * at the time the element was saved. For the first point in a subpath,
1321 * that is a saved HintMap. For most elements, it just means the caller
1322 * has delayed building a HintMap from the current HintMask.
1323 *
1324 * Transform each point with outerTransform and call the outline
1325 * callbacks. This is a general 3x3 transform:
1326 *
1327 * x' = a*x + c*y + tx, y' = b*x + d*y + ty
1328 *
1329 * but it uses 4 elements from CF2_Font and the translation part
1330 * from CF2_GlyphPath.
1331 *
1332 */
1333 static void
1334 cf2_glyphpath_pushPrevElem( CF2_GlyphPath glyphpath,
1335 CF2_HintMap hintmap,
1336 FT_Vector* nextP0,
1337 FT_Vector nextP1,
1338 FT_Bool close )
1339 {
1340 CF2_CallbackParamsRec params;
1341
1342 FT_Vector* prevP0;
1343 FT_Vector* prevP1;
1344
1345 FT_Vector intersection = { 0, 0 };
1346 FT_Bool useIntersection = FALSE;
1347
1348
1349 FT_ASSERT( glyphpath->prevElemOp == CF2_PathOpLineTo ||
1350 glyphpath->prevElemOp == CF2_PathOpCubeTo );
1351
1352 if ( glyphpath->prevElemOp == CF2_PathOpLineTo )
1353 {
1354 prevP0 = &glyphpath->prevElemP0;
1355 prevP1 = &glyphpath->prevElemP1;
1356 }
1357 else
1358 {
1359 prevP0 = &glyphpath->prevElemP2;
1360 prevP1 = &glyphpath->prevElemP3;
1361 }
1362
1363 /* optimization: if previous and next elements are offset by the same */
1364 /* amount, then there will be no gap, and no need to compute an */
1365 /* intersection. */
1366 if ( prevP1->x != nextP0->x || prevP1->y != nextP0->y )
1367 {
1368 /* previous element does not join next element: */
1369 /* adjust end point of previous element to the intersection */
1370 useIntersection = cf2_glyphpath_computeIntersection( glyphpath,
1371 prevP0,
1372 prevP1,
1373 nextP0,
1374 &nextP1,
1375 &intersection );
1376 if ( useIntersection )
1377 {
1378 /* modify the last point of the cached element (either line or */
1379 /* curve) */
1380 *prevP1 = intersection;
1381 }
1382 }
1383
1384 params.pt0 = glyphpath->currentDS;
1385
1386 switch( glyphpath->prevElemOp )
1387 {
1388 case CF2_PathOpLineTo:
1389 params.op = CF2_PathOpLineTo;
1390
1391 /* note: pt2 and pt3 are unused */
1392
1393 if ( close )
1394 {
1395 /* use first hint map if closing */
1396 cf2_glyphpath_hintPoint( glyphpath,
1397 &glyphpath->firstHintMap,
1398 &params.pt1,
1399 glyphpath->prevElemP1.x,
1400 glyphpath->prevElemP1.y );
1401 }
1402 else
1403 {
1404 cf2_glyphpath_hintPoint( glyphpath,
1405 hintmap,
1406 &params.pt1,
1407 glyphpath->prevElemP1.x,
1408 glyphpath->prevElemP1.y );
1409 }
1410
1411 /* output only non-zero length lines */
1412 if ( params.pt0.x != params.pt1.x || params.pt0.y != params.pt1.y )
1413 {
1414 glyphpath->callbacks->lineTo( glyphpath->callbacks, &params );
1415
1416 glyphpath->currentDS = params.pt1;
1417 }
1418 break;
1419
1420 case CF2_PathOpCubeTo:
1421 params.op = CF2_PathOpCubeTo;
1422
1423 /* TODO: should we intersect the interior joins (p1-p2 and p2-p3)? */
1424 cf2_glyphpath_hintPoint( glyphpath,
1425 hintmap,
1426 &params.pt1,
1427 glyphpath->prevElemP1.x,
1428 glyphpath->prevElemP1.y );
1429 cf2_glyphpath_hintPoint( glyphpath,
1430 hintmap,
1431 &params.pt2,
1432 glyphpath->prevElemP2.x,
1433 glyphpath->prevElemP2.y );
1434 cf2_glyphpath_hintPoint( glyphpath,
1435 hintmap,
1436 &params.pt3,
1437 glyphpath->prevElemP3.x,
1438 glyphpath->prevElemP3.y );
1439
1440 glyphpath->callbacks->cubeTo( glyphpath->callbacks, &params );
1441
1442 glyphpath->currentDS = params.pt3;
1443
1444 break;
1445 }
1446
1447 if ( !useIntersection || close )
1448 {
1449 /* insert connecting line between end of previous element and start */
1450 /* of current one */
1451 /* note: at the end of a subpath, we might do both, so use `nextP0' */
1452 /* before we change it, below */
1453
1454 if ( close )
1455 {
1456 /* if we are closing the subpath, then nextP0 is in the first */
1457 /* hint zone */
1458 cf2_glyphpath_hintPoint( glyphpath,
1459 &glyphpath->firstHintMap,
1460 &params.pt1,
1461 nextP0->x,
1462 nextP0->y );
1463 }
1464 else
1465 {
1466 cf2_glyphpath_hintPoint( glyphpath,
1467 hintmap,
1468 &params.pt1,
1469 nextP0->x,
1470 nextP0->y );
1471 }
1472
1473 if ( params.pt1.x != glyphpath->currentDS.x ||
1474 params.pt1.y != glyphpath->currentDS.y )
1475 {
1476 /* length is nonzero */
1477 params.op = CF2_PathOpLineTo;
1478 params.pt0 = glyphpath->currentDS;
1479
1480 /* note: pt2 and pt3 are unused */
1481 glyphpath->callbacks->lineTo( glyphpath->callbacks, &params );
1482
1483 glyphpath->currentDS = params.pt1;
1484 }
1485 }
1486
1487 if ( useIntersection )
1488 {
1489 /* return intersection point to caller */
1490 *nextP0 = intersection;
1491 }
1492 }
1493
1494
1495 /* push a MoveTo element based on current point and offset of current */
1496 /* element */
1497 static void
1498 cf2_glyphpath_pushMove( CF2_GlyphPath glyphpath,
1499 FT_Vector start )
1500 {
1501 CF2_CallbackParamsRec params;
1502
1503
1504 params.op = CF2_PathOpMoveTo;
1505 params.pt0 = glyphpath->currentDS;
1506
1507 /* Test if move has really happened yet; it would have called */
1508 /* `cf2_hintmap_build' to set `isValid'. */
1509 if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) )
1510 {
1511 /* we are here iff first subpath is missing a moveto operator: */
1512 /* synthesize first moveTo to finish initialization of hintMap */
1513 cf2_glyphpath_moveTo( glyphpath,
1514 glyphpath->start.x,
1515 glyphpath->start.y );
1516 }
1517
1518 cf2_glyphpath_hintPoint( glyphpath,
1519 &glyphpath->hintMap,
1520 &params.pt1,
1521 start.x,
1522 start.y );
1523
1524 /* note: pt2 and pt3 are unused */
1525 glyphpath->callbacks->moveTo( glyphpath->callbacks, &params );
1526
1527 glyphpath->currentDS = params.pt1;
1528 glyphpath->offsetStart0 = start;
1529 }
1530
1531
1532 /*
1533 * All coordinates are in character space.
1534 * On input, (x1, y1) and (x2, y2) give line segment.
1535 * On output, (x, y) give offset vector.
1536 * We use a piecewise approximation to trig functions.
1537 *
1538 * TODO: Offset true perpendicular and proper length
1539 * supply the y-translation for hinting here, too,
1540 * that adds yOffset unconditionally to *y.
1541 */
1542 static void
1543 cf2_glyphpath_computeOffset( CF2_GlyphPath glyphpath,
1544 CF2_Fixed x1,
1545 CF2_Fixed y1,
1546 CF2_Fixed x2,
1547 CF2_Fixed y2,
1548 CF2_Fixed* x,
1549 CF2_Fixed* y )
1550 {
1551 CF2_Fixed dx = SUB_INT32( x2, x1 );
1552 CF2_Fixed dy = SUB_INT32( y2, y1 );
1553
1554
1555 /* note: negative offsets don't work here; negate deltas to change */
1556 /* quadrants, below */
1557 if ( glyphpath->font->reverseWinding )
1558 {
1559 dx = NEG_INT32( dx );
1560 dy = NEG_INT32( dy );
1561 }
1562
1563 *x = *y = 0;
1564
1565 if ( !glyphpath->darken )
1566 return;
1567
1568 /* add momentum for this path element */
1569 glyphpath->callbacks->windingMomentum =
1570 ADD_INT32( glyphpath->callbacks->windingMomentum,
1571 cf2_getWindingMomentum( x1, y1, x2, y2 ) );
1572
1573 /* note: allow mixed integer and fixed multiplication here */
1574 if ( dx >= 0 )
1575 {
1576 if ( dy >= 0 )
1577 {
1578 /* first quadrant, +x +y */
1579
1580 if ( dx > MUL_INT32( 2, dy ) )
1581 {
1582 /* +x */
1583 *x = 0;
1584 *y = 0;
1585 }
1586 else if ( dy > MUL_INT32( 2, dx ) )
1587 {
1588 /* +y */
1589 *x = glyphpath->xOffset;
1590 *y = glyphpath->yOffset;
1591 }
1592 else
1593 {
1594 /* +x +y */
1595 *x = FT_MulFix( cf2_doubleToFixed( 0.7 ),
1596 glyphpath->xOffset );
1597 *y = FT_MulFix( cf2_doubleToFixed( 1.0 - 0.7 ),
1598 glyphpath->yOffset );
1599 }
1600 }
1601 else
1602 {
1603 /* fourth quadrant, +x -y */
1604
1605 if ( dx > MUL_INT32( -2, dy ) )
1606 {
1607 /* +x */
1608 *x = 0;
1609 *y = 0;
1610 }
1611 else if ( NEG_INT32( dy ) > MUL_INT32( 2, dx ) )
1612 {
1613 /* -y */
1614 *x = NEG_INT32( glyphpath->xOffset );
1615 *y = glyphpath->yOffset;
1616 }
1617 else
1618 {
1619 /* +x -y */
1620 *x = FT_MulFix( cf2_doubleToFixed( -0.7 ),
1621 glyphpath->xOffset );
1622 *y = FT_MulFix( cf2_doubleToFixed( 1.0 - 0.7 ),
1623 glyphpath->yOffset );
1624 }
1625 }
1626 }
1627 else
1628 {
1629 if ( dy >= 0 )
1630 {
1631 /* second quadrant, -x +y */
1632
1633 if ( NEG_INT32( dx ) > MUL_INT32( 2, dy ) )
1634 {
1635 /* -x */
1636 *x = 0;
1637 *y = MUL_INT32( 2, glyphpath->yOffset );
1638 }
1639 else if ( dy > MUL_INT32( -2, dx ) )
1640 {
1641 /* +y */
1642 *x = glyphpath->xOffset;
1643 *y = glyphpath->yOffset;
1644 }
1645 else
1646 {
1647 /* -x +y */
1648 *x = FT_MulFix( cf2_doubleToFixed( 0.7 ),
1649 glyphpath->xOffset );
1650 *y = FT_MulFix( cf2_doubleToFixed( 1.0 + 0.7 ),
1651 glyphpath->yOffset );
1652 }
1653 }
1654 else
1655 {
1656 /* third quadrant, -x -y */
1657
1658 if ( NEG_INT32( dx ) > MUL_INT32( -2, dy ) )
1659 {
1660 /* -x */
1661 *x = 0;
1662 *y = MUL_INT32( 2, glyphpath->yOffset );
1663 }
1664 else if ( NEG_INT32( dy ) > MUL_INT32( -2, dx ) )
1665 {
1666 /* -y */
1667 *x = NEG_INT32( glyphpath->xOffset );
1668 *y = glyphpath->yOffset;
1669 }
1670 else
1671 {
1672 /* -x -y */
1673 *x = FT_MulFix( cf2_doubleToFixed( -0.7 ),
1674 glyphpath->xOffset );
1675 *y = FT_MulFix( cf2_doubleToFixed( 1.0 + 0.7 ),
1676 glyphpath->yOffset );
1677 }
1678 }
1679 }
1680 }
1681
1682
1683 /*
1684 * The functions cf2_glyphpath_{moveTo,lineTo,curveTo,closeOpenPath} are
1685 * called by the interpreter with Character Space (CS) coordinates. Each
1686 * path element is placed into a queue of length one to await the
1687 * calculation of the following element. At that time, the darkening
1688 * offset of the following element is known and joins can be computed,
1689 * including possible modification of this element, before mapping to
1690 * Device Space (DS) and passing it on to the outline consumer.
1691 *
1692 */
1693 FT_LOCAL_DEF( void )
1694 cf2_glyphpath_moveTo( CF2_GlyphPath glyphpath,
1695 CF2_Fixed x,
1696 CF2_Fixed y )
1697 {
1698 cf2_glyphpath_closeOpenPath( glyphpath );
1699
1700 /* save the parameters of the move for later, when we'll know how to */
1701 /* offset it; */
1702 /* also save last move point */
1703 glyphpath->currentCS.x = glyphpath->start.x = x;
1704 glyphpath->currentCS.y = glyphpath->start.y = y;
1705
1706 glyphpath->moveIsPending = TRUE;
1707
1708 /* ensure we have a valid map with current mask */
1709 if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) ||
1710 cf2_hintmask_isNew( glyphpath->hintMask ) )
1711 cf2_hintmap_build( &glyphpath->hintMap,
1712 glyphpath->hStemHintArray,
1713 glyphpath->vStemHintArray,
1714 glyphpath->hintMask,
1715 glyphpath->hintOriginY,
1716 FALSE );
1717
1718 /* save a copy of current HintMap to use when drawing initial point */
1719 glyphpath->firstHintMap = glyphpath->hintMap; /* structure copy */
1720 }
1721
1722
1723 FT_LOCAL_DEF( void )
1724 cf2_glyphpath_lineTo( CF2_GlyphPath glyphpath,
1725 CF2_Fixed x,
1726 CF2_Fixed y )
1727 {
1728 CF2_Fixed xOffset, yOffset;
1729 FT_Vector P0, P1;
1730 FT_Bool newHintMap;
1731
1732 /*
1733 * New hints will be applied after cf2_glyphpath_pushPrevElem has run.
1734 * In case this is a synthesized closing line, any new hints should be
1735 * delayed until this path is closed (`cf2_hintmask_isNew' will be
1736 * called again before the next line or curve).
1737 */
1738
1739 /* true if new hint map not on close */
1740 newHintMap = cf2_hintmask_isNew( glyphpath->hintMask ) &&
1741 !glyphpath->pathIsClosing;
1742
1743 /*
1744 * Zero-length lines may occur in the charstring. Because we cannot
1745 * compute darkening offsets or intersections from zero-length lines,
1746 * it is best to remove them and avoid artifacts. However, zero-length
1747 * lines in CS at the start of a new hint map can generate non-zero
1748 * lines in DS due to hint substitution. We detect a change in hint
1749 * map here and pass those zero-length lines along.
1750 */
1751
1752 /*
1753 * Note: Find explicitly closed paths here with a conditional
1754 * breakpoint using
1755 *
1756 * !gp->pathIsClosing && gp->start.x == x && gp->start.y == y
1757 *
1758 */
1759
1760 if ( glyphpath->currentCS.x == x &&
1761 glyphpath->currentCS.y == y &&
1762 !newHintMap )
1763 /*
1764 * Ignore zero-length lines in CS where the hint map is the same
1765 * because the line in DS will also be zero length.
1766 *
1767 * Ignore zero-length lines when we synthesize a closing line because
1768 * the close will be handled in cf2_glyphPath_pushPrevElem.
1769 */
1770 return;
1771
1772 cf2_glyphpath_computeOffset( glyphpath,
1773 glyphpath->currentCS.x,
1774 glyphpath->currentCS.y,
1775 x,
1776 y,
1777 &xOffset,
1778 &yOffset );
1779
1780 /* construct offset points */
1781 P0.x = ADD_INT32( glyphpath->currentCS.x, xOffset );
1782 P0.y = ADD_INT32( glyphpath->currentCS.y, yOffset );
1783 P1.x = ADD_INT32( x, xOffset );
1784 P1.y = ADD_INT32( y, yOffset );
1785
1786 if ( glyphpath->moveIsPending )
1787 {
1788 /* emit offset 1st point as MoveTo */
1789 cf2_glyphpath_pushMove( glyphpath, P0 );
1790
1791 glyphpath->moveIsPending = FALSE; /* adjust state machine */
1792 glyphpath->pathIsOpen = TRUE;
1793
1794 glyphpath->offsetStart1 = P1; /* record second point */
1795 }
1796
1797 if ( glyphpath->elemIsQueued )
1798 {
1799 FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) ||
1800 glyphpath->hintMap.count == 0 );
1801
1802 cf2_glyphpath_pushPrevElem( glyphpath,
1803 &glyphpath->hintMap,
1804 &P0,
1805 P1,
1806 FALSE );
1807 }
1808
1809 /* queue the current element with offset points */
1810 glyphpath->elemIsQueued = TRUE;
1811 glyphpath->prevElemOp = CF2_PathOpLineTo;
1812 glyphpath->prevElemP0 = P0;
1813 glyphpath->prevElemP1 = P1;
1814
1815 /* update current map */
1816 if ( newHintMap )
1817 cf2_hintmap_build( &glyphpath->hintMap,
1818 glyphpath->hStemHintArray,
1819 glyphpath->vStemHintArray,
1820 glyphpath->hintMask,
1821 glyphpath->hintOriginY,
1822 FALSE );
1823
1824 glyphpath->currentCS.x = x; /* pre-offset current point */
1825 glyphpath->currentCS.y = y;
1826 }
1827
1828
1829 FT_LOCAL_DEF( void )
1830 cf2_glyphpath_curveTo( CF2_GlyphPath glyphpath,
1831 CF2_Fixed x1,
1832 CF2_Fixed y1,
1833 CF2_Fixed x2,
1834 CF2_Fixed y2,
1835 CF2_Fixed x3,
1836 CF2_Fixed y3 )
1837 {
1838 CF2_Fixed xOffset1, yOffset1, xOffset3, yOffset3;
1839 FT_Vector P0, P1, P2, P3;
1840
1841
1842 /* TODO: ignore zero length portions of curve?? */
1843 cf2_glyphpath_computeOffset( glyphpath,
1844 glyphpath->currentCS.x,
1845 glyphpath->currentCS.y,
1846 x1,
1847 y1,
1848 &xOffset1,
1849 &yOffset1 );
1850 cf2_glyphpath_computeOffset( glyphpath,
1851 x2,
1852 y2,
1853 x3,
1854 y3,
1855 &xOffset3,
1856 &yOffset3 );
1857
1858 /* add momentum from the middle segment */
1859 glyphpath->callbacks->windingMomentum =
1860 ADD_INT32( glyphpath->callbacks->windingMomentum,
1861 cf2_getWindingMomentum( x1, y1, x2, y2 ) );
1862
1863 /* construct offset points */
1864 P0.x = ADD_INT32( glyphpath->currentCS.x, xOffset1 );
1865 P0.y = ADD_INT32( glyphpath->currentCS.y, yOffset1 );
1866 P1.x = ADD_INT32( x1, xOffset1 );
1867 P1.y = ADD_INT32( y1, yOffset1 );
1868 /* note: preserve angle of final segment by using offset3 at both ends */
1869 P2.x = ADD_INT32( x2, xOffset3 );
1870 P2.y = ADD_INT32( y2, yOffset3 );
1871 P3.x = ADD_INT32( x3, xOffset3 );
1872 P3.y = ADD_INT32( y3, yOffset3 );
1873
1874 if ( glyphpath->moveIsPending )
1875 {
1876 /* emit offset 1st point as MoveTo */
1877 cf2_glyphpath_pushMove( glyphpath, P0 );
1878
1879 glyphpath->moveIsPending = FALSE;
1880 glyphpath->pathIsOpen = TRUE;
1881
1882 glyphpath->offsetStart1 = P1; /* record second point */
1883 }
1884
1885 if ( glyphpath->elemIsQueued )
1886 {
1887 FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) ||
1888 glyphpath->hintMap.count == 0 );
1889
1890 cf2_glyphpath_pushPrevElem( glyphpath,
1891 &glyphpath->hintMap,
1892 &P0,
1893 P1,
1894 FALSE );
1895 }
1896
1897 /* queue the current element with offset points */
1898 glyphpath->elemIsQueued = TRUE;
1899 glyphpath->prevElemOp = CF2_PathOpCubeTo;
1900 glyphpath->prevElemP0 = P0;
1901 glyphpath->prevElemP1 = P1;
1902 glyphpath->prevElemP2 = P2;
1903 glyphpath->prevElemP3 = P3;
1904
1905 /* update current map */
1906 if ( cf2_hintmask_isNew( glyphpath->hintMask ) )
1907 cf2_hintmap_build( &glyphpath->hintMap,
1908 glyphpath->hStemHintArray,
1909 glyphpath->vStemHintArray,
1910 glyphpath->hintMask,
1911 glyphpath->hintOriginY,
1912 FALSE );
1913
1914 glyphpath->currentCS.x = x3; /* pre-offset current point */
1915 glyphpath->currentCS.y = y3;
1916 }
1917
1918
1919 FT_LOCAL_DEF( void )
1920 cf2_glyphpath_closeOpenPath( CF2_GlyphPath glyphpath )
1921 {
1922 if ( glyphpath->pathIsOpen )
1923 {
1924 /*
1925 * A closing line in Character Space line is always generated below
1926 * with `cf2_glyphPath_lineTo'. It may be ignored later if it turns
1927 * out to be zero length in Device Space.
1928 */
1929 glyphpath->pathIsClosing = TRUE;
1930
1931 cf2_glyphpath_lineTo( glyphpath,
1932 glyphpath->start.x,
1933 glyphpath->start.y );
1934
1935 /* empty the final element from the queue and close the path */
1936 if ( glyphpath->elemIsQueued )
1937 cf2_glyphpath_pushPrevElem( glyphpath,
1938 &glyphpath->hintMap,
1939 &glyphpath->offsetStart0,
1940 glyphpath->offsetStart1,
1941 TRUE );
1942
1943 /* reset state machine */
1944 glyphpath->moveIsPending = TRUE;
1945 glyphpath->pathIsOpen = FALSE;
1946 glyphpath->pathIsClosing = FALSE;
1947 glyphpath->elemIsQueued = FALSE;
1948 }
1949 }
1950
1951
1952/* END */
1953