projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Sync with trunk (aka 'I want my virtualbox mouse integration too')
[reactos.git] / lib / 3rdparty / freetype / src / raster / ftraster.c
1 /***************************************************************************/
2 /* */
3 /* ftraster.c */
4 /* */
5 /* The FreeType glyph rasterizer (body). */
6 /* */
7 /* Copyright 1996-2001, 2002, 2003, 2005, 2007 by */
8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
9 /* */
10 /* This file is part of the FreeType project, and may only be used, */
11 /* modified, and distributed under the terms of the FreeType project */
12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
13 /* this file you indicate that you have read the license and */
14 /* understand and accept it fully. */
15 /* */
16 /***************************************************************************/
17
18 /*************************************************************************/
19 /* */
20 /* This file can be compiled without the rest of the FreeType engine, by */
21 /* defining the _STANDALONE_ macro when compiling it. You also need to */
22 /* put the files `ftimage.h' and `ftmisc.h' into the $(incdir) */
23 /* directory. Typically, you should do something like */
24 /* */
25 /* - copy `src/raster/ftraster.c' (this file) to your current directory */
26 /* */
27 /* - copy `include/freetype/ftimage.h' and `src/raster/ftmisc.h' */
28 /* to your current directory */
29 /* */
30 /* - compile `ftraster' with the _STANDALONE_ macro defined, as in */
31 /* */
32 /* cc -c -D_STANDALONE_ ftraster.c */
33 /* */
34 /* The renderer can be initialized with a call to */
35 /* `ft_standard_raster.raster_new'; a bitmap can be generated */
36 /* with a call to `ft_standard_raster.raster_render'. */
37 /* */
38 /* See the comments and documentation in the file `ftimage.h' for more */
39 /* details on how the raster works. */
40 /* */
41 /*************************************************************************/
42
43
44 /*************************************************************************/
45 /* */
46 /* This is a rewrite of the FreeType 1.x scan-line converter */
47 /* */
48 /*************************************************************************/
49
50 #ifdef _STANDALONE_
51
52 #include "ftmisc.h"
53 #include "ftimage.h"
54
55 #else /* !_STANDALONE_ */
56
57 #include <ft2build.h>
58 #include "ftraster.h"
59 #include FT_INTERNAL_CALC_H /* for FT_MulDiv only */
60
61 #endif /* !_STANDALONE_ */
62
63
64 /*************************************************************************/
65 /* */
66 /* A simple technical note on how the raster works */
67 /* ----------------------------------------------- */
68 /* */
69 /* Converting an outline into a bitmap is achieved in several steps: */
70 /* */
71 /* 1 - Decomposing the outline into successive `profiles'. Each */
72 /* profile is simply an array of scanline intersections on a given */
73 /* dimension. A profile's main attributes are */
74 /* */
75 /* o its scanline position boundaries, i.e. `Ymin' and `Ymax'. */
76 /* */
77 /* o an array of intersection coordinates for each scanline */
78 /* between `Ymin' and `Ymax'. */
79 /* */
80 /* o a direction, indicating whether it was built going `up' or */
81 /* `down', as this is very important for filling rules. */
82 /* */
83 /* 2 - Sweeping the target map's scanlines in order to compute segment */
84 /* `spans' which are then filled. Additionally, this pass */
85 /* performs drop-out control. */
86 /* */
87 /* The outline data is parsed during step 1 only. The profiles are */
88 /* built from the bottom of the render pool, used as a stack. The */
89 /* following graphics shows the profile list under construction: */
90 /* */
91 /* ____________________________________________________________ _ _ */
92 /* | | | | | */
93 /* | profile | coordinates for | profile | coordinates for |--> */
94 /* | 1 | profile 1 | 2 | profile 2 |--> */
95 /* |_________|___________________|_________|_________________|__ _ _ */
96 /* */
97 /* ^ ^ */
98 /* | | */
99 /* start of render pool top */
100 /* */
101 /* The top of the profile stack is kept in the `top' variable. */
102 /* */
103 /* As you can see, a profile record is pushed on top of the render */
104 /* pool, which is then followed by its coordinates/intersections. If */
105 /* a change of direction is detected in the outline, a new profile is */
106 /* generated until the end of the outline. */
107 /* */
108 /* Note that when all profiles have been generated, the function */
109 /* Finalize_Profile_Table() is used to record, for each profile, its */
110 /* bottom-most scanline as well as the scanline above its upmost */
111 /* boundary. These positions are called `y-turns' because they (sort */
112 /* of) correspond to local extrema. They are stored in a sorted list */
113 /* built from the top of the render pool as a downwards stack: */
114 /* */
115 /* _ _ _______________________________________ */
116 /* | | */
117 /* <--| sorted list of | */
118 /* <--| extrema scanlines | */
119 /* _ _ __________________|____________________| */
120 /* */
121 /* ^ ^ */
122 /* | | */
123 /* maxBuff sizeBuff = end of pool */
124 /* */
125 /* This list is later used during the sweep phase in order to */
126 /* optimize performance (see technical note on the sweep below). */
127 /* */
128 /* Of course, the raster detects whether the two stacks collide and */
129 /* handles the situation properly. */
130 /* */
131 /*************************************************************************/
132
133
134 /*************************************************************************/
135 /*************************************************************************/
136 /** **/
137 /** CONFIGURATION MACROS **/
138 /** **/
139 /*************************************************************************/
140 /*************************************************************************/
141
142 /* define DEBUG_RASTER if you want to compile a debugging version */
143 #define xxxDEBUG_RASTER
144
145 /* undefine FT_RASTER_OPTION_ANTI_ALIASING if you do not want to support */
146 /* 5-levels anti-aliasing */
147 #ifdef FT_CONFIG_OPTION_5_GRAY_LEVELS
148 #define FT_RASTER_OPTION_ANTI_ALIASING
149 #endif
150
151 /* The size of the two-lines intermediate bitmap used */
152 /* for anti-aliasing, in bytes. */
153 #define RASTER_GRAY_LINES 2048
154
155
156 /*************************************************************************/
157 /*************************************************************************/
158 /** **/
159 /** OTHER MACROS (do not change) **/
160 /** **/
161 /*************************************************************************/
162 /*************************************************************************/
163
164 /*************************************************************************/
165 /* */
166 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
167 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
168 /* messages during execution. */
169 /* */
170 #undef FT_COMPONENT
171 #define FT_COMPONENT trace_raster
172
173
174 #ifdef _STANDALONE_
175
176
177 /* This macro is used to indicate that a function parameter is unused. */
178 /* Its purpose is simply to reduce compiler warnings. Note also that */
179 /* simply defining it as `(void)x' doesn't avoid warnings with certain */
180 /* ANSI compilers (e.g. LCC). */
181 #define FT_UNUSED( x ) (x) = (x)
182
183 /* Disable the tracing mechanism for simplicity -- developers can */
184 /* activate it easily by redefining these two macros. */
185 #ifndef FT_ERROR
186 #define FT_ERROR( x ) do ; while ( 0 ) /* nothing */
187 #endif
188
189 #ifndef FT_TRACE
190 #define FT_TRACE( x ) do ; while ( 0 ) /* nothing */
191 #define FT_TRACE1( x ) do ; while ( 0 ) /* nothing */
192 #define FT_TRACE6( x ) do ; while ( 0 ) /* nothing */
193 #endif
194
195 #define Raster_Err_None 0
196 #define Raster_Err_Not_Ini -1
197 #define Raster_Err_Overflow -2
198 #define Raster_Err_Neg_Height -3
199 #define Raster_Err_Invalid -4
200 #define Raster_Err_Unsupported -5
201
202 #define ft_memset memset
203
204 #else /* _STANDALONE_ */
205
206
207 #include FT_INTERNAL_OBJECTS_H
208 #include FT_INTERNAL_DEBUG_H /* for FT_TRACE() and FT_ERROR() */
209
210 #include "rasterrs.h"
211
212 #define Raster_Err_None Raster_Err_Ok
213 #define Raster_Err_Not_Ini Raster_Err_Raster_Uninitialized
214 #define Raster_Err_Overflow Raster_Err_Raster_Overflow
215 #define Raster_Err_Neg_Height Raster_Err_Raster_Negative_Height
216 #define Raster_Err_Invalid Raster_Err_Invalid_Outline
217 #define Raster_Err_Unsupported Raster_Err_Cannot_Render_Glyph
218
219
220 #endif /* _STANDALONE_ */
221
222
223 #ifndef FT_MEM_SET
224 #define FT_MEM_SET( d, s, c ) ft_memset( d, s, c )
225 #endif
226
227 #ifndef FT_MEM_ZERO
228 #define FT_MEM_ZERO( dest, count ) FT_MEM_SET( dest, 0, count )
229 #endif
230
231 /* FMulDiv means `Fast MulDiv'; it is used in case where `b' is */
232 /* typically a small value and the result of a*b is known to fit into */
233 /* 32 bits. */
234 #define FMulDiv( a, b, c ) ( (a) * (b) / (c) )
235
236 /* On the other hand, SMulDiv means `Slow MulDiv', and is used typically */
237 /* for clipping computations. It simply uses the FT_MulDiv() function */
238 /* defined in `ftcalc.h'. */
239 #define SMulDiv FT_MulDiv
240
241 /* The rasterizer is a very general purpose component; please leave */
242 /* the following redefinitions there (you never know your target */
243 /* environment). */
244
245 #ifndef TRUE
246 #define TRUE 1
247 #endif
248
249 #ifndef FALSE
250 #define FALSE 0
251 #endif
252
253 #ifndef NULL
254 #define NULL (void*)0
255 #endif
256
257 #ifndef SUCCESS
258 #define SUCCESS 0
259 #endif
260
261 #ifndef FAILURE
262 #define FAILURE 1
263 #endif
264
265
266 #define MaxBezier 32 /* The maximum number of stacked Bezier curves. */
267 /* Setting this constant to more than 32 is a */
268 /* pure waste of space. */
269
270 #define Pixel_Bits 6 /* fractional bits of *input* coordinates */
271
272
273 /*************************************************************************/
274 /*************************************************************************/
275 /** **/
276 /** SIMPLE TYPE DECLARATIONS **/
277 /** **/
278 /*************************************************************************/
279 /*************************************************************************/
280
281 typedef int Int;
282 typedef unsigned int UInt;
283 typedef short Short;
284 typedef unsigned short UShort, *PUShort;
285 typedef long Long, *PLong;
286 typedef unsigned long ULong;
287
288 typedef unsigned char Byte, *PByte;
289 typedef char Bool;
290
291
292 typedef union Alignment_
293 {
294 long l;
295 void* p;
296 void (*f)(void);
297
298 } Alignment, *PAlignment;
299
300
301 typedef struct TPoint_
302 {
303 Long x;
304 Long y;
305
306 } TPoint;
307
308
309 typedef enum TFlow_
310 {
311 Flow_None = 0,
312 Flow_Up = 1,
313 Flow_Down = -1
314
315 } TFlow;
316
317
318 /* States of each line, arc, and profile */
319 typedef enum TStates_
320 {
321 Unknown_State,
322 Ascending_State,
323 Descending_State,
324 Flat_State
325
326 } TStates;
327
328
329 typedef struct TProfile_ TProfile;
330 typedef TProfile* PProfile;
331
332 struct TProfile_
333 {
334 FT_F26Dot6 X; /* current coordinate during sweep */
335 PProfile link; /* link to next profile - various purpose */
336 PLong offset; /* start of profile's data in render pool */
337 int flow; /* Profile orientation: Asc/Descending */
338 long height; /* profile's height in scanlines */
339 long start; /* profile's starting scanline */
340
341 unsigned countL; /* number of lines to step before this */
342 /* profile becomes drawable */
343
344 PProfile next; /* next profile in same contour, used */
345 /* during drop-out control */
346 };
347
348 typedef PProfile TProfileList;
349 typedef PProfile* PProfileList;
350
351
352 /* Simple record used to implement a stack of bands, required */
353 /* by the sub-banding mechanism */
354 typedef struct TBand_
355 {
356 Short y_min; /* band's minimum */
357 Short y_max; /* band's maximum */
358
359 } TBand;
360
361
362 #define AlignProfileSize \
363 ( ( sizeof ( TProfile ) + sizeof ( Alignment ) - 1 ) / sizeof ( long ) )
364
365
366 #ifdef FT_STATIC_RASTER
367
368
369 #define RAS_ARGS /* void */
370 #define RAS_ARG /* void */
371
372 #define RAS_VARS /* void */
373 #define RAS_VAR /* void */
374
375 #define FT_UNUSED_RASTER do ; while ( 0 )
376
377
378 #else /* FT_STATIC_RASTER */
379
380
381 #define RAS_ARGS PWorker worker,
382 #define RAS_ARG PWorker worker
383
384 #define RAS_VARS worker,
385 #define RAS_VAR worker
386
387 #define FT_UNUSED_RASTER FT_UNUSED( worker )
388
389
390 #endif /* FT_STATIC_RASTER */
391
392
393 typedef struct TWorker_ TWorker, *PWorker;
394
395
396 /* prototypes used for sweep function dispatch */
397 typedef void
398 Function_Sweep_Init( RAS_ARGS Short* min,
399 Short* max );
400
401 typedef void
402 Function_Sweep_Span( RAS_ARGS Short y,
403 FT_F26Dot6 x1,
404 FT_F26Dot6 x2,
405 PProfile left,
406 PProfile right );
407
408 typedef void
409 Function_Sweep_Step( RAS_ARG );
410
411
412 /* NOTE: These operations are only valid on 2's complement processors */
413
414 #define FLOOR( x ) ( (x) & -ras.precision )
415 #define CEILING( x ) ( ( (x) + ras.precision - 1 ) & -ras.precision )
416 #define TRUNC( x ) ( (signed long)(x) >> ras.precision_bits )
417 #define FRAC( x ) ( (x) & ( ras.precision - 1 ) )
418 #define SCALED( x ) ( ( (x) << ras.scale_shift ) - ras.precision_half )
419
420 /* Note that I have moved the location of some fields in the */
421 /* structure to ensure that the most used variables are used */
422 /* at the top. Thus, their offset can be coded with less */
423 /* opcodes, and it results in a smaller executable. */
424
425 struct TWorker_
426 {
427 Int precision_bits; /* precision related variables */
428 Int precision;
429 Int precision_half;
430 Long precision_mask;
431 Int precision_shift;
432 Int precision_step;
433 Int precision_jitter;
434
435 Int scale_shift; /* == precision_shift for bitmaps */
436 /* == precision_shift+1 for pixmaps */
437
438 PLong buff; /* The profiles buffer */
439 PLong sizeBuff; /* Render pool size */
440 PLong maxBuff; /* Profiles buffer size */
441 PLong top; /* Current cursor in buffer */
442
443 FT_Error error;
444
445 Int numTurns; /* number of Y-turns in outline */
446
447 TPoint* arc; /* current Bezier arc pointer */
448
449 UShort bWidth; /* target bitmap width */
450 PByte bTarget; /* target bitmap buffer */
451 PByte gTarget; /* target pixmap buffer */
452
453 Long lastX, lastY, minY, maxY;
454
455 UShort num_Profs; /* current number of profiles */
456
457 Bool fresh; /* signals a fresh new profile which */
458 /* 'start' field must be completed */
459 Bool joint; /* signals that the last arc ended */
460 /* exactly on a scanline. Allows */
461 /* removal of doublets */
462 PProfile cProfile; /* current profile */
463 PProfile fProfile; /* head of linked list of profiles */
464 PProfile gProfile; /* contour's first profile in case */
465 /* of impact */
466
467 TStates state; /* rendering state */
468
469 FT_Bitmap target; /* description of target bit/pixmap */
470 FT_Outline outline;
471
472 Long traceOfs; /* current offset in target bitmap */
473 Long traceG; /* current offset in target pixmap */
474
475 Short traceIncr; /* sweep's increment in target bitmap */
476
477 Short gray_min_x; /* current min x during gray rendering */
478 Short gray_max_x; /* current max x during gray rendering */
479
480 /* dispatch variables */
481
482 Function_Sweep_Init* Proc_Sweep_Init;
483 Function_Sweep_Span* Proc_Sweep_Span;
484 Function_Sweep_Span* Proc_Sweep_Drop;
485 Function_Sweep_Step* Proc_Sweep_Step;
486
487 Byte dropOutControl; /* current drop_out control method */
488
489 Bool second_pass; /* indicates whether a horizontal pass */
490 /* should be performed to control */
491 /* drop-out accurately when calling */
492 /* Render_Glyph. Note that there is */
493 /* no horizontal pass during gray */
494 /* rendering. */
495
496 TPoint arcs[3 * MaxBezier + 1]; /* The Bezier stack */
497
498 TBand band_stack[16]; /* band stack used for sub-banding */
499 Int band_top; /* band stack top */
500
501 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
502
503 Byte* grays;
504
505 Byte gray_lines[RASTER_GRAY_LINES];
506 /* Intermediate table used to render the */
507 /* graylevels pixmaps. */
508 /* gray_lines is a buffer holding two */
509 /* monochrome scanlines */
510
511 Short gray_width; /* width in bytes of one monochrome */
512 /* intermediate scanline of gray_lines. */
513 /* Each gray pixel takes 2 bits long there */
514
515 /* The gray_lines must hold 2 lines, thus with size */
516 /* in bytes of at least `gray_width*2'. */
517
518 #endif /* FT_RASTER_ANTI_ALIASING */
519
520 };
521
522
523 typedef struct TRaster_
524 {
525 char* buffer;
526 long buffer_size;
527 void* memory;
528 PWorker worker;
529 Byte grays[5];
530 Short gray_width;
531
532 } TRaster, *PRaster;
533
534 #ifdef FT_STATIC_RASTER
535
536 static TWorker cur_ras;
537 #define ras cur_ras
538
539 #else
540
541 #define ras (*worker)
542
543 #endif /* FT_STATIC_RASTER */
544
545
546 static const char count_table[256] =
547 {
548 0 , 1 , 1 , 2 , 1 , 2 , 2 , 3 , 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4,
549 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5,
550 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5,
551 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
552 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5,
553 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
554 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
555 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7,
556 1 , 2 , 2 , 3 , 2 , 3 , 3 , 4 , 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5,
557 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
558 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
559 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7,
560 2 , 3 , 3 , 4 , 3 , 4 , 4 , 5 , 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6,
561 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7,
562 3 , 4 , 4 , 5 , 4 , 5 , 5 , 6 , 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7,
563 4 , 5 , 5 , 6 , 5 , 6 , 6 , 7 , 5 , 6 , 6 , 7 , 6 , 7 , 7 , 8 };
564
565
566
567 /*************************************************************************/
568 /*************************************************************************/
569 /** **/
570 /** PROFILES COMPUTATION **/
571 /** **/
572 /*************************************************************************/
573 /*************************************************************************/
574
575
576 /*************************************************************************/
577 /* */
578 /* <Function> */
579 /* Set_High_Precision */
580 /* */
581 /* <Description> */
582 /* Sets precision variables according to param flag. */
583 /* */
584 /* <Input> */
585 /* High :: Set to True for high precision (typically for ppem < 18), */
586 /* false otherwise. */
587 /* */
588 static void
589 Set_High_Precision( RAS_ARGS Int High )
590 {
591 if ( High )
592 {
593 ras.precision_bits = 10;
594 ras.precision_step = 128;
595 ras.precision_jitter = 24;
596 }
597 else
598 {
599 ras.precision_bits = 6;
600 ras.precision_step = 32;
601 ras.precision_jitter = 2;
602 }
603
604 FT_TRACE6(( "Set_High_Precision(%s)\n", High ? "true" : "false" ));
605
606 ras.precision = 1 << ras.precision_bits;
607 ras.precision_half = ras.precision / 2;
608 ras.precision_shift = ras.precision_bits - Pixel_Bits;
609 ras.precision_mask = -ras.precision;
610 }
611
612
613 /*************************************************************************/
614 /* */
615 /* <Function> */
616 /* New_Profile */
617 /* */
618 /* <Description> */
619 /* Creates a new profile in the render pool. */
620 /* */
621 /* <Input> */
622 /* aState :: The state/orientation of the new profile. */
623 /* */
624 /* <Return> */
625 /* SUCCESS on success. FAILURE in case of overflow or of incoherent */
626 /* profile. */
627 /* */
628 static Bool
629 New_Profile( RAS_ARGS TStates aState )
630 {
631 if ( !ras.fProfile )
632 {
633 ras.cProfile = (PProfile)ras.top;
634 ras.fProfile = ras.cProfile;
635 ras.top += AlignProfileSize;
636 }
637
638 if ( ras.top >= ras.maxBuff )
639 {
640 ras.error = Raster_Err_Overflow;
641 return FAILURE;
642 }
643
644 switch ( aState )
645 {
646 case Ascending_State:
647 ras.cProfile->flow = Flow_Up;
648 FT_TRACE6(( "New ascending profile = %lx\n", (long)ras.cProfile ));
649 break;
650
651 case Descending_State:
652 ras.cProfile->flow = Flow_Down;
653 FT_TRACE6(( "New descending profile = %lx\n", (long)ras.cProfile ));
654 break;
655
656 default:
657 FT_ERROR(( "New_Profile: invalid profile direction!\n" ));
658 ras.error = Raster_Err_Invalid;
659 return FAILURE;
660 }
661
662 ras.cProfile->start = 0;
663 ras.cProfile->height = 0;
664 ras.cProfile->offset = ras.top;
665 ras.cProfile->link = (PProfile)0;
666 ras.cProfile->next = (PProfile)0;
667
668 if ( !ras.gProfile )
669 ras.gProfile = ras.cProfile;
670
671 ras.state = aState;
672 ras.fresh = TRUE;
673 ras.joint = FALSE;
674
675 return SUCCESS;
676 }
677
678
679 /*************************************************************************/
680 /* */
681 /* <Function> */
682 /* End_Profile */
683 /* */
684 /* <Description> */
685 /* Finalizes the current profile. */
686 /* */
687 /* <Return> */
688 /* SUCCESS on success. FAILURE in case of overflow or incoherency. */
689 /* */
690 static Bool
691 End_Profile( RAS_ARG )
692 {
693 Long h;
694 PProfile oldProfile;
695
696
697 h = (Long)( ras.top - ras.cProfile->offset );
698
699 if ( h < 0 )
700 {
701 FT_ERROR(( "End_Profile: negative height encountered!\n" ));
702 ras.error = Raster_Err_Neg_Height;
703 return FAILURE;
704 }
705
706 if ( h > 0 )
707 {
708 FT_TRACE6(( "Ending profile %lx, start = %ld, height = %ld\n",
709 (long)ras.cProfile, ras.cProfile->start, h ));
710
711 oldProfile = ras.cProfile;
712 ras.cProfile->height = h;
713 ras.cProfile = (PProfile)ras.top;
714
715 ras.top += AlignProfileSize;
716
717 ras.cProfile->height = 0;
718 ras.cProfile->offset = ras.top;
719 oldProfile->next = ras.cProfile;
720 ras.num_Profs++;
721 }
722
723 if ( ras.top >= ras.maxBuff )
724 {
725 FT_TRACE1(( "overflow in End_Profile\n" ));
726 ras.error = Raster_Err_Overflow;
727 return FAILURE;
728 }
729
730 ras.joint = FALSE;
731
732 return SUCCESS;
733 }
734
735
736 /*************************************************************************/
737 /* */
738 /* <Function> */
739 /* Insert_Y_Turn */
740 /* */
741 /* <Description> */
742 /* Inserts a salient into the sorted list placed on top of the render */
743 /* pool. */
744 /* */
745 /* <Input> */
746 /* New y scanline position. */
747 /* */
748 /* <Return> */
749 /* SUCCESS on success. FAILURE in case of overflow. */
750 /* */
751 static Bool
752 Insert_Y_Turn( RAS_ARGS Int y )
753 {
754 PLong y_turns;
755 Int y2, n;
756
757
758 n = ras.numTurns - 1;
759 y_turns = ras.sizeBuff - ras.numTurns;
760
761 /* look for first y value that is <= */
762 while ( n >= 0 && y < y_turns[n] )
763 n--;
764
765 /* if it is <, simply insert it, ignore if == */
766 if ( n >= 0 && y > y_turns[n] )
767 while ( n >= 0 )
768 {
769 y2 = (Int)y_turns[n];
770 y_turns[n] = y;
771 y = y2;
772 n--;
773 }
774
775 if ( n < 0 )
776 {
777 ras.maxBuff--;
778 if ( ras.maxBuff <= ras.top )
779 {
780 ras.error = Raster_Err_Overflow;
781 return FAILURE;
782 }
783 ras.numTurns++;
784 ras.sizeBuff[-ras.numTurns] = y;
785 }
786
787 return SUCCESS;
788 }
789
790
791 /*************************************************************************/
792 /* */
793 /* <Function> */
794 /* Finalize_Profile_Table */
795 /* */
796 /* <Description> */
797 /* Adjusts all links in the profiles list. */
798 /* */
799 /* <Return> */
800 /* SUCCESS on success. FAILURE in case of overflow. */
801 /* */
802 static Bool
803 Finalize_Profile_Table( RAS_ARG )
804 {
805 Int bottom, top;
806 UShort n;
807 PProfile p;
808
809
810 n = ras.num_Profs;
811
812 if ( n > 1 )
813 {
814 p = ras.fProfile;
815 while ( n > 0 )
816 {
817 if ( n > 1 )
818 p->link = (PProfile)( p->offset + p->height );
819 else
820 p->link = NULL;
821
822 switch ( p->flow )
823 {
824 case Flow_Down:
825 bottom = (Int)( p->start - p->height + 1 );
826 top = (Int)p->start;
827 p->start = bottom;
828 p->offset += p->height - 1;
829 break;
830
831 case Flow_Up:
832 default:
833 bottom = (Int)p->start;
834 top = (Int)( p->start + p->height - 1 );
835 }
836
837 if ( Insert_Y_Turn( RAS_VARS bottom ) ||
838 Insert_Y_Turn( RAS_VARS top + 1 ) )
839 return FAILURE;
840
841 p = p->link;
842 n--;
843 }
844 }
845 else
846 ras.fProfile = NULL;
847
848 return SUCCESS;
849 }
850
851
852 /*************************************************************************/
853 /* */
854 /* <Function> */
855 /* Split_Conic */
856 /* */
857 /* <Description> */
858 /* Subdivides one conic Bezier into two joint sub-arcs in the Bezier */
859 /* stack. */
860 /* */
861 /* <Input> */
862 /* None (subdivided Bezier is taken from the top of the stack). */
863 /* */
864 /* <Note> */
865 /* This routine is the `beef' of this component. It is _the_ inner */
866 /* loop that should be optimized to hell to get the best performance. */
867 /* */
868 static void
869 Split_Conic( TPoint* base )
870 {
871 Long a, b;
872
873
874 base[4].x = base[2].x;
875 b = base[1].x;
876 a = base[3].x = ( base[2].x + b ) / 2;
877 b = base[1].x = ( base[0].x + b ) / 2;
878 base[2].x = ( a + b ) / 2;
879
880 base[4].y = base[2].y;
881 b = base[1].y;
882 a = base[3].y = ( base[2].y + b ) / 2;
883 b = base[1].y = ( base[0].y + b ) / 2;
884 base[2].y = ( a + b ) / 2;
885
886 /* hand optimized. gcc doesn't seem to be too good at common */
887 /* expression substitution and instruction scheduling ;-) */
888 }
889
890
891 /*************************************************************************/
892 /* */
893 /* <Function> */
894 /* Split_Cubic */
895 /* */
896 /* <Description> */
897 /* Subdivides a third-order Bezier arc into two joint sub-arcs in the */
898 /* Bezier stack. */
899 /* */
900 /* <Note> */
901 /* This routine is the `beef' of the component. It is one of _the_ */
902 /* inner loops that should be optimized like hell to get the best */
903 /* performance. */
904 /* */
905 static void
906 Split_Cubic( TPoint* base )
907 {
908 Long a, b, c, d;
909
910
911 base[6].x = base[3].x;
912 c = base[1].x;
913 d = base[2].x;
914 base[1].x = a = ( base[0].x + c + 1 ) >> 1;
915 base[5].x = b = ( base[3].x + d + 1 ) >> 1;
916 c = ( c + d + 1 ) >> 1;
917 base[2].x = a = ( a + c + 1 ) >> 1;
918 base[4].x = b = ( b + c + 1 ) >> 1;
919 base[3].x = ( a + b + 1 ) >> 1;
920
921 base[6].y = base[3].y;
922 c = base[1].y;
923 d = base[2].y;
924 base[1].y = a = ( base[0].y + c + 1 ) >> 1;
925 base[5].y = b = ( base[3].y + d + 1 ) >> 1;
926 c = ( c + d + 1 ) >> 1;
927 base[2].y = a = ( a + c + 1 ) >> 1;
928 base[4].y = b = ( b + c + 1 ) >> 1;
929 base[3].y = ( a + b + 1 ) >> 1;
930 }
931
932
933 /*************************************************************************/
934 /* */
935 /* <Function> */
936 /* Line_Up */
937 /* */
938 /* <Description> */
939 /* Computes the x-coordinates of an ascending line segment and stores */
940 /* them in the render pool. */
941 /* */
942 /* <Input> */
943 /* x1 :: The x-coordinate of the segment's start point. */
944 /* */
945 /* y1 :: The y-coordinate of the segment's start point. */
946 /* */
947 /* x2 :: The x-coordinate of the segment's end point. */
948 /* */
949 /* y2 :: The y-coordinate of the segment's end point. */
950 /* */
951 /* miny :: A lower vertical clipping bound value. */
952 /* */
953 /* maxy :: An upper vertical clipping bound value. */
954 /* */
955 /* <Return> */
956 /* SUCCESS on success, FAILURE on render pool overflow. */
957 /* */
958 static Bool
959 Line_Up( RAS_ARGS Long x1,
960 Long y1,
961 Long x2,
962 Long y2,
963 Long miny,
964 Long maxy )
965 {
966 Long Dx, Dy;
967 Int e1, e2, f1, f2, size; /* XXX: is `Short' sufficient? */
968 Long Ix, Rx, Ax;
969
970 PLong top;
971
972
973 Dx = x2 - x1;
974 Dy = y2 - y1;
975
976 if ( Dy <= 0 || y2 < miny || y1 > maxy )
977 return SUCCESS;
978
979 if ( y1 < miny )
980 {
981 /* Take care: miny-y1 can be a very large value; we use */
982 /* a slow MulDiv function to avoid clipping bugs */
983 x1 += SMulDiv( Dx, miny - y1, Dy );
984 e1 = (Int)TRUNC( miny );
985 f1 = 0;
986 }
987 else
988 {
989 e1 = (Int)TRUNC( y1 );
990 f1 = (Int)FRAC( y1 );
991 }
992
993 if ( y2 > maxy )
994 {
995 /* x2 += FMulDiv( Dx, maxy - y2, Dy ); UNNECESSARY */
996 e2 = (Int)TRUNC( maxy );
997 f2 = 0;
998 }
999 else
1000 {
1001 e2 = (Int)TRUNC( y2 );
1002 f2 = (Int)FRAC( y2 );
1003 }
1004
1005 if ( f1 > 0 )
1006 {
1007 if ( e1 == e2 )
1008 return SUCCESS;
1009 else
1010 {
1011 x1 += FMulDiv( Dx, ras.precision - f1, Dy );
1012 e1 += 1;
1013 }
1014 }
1015 else
1016 if ( ras.joint )
1017 {
1018 ras.top--;
1019 ras.joint = FALSE;
1020 }
1021
1022 ras.joint = (char)( f2 == 0 );
1023
1024 if ( ras.fresh )
1025 {
1026 ras.cProfile->start = e1;
1027 ras.fresh = FALSE;
1028 }
1029
1030 size = e2 - e1 + 1;
1031 if ( ras.top + size >= ras.maxBuff )
1032 {
1033 ras.error = Raster_Err_Overflow;
1034 return FAILURE;
1035 }
1036
1037 if ( Dx > 0 )
1038 {
1039 Ix = ( ras.precision * Dx ) / Dy;
1040 Rx = ( ras.precision * Dx ) % Dy;
1041 Dx = 1;
1042 }
1043 else
1044 {
1045 Ix = -( ( ras.precision * -Dx ) / Dy );
1046 Rx = ( ras.precision * -Dx ) % Dy;
1047 Dx = -1;
1048 }
1049
1050 Ax = -Dy;
1051 top = ras.top;
1052
1053 while ( size > 0 )
1054 {
1055 *top++ = x1;
1056
1057 x1 += Ix;
1058 Ax += Rx;
1059 if ( Ax >= 0 )
1060 {
1061 Ax -= Dy;
1062 x1 += Dx;
1063 }
1064 size--;
1065 }
1066
1067 ras.top = top;
1068 return SUCCESS;
1069 }
1070
1071
1072 /*************************************************************************/
1073 /* */
1074 /* <Function> */
1075 /* Line_Down */
1076 /* */
1077 /* <Description> */
1078 /* Computes the x-coordinates of an descending line segment and */
1079 /* stores them in the render pool. */
1080 /* */
1081 /* <Input> */
1082 /* x1 :: The x-coordinate of the segment's start point. */
1083 /* */
1084 /* y1 :: The y-coordinate of the segment's start point. */
1085 /* */
1086 /* x2 :: The x-coordinate of the segment's end point. */
1087 /* */
1088 /* y2 :: The y-coordinate of the segment's end point. */
1089 /* */
1090 /* miny :: A lower vertical clipping bound value. */
1091 /* */
1092 /* maxy :: An upper vertical clipping bound value. */
1093 /* */
1094 /* <Return> */
1095 /* SUCCESS on success, FAILURE on render pool overflow. */
1096 /* */
1097 static Bool
1098 Line_Down( RAS_ARGS Long x1,
1099 Long y1,
1100 Long x2,
1101 Long y2,
1102 Long miny,
1103 Long maxy )
1104 {
1105 Bool result, fresh;
1106
1107
1108 fresh = ras.fresh;
1109
1110 result = Line_Up( RAS_VARS x1, -y1, x2, -y2, -maxy, -miny );
1111
1112 if ( fresh && !ras.fresh )
1113 ras.cProfile->start = -ras.cProfile->start;
1114
1115 return result;
1116 }
1117
1118
1119 /* A function type describing the functions used to split Bezier arcs */
1120 typedef void (*TSplitter)( TPoint* base );
1121
1122
1123 /*************************************************************************/
1124 /* */
1125 /* <Function> */
1126 /* Bezier_Up */
1127 /* */
1128 /* <Description> */
1129 /* Computes the x-coordinates of an ascending Bezier arc and stores */
1130 /* them in the render pool. */
1131 /* */
1132 /* <Input> */
1133 /* degree :: The degree of the Bezier arc (either 2 or 3). */
1134 /* */
1135 /* splitter :: The function to split Bezier arcs. */
1136 /* */
1137 /* miny :: A lower vertical clipping bound value. */
1138 /* */
1139 /* maxy :: An upper vertical clipping bound value. */
1140 /* */
1141 /* <Return> */
1142 /* SUCCESS on success, FAILURE on render pool overflow. */
1143 /* */
1144 static Bool
1145 Bezier_Up( RAS_ARGS Int degree,
1146 TSplitter splitter,
1147 Long miny,
1148 Long maxy )
1149 {
1150 Long y1, y2, e, e2, e0;
1151 Short f1;
1152
1153 TPoint* arc;
1154 TPoint* start_arc;
1155
1156 PLong top;
1157
1158
1159 arc = ras.arc;
1160 y1 = arc[degree].y;
1161 y2 = arc[0].y;
1162 top = ras.top;
1163
1164 if ( y2 < miny || y1 > maxy )
1165 goto Fin;
1166
1167 e2 = FLOOR( y2 );
1168
1169 if ( e2 > maxy )
1170 e2 = maxy;
1171
1172 e0 = miny;
1173
1174 if ( y1 < miny )
1175 e = miny;
1176 else
1177 {
1178 e = CEILING( y1 );
1179 f1 = (Short)( FRAC( y1 ) );
1180 e0 = e;
1181
1182 if ( f1 == 0 )
1183 {
1184 if ( ras.joint )
1185 {
1186 top--;
1187 ras.joint = FALSE;
1188 }
1189
1190 *top++ = arc[degree].x;
1191
1192 e += ras.precision;
1193 }
1194 }
1195
1196 if ( ras.fresh )
1197 {
1198 ras.cProfile->start = TRUNC( e0 );
1199 ras.fresh = FALSE;
1200 }
1201
1202 if ( e2 < e )
1203 goto Fin;
1204
1205 if ( ( top + TRUNC( e2 - e ) + 1 ) >= ras.maxBuff )
1206 {
1207 ras.top = top;
1208 ras.error = Raster_Err_Overflow;
1209 return FAILURE;
1210 }
1211
1212 start_arc = arc;
1213
1214 while ( arc >= start_arc && e <= e2 )
1215 {
1216 ras.joint = FALSE;
1217
1218 y2 = arc[0].y;
1219
1220 if ( y2 > e )
1221 {
1222 y1 = arc[degree].y;
1223 if ( y2 - y1 >= ras.precision_step )
1224 {
1225 splitter( arc );
1226 arc += degree;
1227 }
1228 else
1229 {
1230 *top++ = arc[degree].x + FMulDiv( arc[0].x-arc[degree].x,
1231 e - y1, y2 - y1 );
1232 arc -= degree;
1233 e += ras.precision;
1234 }
1235 }
1236 else
1237 {
1238 if ( y2 == e )
1239 {
1240 ras.joint = TRUE;
1241 *top++ = arc[0].x;
1242
1243 e += ras.precision;
1244 }
1245 arc -= degree;
1246 }
1247 }
1248
1249 Fin:
1250 ras.top = top;
1251 ras.arc -= degree;
1252 return SUCCESS;
1253 }
1254
1255
1256 /*************************************************************************/
1257 /* */
1258 /* <Function> */
1259 /* Bezier_Down */
1260 /* */
1261 /* <Description> */
1262 /* Computes the x-coordinates of an descending Bezier arc and stores */
1263 /* them in the render pool. */
1264 /* */
1265 /* <Input> */
1266 /* degree :: The degree of the Bezier arc (either 2 or 3). */
1267 /* */
1268 /* splitter :: The function to split Bezier arcs. */
1269 /* */
1270 /* miny :: A lower vertical clipping bound value. */
1271 /* */
1272 /* maxy :: An upper vertical clipping bound value. */
1273 /* */
1274 /* <Return> */
1275 /* SUCCESS on success, FAILURE on render pool overflow. */
1276 /* */
1277 static Bool
1278 Bezier_Down( RAS_ARGS Int degree,
1279 TSplitter splitter,
1280 Long miny,
1281 Long maxy )
1282 {
1283 TPoint* arc = ras.arc;
1284 Bool result, fresh;
1285
1286
1287 arc[0].y = -arc[0].y;
1288 arc[1].y = -arc[1].y;
1289 arc[2].y = -arc[2].y;
1290 if ( degree > 2 )
1291 arc[3].y = -arc[3].y;
1292
1293 fresh = ras.fresh;
1294
1295 result = Bezier_Up( RAS_VARS degree, splitter, -maxy, -miny );
1296
1297 if ( fresh && !ras.fresh )
1298 ras.cProfile->start = -ras.cProfile->start;
1299
1300 arc[0].y = -arc[0].y;
1301 return result;
1302 }
1303
1304
1305 /*************************************************************************/
1306 /* */
1307 /* <Function> */
1308 /* Line_To */
1309 /* */
1310 /* <Description> */
1311 /* Injects a new line segment and adjusts Profiles list. */
1312 /* */
1313 /* <Input> */
1314 /* x :: The x-coordinate of the segment's end point (its start point */
1315 /* is stored in `lastX'). */
1316 /* */
1317 /* y :: The y-coordinate of the segment's end point (its start point */
1318 /* is stored in `lastY'). */
1319 /* */
1320 /* <Return> */
1321 /* SUCCESS on success, FAILURE on render pool overflow or incorrect */
1322 /* profile. */
1323 /* */
1324 static Bool
1325 Line_To( RAS_ARGS Long x,
1326 Long y )
1327 {
1328 /* First, detect a change of direction */
1329
1330 switch ( ras.state )
1331 {
1332 case Unknown_State:
1333 if ( y > ras.lastY )
1334 {
1335 if ( New_Profile( RAS_VARS Ascending_State ) )
1336 return FAILURE;
1337 }
1338 else
1339 {
1340 if ( y < ras.lastY )
1341 if ( New_Profile( RAS_VARS Descending_State ) )
1342 return FAILURE;
1343 }
1344 break;
1345
1346 case Ascending_State:
1347 if ( y < ras.lastY )
1348 {
1349 if ( End_Profile( RAS_VAR ) ||
1350 New_Profile( RAS_VARS Descending_State ) )
1351 return FAILURE;
1352 }
1353 break;
1354
1355 case Descending_State:
1356 if ( y > ras.lastY )
1357 {
1358 if ( End_Profile( RAS_VAR ) ||
1359 New_Profile( RAS_VARS Ascending_State ) )
1360 return FAILURE;
1361 }
1362 break;
1363
1364 default:
1365 ;
1366 }
1367
1368 /* Then compute the lines */
1369
1370 switch ( ras.state )
1371 {
1372 case Ascending_State:
1373 if ( Line_Up( RAS_VARS ras.lastX, ras.lastY,
1374 x, y, ras.minY, ras.maxY ) )
1375 return FAILURE;
1376 break;
1377
1378 case Descending_State:
1379 if ( Line_Down( RAS_VARS ras.lastX, ras.lastY,
1380 x, y, ras.minY, ras.maxY ) )
1381 return FAILURE;
1382 break;
1383
1384 default:
1385 ;
1386 }
1387
1388 ras.lastX = x;
1389 ras.lastY = y;
1390
1391 return SUCCESS;
1392 }
1393
1394
1395 /*************************************************************************/
1396 /* */
1397 /* <Function> */
1398 /* Conic_To */
1399 /* */
1400 /* <Description> */
1401 /* Injects a new conic arc and adjusts the profile list. */
1402 /* */
1403 /* <Input> */
1404 /* cx :: The x-coordinate of the arc's new control point. */
1405 /* */
1406 /* cy :: The y-coordinate of the arc's new control point. */
1407 /* */
1408 /* x :: The x-coordinate of the arc's end point (its start point is */
1409 /* stored in `lastX'). */
1410 /* */
1411 /* y :: The y-coordinate of the arc's end point (its start point is */
1412 /* stored in `lastY'). */
1413 /* */
1414 /* <Return> */
1415 /* SUCCESS on success, FAILURE on render pool overflow or incorrect */
1416 /* profile. */
1417 /* */
1418 static Bool
1419 Conic_To( RAS_ARGS Long cx,
1420 Long cy,
1421 Long x,
1422 Long y )
1423 {
1424 Long y1, y2, y3, x3, ymin, ymax;
1425 TStates state_bez;
1426
1427
1428 ras.arc = ras.arcs;
1429 ras.arc[2].x = ras.lastX;
1430 ras.arc[2].y = ras.lastY;
1431 ras.arc[1].x = cx; ras.arc[1].y = cy;
1432 ras.arc[0].x = x; ras.arc[0].y = y;
1433
1434 do
1435 {
1436 y1 = ras.arc[2].y;
1437 y2 = ras.arc[1].y;
1438 y3 = ras.arc[0].y;
1439 x3 = ras.arc[0].x;
1440
1441 /* first, categorize the Bezier arc */
1442
1443 if ( y1 <= y3 )
1444 {
1445 ymin = y1;
1446 ymax = y3;
1447 }
1448 else
1449 {
1450 ymin = y3;
1451 ymax = y1;
1452 }
1453
1454 if ( y2 < ymin || y2 > ymax )
1455 {
1456 /* this arc has no given direction, split it! */
1457 Split_Conic( ras.arc );
1458 ras.arc += 2;
1459 }
1460 else if ( y1 == y3 )
1461 {
1462 /* this arc is flat, ignore it and pop it from the Bezier stack */
1463 ras.arc -= 2;
1464 }
1465 else
1466 {
1467 /* the arc is y-monotonous, either ascending or descending */
1468 /* detect a change of direction */
1469 state_bez = y1 < y3 ? Ascending_State : Descending_State;
1470 if ( ras.state != state_bez )
1471 {
1472 /* finalize current profile if any */
1473 if ( ras.state != Unknown_State &&
1474 End_Profile( RAS_VAR ) )
1475 goto Fail;
1476
1477 /* create a new profile */
1478 if ( New_Profile( RAS_VARS state_bez ) )
1479 goto Fail;
1480 }
1481
1482 /* now call the appropriate routine */
1483 if ( state_bez == Ascending_State )
1484 {
1485 if ( Bezier_Up( RAS_VARS 2, Split_Conic, ras.minY, ras.maxY ) )
1486 goto Fail;
1487 }
1488 else
1489 if ( Bezier_Down( RAS_VARS 2, Split_Conic, ras.minY, ras.maxY ) )
1490 goto Fail;
1491 }
1492
1493 } while ( ras.arc >= ras.arcs );
1494
1495 ras.lastX = x3;
1496 ras.lastY = y3;
1497
1498 return SUCCESS;
1499
1500 Fail:
1501 return FAILURE;
1502 }
1503
1504
1505 /*************************************************************************/
1506 /* */
1507 /* <Function> */
1508 /* Cubic_To */
1509 /* */
1510 /* <Description> */
1511 /* Injects a new cubic arc and adjusts the profile list. */
1512 /* */
1513 /* <Input> */
1514 /* cx1 :: The x-coordinate of the arc's first new control point. */
1515 /* */
1516 /* cy1 :: The y-coordinate of the arc's first new control point. */
1517 /* */
1518 /* cx2 :: The x-coordinate of the arc's second new control point. */
1519 /* */
1520 /* cy2 :: The y-coordinate of the arc's second new control point. */
1521 /* */
1522 /* x :: The x-coordinate of the arc's end point (its start point is */
1523 /* stored in `lastX'). */
1524 /* */
1525 /* y :: The y-coordinate of the arc's end point (its start point is */
1526 /* stored in `lastY'). */
1527 /* */
1528 /* <Return> */
1529 /* SUCCESS on success, FAILURE on render pool overflow or incorrect */
1530 /* profile. */
1531 /* */
1532 static Bool
1533 Cubic_To( RAS_ARGS Long cx1,
1534 Long cy1,
1535 Long cx2,
1536 Long cy2,
1537 Long x,
1538 Long y )
1539 {
1540 Long y1, y2, y3, y4, x4, ymin1, ymax1, ymin2, ymax2;
1541 TStates state_bez;
1542
1543
1544 ras.arc = ras.arcs;
1545 ras.arc[3].x = ras.lastX;
1546 ras.arc[3].y = ras.lastY;
1547 ras.arc[2].x = cx1; ras.arc[2].y = cy1;
1548 ras.arc[1].x = cx2; ras.arc[1].y = cy2;
1549 ras.arc[0].x = x; ras.arc[0].y = y;
1550
1551 do
1552 {
1553 y1 = ras.arc[3].y;
1554 y2 = ras.arc[2].y;
1555 y3 = ras.arc[1].y;
1556 y4 = ras.arc[0].y;
1557 x4 = ras.arc[0].x;
1558
1559 /* first, categorize the Bezier arc */
1560
1561 if ( y1 <= y4 )
1562 {
1563 ymin1 = y1;
1564 ymax1 = y4;
1565 }
1566 else
1567 {
1568 ymin1 = y4;
1569 ymax1 = y1;
1570 }
1571
1572 if ( y2 <= y3 )
1573 {
1574 ymin2 = y2;
1575 ymax2 = y3;
1576 }
1577 else
1578 {
1579 ymin2 = y3;
1580 ymax2 = y2;
1581 }
1582
1583 if ( ymin2 < ymin1 || ymax2 > ymax1 )
1584 {
1585 /* this arc has no given direction, split it! */
1586 Split_Cubic( ras.arc );
1587 ras.arc += 3;
1588 }
1589 else if ( y1 == y4 )
1590 {
1591 /* this arc is flat, ignore it and pop it from the Bezier stack */
1592 ras.arc -= 3;
1593 }
1594 else
1595 {
1596 state_bez = ( y1 <= y4 ) ? Ascending_State : Descending_State;
1597
1598 /* detect a change of direction */
1599 if ( ras.state != state_bez )
1600 {
1601 if ( ras.state != Unknown_State &&
1602 End_Profile( RAS_VAR ) )
1603 goto Fail;
1604
1605 if ( New_Profile( RAS_VARS state_bez ) )
1606 goto Fail;
1607 }
1608
1609 /* compute intersections */
1610 if ( state_bez == Ascending_State )
1611 {
1612 if ( Bezier_Up( RAS_VARS 3, Split_Cubic, ras.minY, ras.maxY ) )
1613 goto Fail;
1614 }
1615 else
1616 if ( Bezier_Down( RAS_VARS 3, Split_Cubic, ras.minY, ras.maxY ) )
1617 goto Fail;
1618 }
1619
1620 } while ( ras.arc >= ras.arcs );
1621
1622 ras.lastX = x4;
1623 ras.lastY = y4;
1624
1625 return SUCCESS;
1626
1627 Fail:
1628 return FAILURE;
1629 }
1630
1631
1632 #undef SWAP_
1633 #define SWAP_( x, y ) do \
1634 { \
1635 Long swap = x; \
1636 \
1637 \
1638 x = y; \
1639 y = swap; \
1640 } while ( 0 )
1641
1642
1643 /*************************************************************************/
1644 /* */
1645 /* <Function> */
1646 /* Decompose_Curve */
1647 /* */
1648 /* <Description> */
1649 /* Scans the outline arrays in order to emit individual segments and */
1650 /* Beziers by calling Line_To() and Bezier_To(). It handles all */
1651 /* weird cases, like when the first point is off the curve, or when */
1652 /* there are simply no `on' points in the contour! */
1653 /* */
1654 /* <Input> */
1655 /* first :: The index of the first point in the contour. */
1656 /* */
1657 /* last :: The index of the last point in the contour. */
1658 /* */
1659 /* flipped :: If set, flip the direction of the curve. */
1660 /* */
1661 /* <Return> */
1662 /* SUCCESS on success, FAILURE on error. */
1663 /* */
1664 static Bool
1665 Decompose_Curve( RAS_ARGS UShort first,
1666 UShort last,
1667 int flipped )
1668 {
1669 FT_Vector v_last;
1670 FT_Vector v_control;
1671 FT_Vector v_start;
1672
1673 FT_Vector* points;
1674 FT_Vector* point;
1675 FT_Vector* limit;
1676 char* tags;
1677
1678 unsigned tag; /* current point's state */
1679
1680
1681 points = ras.outline.points;
1682 limit = points + last;
1683
1684 v_start.x = SCALED( points[first].x );
1685 v_start.y = SCALED( points[first].y );
1686 v_last.x = SCALED( points[last].x );
1687 v_last.y = SCALED( points[last].y );
1688
1689 if ( flipped )
1690 {
1691 SWAP_( v_start.x, v_start.y );
1692 SWAP_( v_last.x, v_last.y );
1693 }
1694
1695 v_control = v_start;
1696
1697 point = points + first;
1698 tags = ras.outline.tags + first;
1699 tag = FT_CURVE_TAG( tags[0] );
1700
1701 /* A contour cannot start with a cubic control point! */
1702 if ( tag == FT_CURVE_TAG_CUBIC )
1703 goto Invalid_Outline;
1704
1705 /* check first point to determine origin */
1706 if ( tag == FT_CURVE_TAG_CONIC )
1707 {
1708 /* first point is conic control. Yes, this happens. */
1709 if ( FT_CURVE_TAG( ras.outline.tags[last] ) == FT_CURVE_TAG_ON )
1710 {
1711 /* start at last point if it is on the curve */
1712 v_start = v_last;
1713 limit--;
1714 }
1715 else
1716 {
1717 /* if both first and last points are conic, */
1718 /* start at their middle and record its position */
1719 /* for closure */
1720 v_start.x = ( v_start.x + v_last.x ) / 2;
1721 v_start.y = ( v_start.y + v_last.y ) / 2;
1722
1723 v_last = v_start;
1724 }
1725 point--;
1726 tags--;
1727 }
1728
1729 ras.lastX = v_start.x;
1730 ras.lastY = v_start.y;
1731
1732 while ( point < limit )
1733 {
1734 point++;
1735 tags++;
1736
1737 tag = FT_CURVE_TAG( tags[0] );
1738
1739 switch ( tag )
1740 {
1741 case FT_CURVE_TAG_ON: /* emit a single line_to */
1742 {
1743 Long x, y;
1744
1745
1746 x = SCALED( point->x );
1747 y = SCALED( point->y );
1748 if ( flipped )
1749 SWAP_( x, y );
1750
1751 if ( Line_To( RAS_VARS x, y ) )
1752 goto Fail;
1753 continue;
1754 }
1755
1756 case FT_CURVE_TAG_CONIC: /* consume conic arcs */
1757 v_control.x = SCALED( point[0].x );
1758 v_control.y = SCALED( point[0].y );
1759
1760 if ( flipped )
1761 SWAP_( v_control.x, v_control.y );
1762
1763 Do_Conic:
1764 if ( point < limit )
1765 {
1766 FT_Vector v_middle;
1767 Long x, y;
1768
1769
1770 point++;
1771 tags++;
1772 tag = FT_CURVE_TAG( tags[0] );
1773
1774 x = SCALED( point[0].x );
1775 y = SCALED( point[0].y );
1776
1777 if ( flipped )
1778 SWAP_( x, y );
1779
1780 if ( tag == FT_CURVE_TAG_ON )
1781 {
1782 if ( Conic_To( RAS_VARS v_control.x, v_control.y, x, y ) )
1783 goto Fail;
1784 continue;
1785 }
1786
1787 if ( tag != FT_CURVE_TAG_CONIC )
1788 goto Invalid_Outline;
1789
1790 v_middle.x = ( v_control.x + x ) / 2;
1791 v_middle.y = ( v_control.y + y ) / 2;
1792
1793 if ( Conic_To( RAS_VARS v_control.x, v_control.y,
1794 v_middle.x, v_middle.y ) )
1795 goto Fail;
1796
1797 v_control.x = x;
1798 v_control.y = y;
1799
1800 goto Do_Conic;
1801 }
1802
1803 if ( Conic_To( RAS_VARS v_control.x, v_control.y,
1804 v_start.x, v_start.y ) )
1805 goto Fail;
1806
1807 goto Close;
1808
1809 default: /* FT_CURVE_TAG_CUBIC */
1810 {
1811 Long x1, y1, x2, y2, x3, y3;
1812
1813
1814 if ( point + 1 > limit ||
1815 FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
1816 goto Invalid_Outline;
1817
1818 point += 2;
1819 tags += 2;
1820
1821 x1 = SCALED( point[-2].x );
1822 y1 = SCALED( point[-2].y );
1823 x2 = SCALED( point[-1].x );
1824 y2 = SCALED( point[-1].y );
1825 x3 = SCALED( point[ 0].x );
1826 y3 = SCALED( point[ 0].y );
1827
1828 if ( flipped )
1829 {
1830 SWAP_( x1, y1 );
1831 SWAP_( x2, y2 );
1832 SWAP_( x3, y3 );
1833 }
1834
1835 if ( point <= limit )
1836 {
1837 if ( Cubic_To( RAS_VARS x1, y1, x2, y2, x3, y3 ) )
1838 goto Fail;
1839 continue;
1840 }
1841
1842 if ( Cubic_To( RAS_VARS x1, y1, x2, y2, v_start.x, v_start.y ) )
1843 goto Fail;
1844 goto Close;
1845 }
1846 }
1847 }
1848
1849 /* close the contour with a line segment */
1850 if ( Line_To( RAS_VARS v_start.x, v_start.y ) )
1851 goto Fail;
1852
1853 Close:
1854 return SUCCESS;
1855
1856 Invalid_Outline:
1857 ras.error = Raster_Err_Invalid;
1858
1859 Fail:
1860 return FAILURE;
1861 }
1862
1863
1864 /*************************************************************************/
1865 /* */
1866 /* <Function> */
1867 /* Convert_Glyph */
1868 /* */
1869 /* <Description> */
1870 /* Converts a glyph into a series of segments and arcs and makes a */
1871 /* profiles list with them. */
1872 /* */
1873 /* <Input> */
1874 /* flipped :: If set, flip the direction of curve. */
1875 /* */
1876 /* <Return> */
1877 /* SUCCESS on success, FAILURE if any error was encountered during */
1878 /* rendering. */
1879 /* */
1880 static Bool
1881 Convert_Glyph( RAS_ARGS int flipped )
1882 {
1883 int i;
1884 unsigned start;
1885
1886 PProfile lastProfile;
1887
1888
1889 ras.fProfile = NULL;
1890 ras.joint = FALSE;
1891 ras.fresh = FALSE;
1892
1893 ras.maxBuff = ras.sizeBuff - AlignProfileSize;
1894
1895 ras.numTurns = 0;
1896
1897 ras.cProfile = (PProfile)ras.top;
1898 ras.cProfile->offset = ras.top;
1899 ras.num_Profs = 0;
1900
1901 start = 0;
1902
1903 for ( i = 0; i < ras.outline.n_contours; i++ )
1904 {
1905 ras.state = Unknown_State;
1906 ras.gProfile = NULL;
1907
1908 if ( Decompose_Curve( RAS_VARS (unsigned short)start,
1909 ras.outline.contours[i],
1910 flipped ) )
1911 return FAILURE;
1912
1913 start = ras.outline.contours[i] + 1;
1914
1915 /* We must now see whether the extreme arcs join or not */
1916 if ( FRAC( ras.lastY ) == 0 &&
1917 ras.lastY >= ras.minY &&
1918 ras.lastY <= ras.maxY )
1919 if ( ras.gProfile && ras.gProfile->flow == ras.cProfile->flow )
1920 ras.top--;
1921 /* Note that ras.gProfile can be nil if the contour was too small */
1922 /* to be drawn. */
1923
1924 lastProfile = ras.cProfile;
1925 if ( End_Profile( RAS_VAR ) )
1926 return FAILURE;
1927
1928 /* close the `next profile in contour' linked list */
1929 if ( ras.gProfile )
1930 lastProfile->next = ras.gProfile;
1931 }
1932
1933 if ( Finalize_Profile_Table( RAS_VAR ) )
1934 return FAILURE;
1935
1936 return (Bool)( ras.top < ras.maxBuff ? SUCCESS : FAILURE );
1937 }
1938
1939
1940 /*************************************************************************/
1941 /*************************************************************************/
1942 /** **/
1943 /** SCAN-LINE SWEEPS AND DRAWING **/
1944 /** **/
1945 /*************************************************************************/
1946 /*************************************************************************/
1947
1948
1949 /*************************************************************************/
1950 /* */
1951 /* Init_Linked */
1952 /* */
1953 /* Initializes an empty linked list. */
1954 /* */
1955 static void
1956 Init_Linked( TProfileList* l )
1957 {
1958 *l = NULL;
1959 }
1960
1961
1962 /*************************************************************************/
1963 /* */
1964 /* InsNew */
1965 /* */
1966 /* Inserts a new profile in a linked list. */
1967 /* */
1968 static void
1969 InsNew( PProfileList list,
1970 PProfile profile )
1971 {
1972 PProfile *old, current;
1973 Long x;
1974
1975
1976 old = list;
1977 current = *old;
1978 x = profile->X;
1979
1980 while ( current )
1981 {
1982 if ( x < current->X )
1983 break;
1984 old = &current->link;
1985 current = *old;
1986 }
1987
1988 profile->link = current;
1989 *old = profile;
1990 }
1991
1992
1993 /*************************************************************************/
1994 /* */
1995 /* DelOld */
1996 /* */
1997 /* Removes an old profile from a linked list. */
1998 /* */
1999 static void
2000 DelOld( PProfileList list,
2001 PProfile profile )
2002 {
2003 PProfile *old, current;
2004
2005
2006 old = list;
2007 current = *old;
2008
2009 while ( current )
2010 {
2011 if ( current == profile )
2012 {
2013 *old = current->link;
2014 return;
2015 }
2016
2017 old = &current->link;
2018 current = *old;
2019 }
2020
2021 /* we should never get there, unless the profile was not part of */
2022 /* the list. */
2023 }
2024
2025
2026 /*************************************************************************/
2027 /* */
2028 /* Sort */
2029 /* */
2030 /* Sorts a trace list. In 95%, the list is already sorted. We need */
2031 /* an algorithm which is fast in this case. Bubble sort is enough */
2032 /* and simple. */
2033 /* */
2034 static void
2035 Sort( PProfileList list )
2036 {
2037 PProfile *old, current, next;
2038
2039
2040 /* First, set the new X coordinate of each profile */
2041 current = *list;
2042 while ( current )
2043 {
2044 current->X = *current->offset;
2045 current->offset += current->flow;
2046 current->height--;
2047 current = current->link;
2048 }
2049
2050 /* Then sort them */
2051 old = list;
2052 current = *old;
2053
2054 if ( !current )
2055 return;
2056
2057 next = current->link;
2058
2059 while ( next )
2060 {
2061 if ( current->X <= next->X )
2062 {
2063 old = &current->link;
2064 current = *old;
2065
2066 if ( !current )
2067 return;
2068 }
2069 else
2070 {
2071 *old = next;
2072 current->link = next->link;
2073 next->link = current;
2074
2075 old = list;
2076 current = *old;
2077 }
2078
2079 next = current->link;
2080 }
2081 }
2082
2083
2084 /*************************************************************************/
2085 /* */
2086 /* Vertical Sweep Procedure Set */
2087 /* */
2088 /* These four routines are used during the vertical black/white sweep */
2089 /* phase by the generic Draw_Sweep() function. */
2090 /* */
2091 /*************************************************************************/
2092
2093 static void
2094 Vertical_Sweep_Init( RAS_ARGS Short* min,
2095 Short* max )
2096 {
2097 Long pitch = ras.target.pitch;
2098
2099 FT_UNUSED( max );
2100
2101
2102 ras.traceIncr = (Short)-pitch;
2103 ras.traceOfs = -*min * pitch;
2104 if ( pitch > 0 )
2105 ras.traceOfs += ( ras.target.rows - 1 ) * pitch;
2106
2107 ras.gray_min_x = 0;
2108 ras.gray_max_x = 0;
2109 }
2110
2111
2112 static void
2113 Vertical_Sweep_Span( RAS_ARGS Short y,
2114 FT_F26Dot6 x1,
2115 FT_F26Dot6 x2,
2116 PProfile left,
2117 PProfile right )
2118 {
2119 Long e1, e2;
2120 int c1, c2;
2121 Byte f1, f2;
2122 Byte* target;
2123
2124 FT_UNUSED( y );
2125 FT_UNUSED( left );
2126 FT_UNUSED( right );
2127
2128
2129 /* Drop-out control */
2130
2131 e1 = TRUNC( CEILING( x1 ) );
2132
2133 if ( x2 - x1 - ras.precision <= ras.precision_jitter )
2134 e2 = e1;
2135 else
2136 e2 = TRUNC( FLOOR( x2 ) );
2137
2138 if ( e2 >= 0 && e1 < ras.bWidth )
2139 {
2140 if ( e1 < 0 )
2141 e1 = 0;
2142 if ( e2 >= ras.bWidth )
2143 e2 = ras.bWidth - 1;
2144
2145 c1 = (Short)( e1 >> 3 );
2146 c2 = (Short)( e2 >> 3 );
2147
2148 f1 = (Byte) ( 0xFF >> ( e1 & 7 ) );
2149 f2 = (Byte) ~( 0x7F >> ( e2 & 7 ) );
2150
2151 if ( ras.gray_min_x > c1 ) ras.gray_min_x = (short)c1;
2152 if ( ras.gray_max_x < c2 ) ras.gray_max_x = (short)c2;
2153
2154 target = ras.bTarget + ras.traceOfs + c1;
2155 c2 -= c1;
2156
2157 if ( c2 > 0 )
2158 {
2159 target[0] |= f1;
2160
2161 /* memset() is slower than the following code on many platforms. */
2162 /* This is due to the fact that, in the vast majority of cases, */
2163 /* the span length in bytes is relatively small. */
2164 c2--;
2165 while ( c2 > 0 )
2166 {
2167 *(++target) = 0xFF;
2168 c2--;
2169 }
2170 target[1] |= f2;
2171 }
2172 else
2173 *target |= ( f1 & f2 );
2174 }
2175 }
2176
2177
2178 static void
2179 Vertical_Sweep_Drop( RAS_ARGS Short y,
2180 FT_F26Dot6 x1,
2181 FT_F26Dot6 x2,
2182 PProfile left,
2183 PProfile right )
2184 {
2185 Long e1, e2;
2186 Short c1, f1;
2187
2188
2189 /* Drop-out control */
2190
2191 e1 = CEILING( x1 );
2192 e2 = FLOOR ( x2 );
2193
2194 if ( e1 > e2 )
2195 {
2196 if ( e1 == e2 + ras.precision )
2197 {
2198 switch ( ras.dropOutControl )
2199 {
2200 case 1:
2201 e1 = e2;
2202 break;
2203
2204 case 4:
2205 e1 = CEILING( (x1 + x2 + 1) / 2 );
2206 break;
2207
2208 case 2:
2209 case 5:
2210 /* Drop-out Control Rule #4 */
2211
2212 /* The spec is not very clear regarding rule #4. It */
2213 /* presents a method that is way too costly to implement */
2214 /* while the general idea seems to get rid of `stubs'. */
2215 /* */
2216 /* Here, we only get rid of stubs recognized if: */
2217 /* */
2218 /* upper stub: */
2219 /* */
2220 /* - P_Left and P_Right are in the same contour */
2221 /* - P_Right is the successor of P_Left in that contour */
2222 /* - y is the top of P_Left and P_Right */
2223 /* */
2224 /* lower stub: */
2225 /* */
2226 /* - P_Left and P_Right are in the same contour */
2227 /* - P_Left is the successor of P_Right in that contour */
2228 /* - y is the bottom of P_Left */
2229 /* */
2230
2231 /* FIXXXME: uncommenting this line solves the disappearing */
2232 /* bit problem in the `7' of verdana 10pts, but */
2233 /* makes a new one in the `C' of arial 14pts */
2234
2235 #if 0
2236 if ( x2 - x1 < ras.precision_half )
2237 #endif
2238 {
2239 /* upper stub test */
2240 if ( left->next == right && left->height <= 0 )
2241 return;
2242
2243 /* lower stub test */
2244 if ( right->next == left && left->start == y )
2245 return;
2246 }
2247
2248 /* check that the rightmost pixel isn't set */
2249
2250 e1 = TRUNC( e1 );
2251
2252 c1 = (Short)( e1 >> 3 );
2253 f1 = (Short)( e1 & 7 );
2254
2255 if ( e1 >= 0 && e1 < ras.bWidth &&
2256 ras.bTarget[ras.traceOfs + c1] & ( 0x80 >> f1 ) )
2257 return;
2258
2259 if ( ras.dropOutControl == 2 )
2260 e1 = e2;
2261 else
2262 e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
2263
2264 break;
2265
2266 default:
2267 return; /* unsupported mode */
2268 }
2269 }
2270 else
2271 return;
2272 }
2273
2274 e1 = TRUNC( e1 );
2275
2276 if ( e1 >= 0 && e1 < ras.bWidth )
2277 {
2278 c1 = (Short)( e1 >> 3 );
2279 f1 = (Short)( e1 & 7 );
2280
2281 if ( ras.gray_min_x > c1 ) ras.gray_min_x = c1;
2282 if ( ras.gray_max_x < c1 ) ras.gray_max_x = c1;
2283
2284 ras.bTarget[ras.traceOfs + c1] |= (char)( 0x80 >> f1 );
2285 }
2286 }
2287
2288
2289 static void
2290 Vertical_Sweep_Step( RAS_ARG )
2291 {
2292 ras.traceOfs += ras.traceIncr;
2293 }
2294
2295
2296 /***********************************************************************/
2297 /* */
2298 /* Horizontal Sweep Procedure Set */
2299 /* */
2300 /* These four routines are used during the horizontal black/white */
2301 /* sweep phase by the generic Draw_Sweep() function. */
2302 /* */
2303 /***********************************************************************/
2304
2305 static void
2306 Horizontal_Sweep_Init( RAS_ARGS Short* min,
2307 Short* max )
2308 {
2309 /* nothing, really */
2310 FT_UNUSED_RASTER;
2311 FT_UNUSED( min );
2312 FT_UNUSED( max );
2313 }
2314
2315
2316 static void
2317 Horizontal_Sweep_Span( RAS_ARGS Short y,
2318 FT_F26Dot6 x1,
2319 FT_F26Dot6 x2,
2320 PProfile left,
2321 PProfile right )
2322 {
2323 Long e1, e2;
2324 PByte bits;
2325 Byte f1;
2326
2327 FT_UNUSED( left );
2328 FT_UNUSED( right );
2329
2330
2331 if ( x2 - x1 < ras.precision )
2332 {
2333 e1 = CEILING( x1 );
2334 e2 = FLOOR ( x2 );
2335
2336 if ( e1 == e2 )
2337 {
2338 bits = ras.bTarget + ( y >> 3 );
2339 f1 = (Byte)( 0x80 >> ( y & 7 ) );
2340
2341 e1 = TRUNC( e1 );
2342
2343 if ( e1 >= 0 && e1 < ras.target.rows )
2344 {
2345 PByte p;
2346
2347
2348 p = bits - e1*ras.target.pitch;
2349 if ( ras.target.pitch > 0 )
2350 p += ( ras.target.rows - 1 ) * ras.target.pitch;
2351
2352 p[0] |= f1;
2353 }
2354 }
2355 }
2356 }
2357
2358
2359 static void
2360 Horizontal_Sweep_Drop( RAS_ARGS Short y,
2361 FT_F26Dot6 x1,
2362 FT_F26Dot6 x2,
2363 PProfile left,
2364 PProfile right )
2365 {
2366 Long e1, e2;
2367 PByte bits;
2368 Byte f1;
2369
2370
2371 /* During the horizontal sweep, we only take care of drop-outs */
2372
2373 e1 = CEILING( x1 );
2374 e2 = FLOOR ( x2 );
2375
2376 if ( e1 > e2 )
2377 {
2378 if ( e1 == e2 + ras.precision )
2379 {
2380 switch ( ras.dropOutControl )
2381 {
2382 case 1:
2383 e1 = e2;
2384 break;
2385
2386 case 4:
2387 e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
2388 break;
2389
2390 case 2:
2391 case 5:
2392
2393 /* Drop-out Control Rule #4 */
2394
2395 /* The spec is not very clear regarding rule #4. It */
2396 /* presents a method that is way too costly to implement */
2397 /* while the general idea seems to get rid of `stubs'. */
2398 /* */
2399
2400 /* rightmost stub test */
2401 if ( left->next == right && left->height <= 0 )
2402 return;
2403
2404 /* leftmost stub test */
2405 if ( right->next == left && left->start == y )
2406 return;
2407
2408 /* check that the rightmost pixel isn't set */
2409
2410 e1 = TRUNC( e1 );
2411
2412 bits = ras.bTarget + ( y >> 3 );
2413 f1 = (Byte)( 0x80 >> ( y & 7 ) );
2414
2415 bits -= e1 * ras.target.pitch;
2416 if ( ras.target.pitch > 0 )
2417 bits += ( ras.target.rows - 1 ) * ras.target.pitch;
2418
2419 if ( e1 >= 0 &&
2420 e1 < ras.target.rows &&
2421 *bits & f1 )
2422 return;
2423
2424 if ( ras.dropOutControl == 2 )
2425 e1 = e2;
2426 else
2427 e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
2428
2429 break;
2430
2431 default:
2432 return; /* unsupported mode */
2433 }
2434 }
2435 else
2436 return;
2437 }
2438
2439 bits = ras.bTarget + ( y >> 3 );
2440 f1 = (Byte)( 0x80 >> ( y & 7 ) );
2441
2442 e1 = TRUNC( e1 );
2443
2444 if ( e1 >= 0 && e1 < ras.target.rows )
2445 {
2446 bits -= e1 * ras.target.pitch;
2447 if ( ras.target.pitch > 0 )
2448 bits += ( ras.target.rows - 1 ) * ras.target.pitch;
2449
2450 bits[0] |= f1;
2451 }
2452 }
2453
2454
2455 static void
2456 Horizontal_Sweep_Step( RAS_ARG )
2457 {
2458 /* Nothing, really */
2459 FT_UNUSED_RASTER;
2460 }
2461
2462
2463 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
2464
2465
2466 /*************************************************************************/
2467 /* */
2468 /* Vertical Gray Sweep Procedure Set */
2469 /* */
2470 /* These two routines are used during the vertical gray-levels sweep */
2471 /* phase by the generic Draw_Sweep() function. */
2472 /* */
2473 /* NOTES */
2474 /* */
2475 /* - The target pixmap's width *must* be a multiple of 4. */
2476 /* */
2477 /* - You have to use the function Vertical_Sweep_Span() for the gray */
2478 /* span call. */
2479 /* */
2480 /*************************************************************************/
2481
2482 static void
2483 Vertical_Gray_Sweep_Init( RAS_ARGS Short* min,
2484 Short* max )
2485 {
2486 Long pitch, byte_len;
2487
2488
2489 *min = *min & -2;
2490 *max = ( *max + 3 ) & -2;
2491
2492 ras.traceOfs = 0;
2493 pitch = ras.target.pitch;
2494 byte_len = -pitch;
2495 ras.traceIncr = (Short)byte_len;
2496 ras.traceG = ( *min / 2 ) * byte_len;
2497
2498 if ( pitch > 0 )
2499 {
2500 ras.traceG += ( ras.target.rows - 1 ) * pitch;
2501 byte_len = -byte_len;
2502 }
2503
2504 ras.gray_min_x = (Short)byte_len;
2505 ras.gray_max_x = -(Short)byte_len;
2506 }
2507
2508
2509 static void
2510 Vertical_Gray_Sweep_Step( RAS_ARG )
2511 {
2512 Int c1, c2;
2513 PByte pix, bit, bit2;
2514 char* count = (char*)count_table;
2515 Byte* grays;
2516
2517
2518 ras.traceOfs += ras.gray_width;
2519
2520 if ( ras.traceOfs > ras.gray_width )
2521 {
2522 pix = ras.gTarget + ras.traceG + ras.gray_min_x * 4;
2523 grays = ras.grays;
2524
2525 if ( ras.gray_max_x >= 0 )
2526 {
2527 Long last_pixel = ras.target.width - 1;
2528 Int last_cell = last_pixel >> 2;
2529 Int last_bit = last_pixel & 3;
2530 Bool over = 0;
2531
2532
2533 if ( ras.gray_max_x >= last_cell && last_bit != 3 )
2534 {
2535 ras.gray_max_x = last_cell - 1;
2536 over = 1;
2537 }
2538
2539 if ( ras.gray_min_x < 0 )
2540 ras.gray_min_x = 0;
2541
2542 bit = ras.bTarget + ras.gray_min_x;
2543 bit2 = bit + ras.gray_width;
2544
2545 c1 = ras.gray_max_x - ras.gray_min_x;
2546
2547 while ( c1 >= 0 )
2548 {
2549 c2 = count[*bit] + count[*bit2];
2550
2551 if ( c2 )
2552 {
2553 pix[0] = grays[(c2 >> 12) & 0x000F];
2554 pix[1] = grays[(c2 >> 8 ) & 0x000F];
2555 pix[2] = grays[(c2 >> 4 ) & 0x000F];
2556 pix[3] = grays[ c2 & 0x000F];
2557
2558 *bit = 0;
2559 *bit2 = 0;
2560 }
2561
2562 bit++;
2563 bit2++;
2564 pix += 4;
2565 c1--;
2566 }
2567
2568 if ( over )
2569 {
2570 c2 = count[*bit] + count[*bit2];
2571 if ( c2 )
2572 {
2573 switch ( last_bit )
2574 {
2575 case 2:
2576 pix[2] = grays[(c2 >> 4 ) & 0x000F];
2577 case 1:
2578 pix[1] = grays[(c2 >> 8 ) & 0x000F];
2579 default:
2580 pix[0] = grays[(c2 >> 12) & 0x000F];
2581 }
2582
2583 *bit = 0;
2584 *bit2 = 0;
2585 }
2586 }
2587 }
2588
2589 ras.traceOfs = 0;
2590 ras.traceG += ras.traceIncr;
2591
2592 ras.gray_min_x = 32000;
2593 ras.gray_max_x = -32000;
2594 }
2595 }
2596
2597
2598 static void
2599 Horizontal_Gray_Sweep_Span( RAS_ARGS Short y,
2600 FT_F26Dot6 x1,
2601 FT_F26Dot6 x2,
2602 PProfile left,
2603 PProfile right )
2604 {
2605 /* nothing, really */
2606 FT_UNUSED_RASTER;
2607 FT_UNUSED( y );
2608 FT_UNUSED( x1 );
2609 FT_UNUSED( x2 );
2610 FT_UNUSED( left );
2611 FT_UNUSED( right );
2612 }
2613
2614
2615 static void
2616 Horizontal_Gray_Sweep_Drop( RAS_ARGS Short y,
2617 FT_F26Dot6 x1,
2618 FT_F26Dot6 x2,
2619 PProfile left,
2620 PProfile right )
2621 {
2622 Long e1, e2;
2623 PByte pixel;
2624 Byte color;
2625
2626
2627 /* During the horizontal sweep, we only take care of drop-outs */
2628 e1 = CEILING( x1 );
2629 e2 = FLOOR ( x2 );
2630
2631 if ( e1 > e2 )
2632 {
2633 if ( e1 == e2 + ras.precision )
2634 {
2635 switch ( ras.dropOutControl )
2636 {
2637 case 1:
2638 e1 = e2;
2639 break;
2640
2641 case 4:
2642 e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
2643 break;
2644
2645 case 2:
2646 case 5:
2647
2648 /* Drop-out Control Rule #4 */
2649
2650 /* The spec is not very clear regarding rule #4. It */
2651 /* presents a method that is way too costly to implement */
2652 /* while the general idea seems to get rid of `stubs'. */
2653 /* */
2654
2655 /* rightmost stub test */
2656 if ( left->next == right && left->height <= 0 )
2657 return;
2658
2659 /* leftmost stub test */
2660 if ( right->next == left && left->start == y )
2661 return;
2662
2663 if ( ras.dropOutControl == 2 )
2664 e1 = e2;
2665 else
2666 e1 = CEILING( ( x1 + x2 + 1 ) / 2 );
2667
2668 break;
2669
2670 default:
2671 return; /* unsupported mode */
2672 }
2673 }
2674 else
2675 return;
2676 }
2677
2678 if ( e1 >= 0 )
2679 {
2680 if ( x2 - x1 >= ras.precision_half )
2681 color = ras.grays[2];
2682 else
2683 color = ras.grays[1];
2684
2685 e1 = TRUNC( e1 ) / 2;
2686 if ( e1 < ras.target.rows )
2687 {
2688 pixel = ras.gTarget - e1 * ras.target.pitch + y / 2;
2689 if ( ras.target.pitch > 0 )
2690 pixel += ( ras.target.rows - 1 ) * ras.target.pitch;
2691
2692 if ( pixel[0] == ras.grays[0] )
2693 pixel[0] = color;
2694 }
2695 }
2696 }
2697
2698
2699 #endif /* FT_RASTER_OPTION_ANTI_ALIASING */
2700
2701
2702 /*************************************************************************/
2703 /* */
2704 /* Generic Sweep Drawing routine */
2705 /* */
2706 /*************************************************************************/
2707
2708 static Bool
2709 Draw_Sweep( RAS_ARG )
2710 {
2711 Short y, y_change, y_height;
2712
2713 PProfile P, Q, P_Left, P_Right;
2714
2715 Short min_Y, max_Y, top, bottom, dropouts;
2716
2717 Long x1, x2, xs, e1, e2;
2718
2719 TProfileList waiting;
2720 TProfileList draw_left, draw_right;
2721
2722
2723 /* Init empty linked lists */
2724
2725 Init_Linked( &waiting );
2726
2727 Init_Linked( &draw_left );
2728 Init_Linked( &draw_right );
2729
2730 /* first, compute min and max Y */
2731
2732 P = ras.fProfile;
2733 max_Y = (Short)TRUNC( ras.minY );
2734 min_Y = (Short)TRUNC( ras.maxY );
2735
2736 while ( P )
2737 {
2738 Q = P->link;
2739
2740 bottom = (Short)P->start;
2741 top = (Short)( P->start + P->height - 1 );
2742
2743 if ( min_Y > bottom ) min_Y = bottom;
2744 if ( max_Y < top ) max_Y = top;
2745
2746 P->X = 0;
2747 InsNew( &waiting, P );
2748
2749 P = Q;
2750 }
2751
2752 /* Check the Y-turns */
2753 if ( ras.numTurns == 0 )
2754 {
2755 ras.error = Raster_Err_Invalid;
2756 return FAILURE;
2757 }
2758
2759 /* Now inits the sweep */
2760
2761 ras.Proc_Sweep_Init( RAS_VARS &min_Y, &max_Y );
2762
2763 /* Then compute the distance of each profile from min_Y */
2764
2765 P = waiting;
2766
2767 while ( P )
2768 {
2769 P->countL = (UShort)( P->start - min_Y );
2770 P = P->link;
2771 }
2772
2773 /* Let's go */
2774
2775 y = min_Y;
2776 y_height = 0;
2777
2778 if ( ras.numTurns > 0 &&
2779 ras.sizeBuff[-ras.numTurns] == min_Y )
2780 ras.numTurns--;
2781
2782 while ( ras.numTurns > 0 )
2783 {
2784 /* look in the waiting list for new activations */
2785
2786 P = waiting;
2787
2788 while ( P )
2789 {
2790 Q = P->link;
2791 P->countL -= y_height;
2792 if ( P->countL == 0 )
2793 {
2794 DelOld( &waiting, P );
2795
2796 switch ( P->flow )
2797 {
2798 case Flow_Up:
2799 InsNew( &draw_left, P );
2800 break;
2801
2802 case Flow_Down:
2803 InsNew( &draw_right, P );
2804 break;
2805 }
2806 }
2807
2808 P = Q;
2809 }
2810
2811 /* Sort the drawing lists */
2812
2813 Sort( &draw_left );
2814 Sort( &draw_right );
2815
2816 y_change = (Short)ras.sizeBuff[-ras.numTurns--];
2817 y_height = (Short)( y_change - y );
2818
2819 while ( y < y_change )
2820 {
2821 /* Let's trace */
2822
2823 dropouts = 0;
2824
2825 P_Left = draw_left;
2826 P_Right = draw_right;
2827
2828 while ( P_Left )
2829 {
2830 x1 = P_Left ->X;
2831 x2 = P_Right->X;
2832
2833 if ( x1 > x2 )
2834 {
2835 xs = x1;
2836 x1 = x2;
2837 x2 = xs;
2838 }
2839
2840 if ( x2 - x1 <= ras.precision )
2841 {
2842 e1 = FLOOR( x1 );
2843 e2 = CEILING( x2 );
2844
2845 if ( ras.dropOutControl != 0 &&
2846 ( e1 > e2 || e2 == e1 + ras.precision ) )
2847 {
2848 /* a drop out was detected */
2849
2850 P_Left ->X = x1;
2851 P_Right->X = x2;
2852
2853 /* mark profile for drop-out processing */
2854 P_Left->countL = 1;
2855 dropouts++;
2856
2857 goto Skip_To_Next;
2858 }
2859 }
2860
2861 ras.Proc_Sweep_Span( RAS_VARS y, x1, x2, P_Left, P_Right );
2862
2863 Skip_To_Next:
2864
2865 P_Left = P_Left->link;
2866 P_Right = P_Right->link;
2867 }
2868
2869 /* now perform the dropouts _after_ the span drawing -- */
2870 /* drop-outs processing has been moved out of the loop */
2871 /* for performance tuning */
2872 if ( dropouts > 0 )
2873 goto Scan_DropOuts;
2874
2875 Next_Line:
2876
2877 ras.Proc_Sweep_Step( RAS_VAR );
2878
2879 y++;
2880
2881 if ( y < y_change )
2882 {
2883 Sort( &draw_left );
2884 Sort( &draw_right );
2885 }
2886 }
2887
2888 /* Now finalize the profiles that needs it */
2889
2890 P = draw_left;
2891 while ( P )
2892 {
2893 Q = P->link;
2894 if ( P->height == 0 )
2895 DelOld( &draw_left, P );
2896 P = Q;
2897 }
2898
2899 P = draw_right;
2900 while ( P )
2901 {
2902 Q = P->link;
2903 if ( P->height == 0 )
2904 DelOld( &draw_right, P );
2905 P = Q;
2906 }
2907 }
2908
2909 /* for gray-scaling, flushes the bitmap scanline cache */
2910 while ( y <= max_Y )
2911 {
2912 ras.Proc_Sweep_Step( RAS_VAR );
2913 y++;
2914 }
2915
2916 return SUCCESS;
2917
2918 Scan_DropOuts:
2919
2920 P_Left = draw_left;
2921 P_Right = draw_right;
2922
2923 while ( P_Left )
2924 {
2925 if ( P_Left->countL )
2926 {
2927 P_Left->countL = 0;
2928 #if 0
2929 dropouts--; /* -- this is useful when debugging only */
2930 #endif
2931 ras.Proc_Sweep_Drop( RAS_VARS y,
2932 P_Left->X,
2933 P_Right->X,
2934 P_Left,
2935 P_Right );
2936 }
2937
2938 P_Left = P_Left->link;
2939 P_Right = P_Right->link;
2940 }
2941
2942 goto Next_Line;
2943 }
2944
2945
2946 /*************************************************************************/
2947 /* */
2948 /* <Function> */
2949 /* Render_Single_Pass */
2950 /* */
2951 /* <Description> */
2952 /* Performs one sweep with sub-banding. */
2953 /* */
2954 /* <Input> */
2955 /* flipped :: If set, flip the direction of the outline. */
2956 /* */
2957 /* <Return> */
2958 /* Renderer error code. */
2959 /* */
2960 static int
2961 Render_Single_Pass( RAS_ARGS Bool flipped )
2962 {
2963 Short i, j, k;
2964
2965
2966 while ( ras.band_top >= 0 )
2967 {
2968 ras.maxY = (Long)ras.band_stack[ras.band_top].y_max * ras.precision;
2969 ras.minY = (Long)ras.band_stack[ras.band_top].y_min * ras.precision;
2970
2971 ras.top = ras.buff;
2972
2973 ras.error = Raster_Err_None;
2974
2975 if ( Convert_Glyph( RAS_VARS flipped ) )
2976 {
2977 if ( ras.error != Raster_Err_Overflow )
2978 return FAILURE;
2979
2980 ras.error = Raster_Err_None;
2981
2982 /* sub-banding */
2983
2984 #ifdef DEBUG_RASTER
2985 ClearBand( RAS_VARS TRUNC( ras.minY ), TRUNC( ras.maxY ) );
2986 #endif
2987
2988 i = ras.band_stack[ras.band_top].y_min;
2989 j = ras.band_stack[ras.band_top].y_max;
2990
2991 k = (Short)( ( i + j ) / 2 );
2992
2993 if ( ras.band_top >= 7 || k < i )
2994 {
2995 ras.band_top = 0;
2996 ras.error = Raster_Err_Invalid;
2997
2998 return ras.error;
2999 }
3000
3001 ras.band_stack[ras.band_top + 1].y_min = k;
3002 ras.band_stack[ras.band_top + 1].y_max = j;
3003
3004 ras.band_stack[ras.band_top].y_max = (Short)( k - 1 );
3005
3006 ras.band_top++;
3007 }
3008 else
3009 {
3010 if ( ras.fProfile )
3011 if ( Draw_Sweep( RAS_VAR ) )
3012 return ras.error;
3013 ras.band_top--;
3014 }
3015 }
3016
3017 return SUCCESS;
3018 }
3019
3020
3021 /*************************************************************************/
3022 /* */
3023 /* <Function> */
3024 /* Render_Glyph */
3025 /* */
3026 /* <Description> */
3027 /* Renders a glyph in a bitmap. Sub-banding if needed. */
3028 /* */
3029 /* <Return> */
3030 /* FreeType error code. 0 means success. */
3031 /* */
3032 FT_LOCAL_DEF( FT_Error )
3033 Render_Glyph( RAS_ARG )
3034 {
3035 FT_Error error;
3036
3037
3038 Set_High_Precision( RAS_VARS ras.outline.flags &
3039 FT_OUTLINE_HIGH_PRECISION );
3040 ras.scale_shift = ras.precision_shift;
3041 /* Drop-out mode 2 is hard-coded since this is the only mode used */
3042 /* on Windows platforms. Using other modes, as specified by the */
3043 /* font, results in misplaced pixels. */
3044 ras.dropOutControl = 2;
3045 ras.second_pass = (FT_Byte)( !( ras.outline.flags &
3046 FT_OUTLINE_SINGLE_PASS ) );
3047
3048 /* Vertical Sweep */
3049 ras.Proc_Sweep_Init = Vertical_Sweep_Init;
3050 ras.Proc_Sweep_Span = Vertical_Sweep_Span;
3051 ras.Proc_Sweep_Drop = Vertical_Sweep_Drop;
3052 ras.Proc_Sweep_Step = Vertical_Sweep_Step;
3053
3054 ras.band_top = 0;
3055 ras.band_stack[0].y_min = 0;
3056 ras.band_stack[0].y_max = (short)( ras.target.rows - 1 );
3057
3058 ras.bWidth = (unsigned short)ras.target.width;
3059 ras.bTarget = (Byte*)ras.target.buffer;
3060
3061 if ( ( error = Render_Single_Pass( RAS_VARS 0 ) ) != 0 )
3062 return error;
3063
3064 /* Horizontal Sweep */
3065 if ( ras.second_pass && ras.dropOutControl != 0 )
3066 {
3067 ras.Proc_Sweep_Init = Horizontal_Sweep_Init;
3068 ras.Proc_Sweep_Span = Horizontal_Sweep_Span;
3069 ras.Proc_Sweep_Drop = Horizontal_Sweep_Drop;
3070 ras.Proc_Sweep_Step = Horizontal_Sweep_Step;
3071
3072 ras.band_top = 0;
3073 ras.band_stack[0].y_min = 0;
3074 ras.band_stack[0].y_max = (short)( ras.target.width - 1 );
3075
3076 if ( ( error = Render_Single_Pass( RAS_VARS 1 ) ) != 0 )
3077 return error;
3078 }
3079
3080 return Raster_Err_None;
3081 }
3082
3083
3084 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
3085
3086
3087 /*************************************************************************/
3088 /* */
3089 /* <Function> */
3090 /* Render_Gray_Glyph */
3091 /* */
3092 /* <Description> */
3093 /* Renders a glyph with grayscaling. Sub-banding if needed. */
3094 /* */
3095 /* <Return> */
3096 /* FreeType error code. 0 means success. */
3097 /* */
3098 FT_LOCAL_DEF( FT_Error )
3099 Render_Gray_Glyph( RAS_ARG )
3100 {
3101 Long pixel_width;
3102 FT_Error error;
3103
3104
3105 Set_High_Precision( RAS_VARS ras.outline.flags &
3106 FT_OUTLINE_HIGH_PRECISION );
3107 ras.scale_shift = ras.precision_shift + 1;
3108 /* Drop-out mode 2 is hard-coded since this is the only mode used */
3109 /* on Windows platforms. Using other modes, as specified by the */
3110 /* font, results in misplaced pixels. */
3111 ras.dropOutControl = 2;
3112 ras.second_pass = !( ras.outline.flags & FT_OUTLINE_SINGLE_PASS );
3113
3114 /* Vertical Sweep */
3115
3116 ras.band_top = 0;
3117 ras.band_stack[0].y_min = 0;
3118 ras.band_stack[0].y_max = 2 * ras.target.rows - 1;
3119
3120 ras.bWidth = ras.gray_width;
3121 pixel_width = 2 * ( ( ras.target.width + 3 ) >> 2 );
3122
3123 if ( ras.bWidth > pixel_width )
3124 ras.bWidth = pixel_width;
3125
3126 ras.bWidth = ras.bWidth * 8;
3127 ras.bTarget = (Byte*)ras.gray_lines;
3128 ras.gTarget = (Byte*)ras.target.buffer;
3129
3130 ras.Proc_Sweep_Init = Vertical_Gray_Sweep_Init;
3131 ras.Proc_Sweep_Span = Vertical_Sweep_Span;
3132 ras.Proc_Sweep_Drop = Vertical_Sweep_Drop;
3133 ras.Proc_Sweep_Step = Vertical_Gray_Sweep_Step;
3134
3135 error = Render_Single_Pass( RAS_VARS 0 );
3136 if ( error )
3137 return error;
3138
3139 /* Horizontal Sweep */
3140 if ( ras.second_pass && ras.dropOutControl != 0 )
3141 {
3142 ras.Proc_Sweep_Init = Horizontal_Sweep_Init;
3143 ras.Proc_Sweep_Span = Horizontal_Gray_Sweep_Span;
3144 ras.Proc_Sweep_Drop = Horizontal_Gray_Sweep_Drop;
3145 ras.Proc_Sweep_Step = Horizontal_Sweep_Step;
3146
3147 ras.band_top = 0;
3148 ras.band_stack[0].y_min = 0;
3149 ras.band_stack[0].y_max = ras.target.width * 2 - 1;
3150
3151 error = Render_Single_Pass( RAS_VARS 1 );
3152 if ( error )
3153 return error;
3154 }
3155
3156 return Raster_Err_None;
3157 }
3158
3159 #else /* !FT_RASTER_OPTION_ANTI_ALIASING */
3160
3161 FT_LOCAL_DEF( FT_Error )
3162 Render_Gray_Glyph( RAS_ARG )
3163 {
3164 FT_UNUSED_RASTER;
3165
3166 return Raster_Err_Unsupported;
3167 }
3168
3169 #endif /* !FT_RASTER_OPTION_ANTI_ALIASING */
3170
3171
3172 static void
3173 ft_black_init( PRaster raster )
3174 {
3175 FT_UNUSED( raster );
3176
3177 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
3178 FT_UInt n;
3179
3180
3181 /* set default 5-levels gray palette */
3182 for ( n = 0; n < 5; n++ )
3183 raster->grays[n] = n * 255 / 4;
3184
3185 raster->gray_width = RASTER_GRAY_LINES / 2;
3186
3187 #endif
3188 }
3189
3190
3191 /**** RASTER OBJECT CREATION: In standalone mode, we simply use *****/
3192 /**** a static object. *****/
3193
3194
3195 #ifdef _STANDALONE_
3196
3197
3198 static int
3199 ft_black_new( void* memory,
3200 FT_Raster *araster )
3201 {
3202 static TRaster the_raster;
3203
3204
3205 *araster = (FT_Raster)&the_raster;
3206 FT_MEM_ZERO( &the_raster, sizeof ( the_raster ) );
3207 ft_black_init( &the_raster );
3208
3209 return 0;
3210 }
3211
3212
3213 static void
3214 ft_black_done( FT_Raster raster )
3215 {
3216 /* nothing */
3217 FT_UNUSED( raster );
3218 }
3219
3220
3221 #else /* _STANDALONE_ */
3222
3223
3224 static int
3225 ft_black_new( FT_Memory memory,
3226 PRaster *araster )
3227 {
3228 FT_Error error;
3229 PRaster raster;
3230
3231
3232 *araster = 0;
3233 if ( !FT_NEW( raster ) )
3234 {
3235 raster->memory = memory;
3236 ft_black_init( raster );
3237
3238 *araster = raster;
3239 }
3240
3241 return error;
3242 }
3243
3244
3245 static void
3246 ft_black_done( PRaster raster )
3247 {
3248 FT_Memory memory = (FT_Memory)raster->memory;
3249 FT_FREE( raster );
3250 }
3251
3252
3253 #endif /* _STANDALONE_ */
3254
3255
3256 static void
3257 ft_black_reset( PRaster raster,
3258 char* pool_base,
3259 long pool_size )
3260 {
3261 if ( raster )
3262 {
3263 if ( pool_base && pool_size >= (long)sizeof(TWorker) + 2048 )
3264 {
3265 PWorker worker = (PWorker)pool_base;
3266
3267
3268 raster->buffer = pool_base + ( (sizeof ( *worker ) + 7 ) & ~7 );
3269 raster->buffer_size = ( ( pool_base + pool_size ) -
3270 (char*)raster->buffer ) / sizeof ( Long );
3271 raster->worker = worker;
3272 }
3273 else
3274 {
3275 raster->buffer = NULL;
3276 raster->buffer_size = 0;
3277 raster->worker = NULL;
3278 }
3279 }
3280 }
3281
3282
3283 static void
3284 ft_black_set_mode( PRaster raster,
3285 unsigned long mode,
3286 const char* palette )
3287 {
3288 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
3289
3290 if ( mode == FT_MAKE_TAG( 'p', 'a', 'l', '5' ) )
3291 {
3292 /* set 5-levels gray palette */
3293 raster->grays[0] = palette[0];
3294 raster->grays[1] = palette[1];
3295 raster->grays[2] = palette[2];
3296 raster->grays[3] = palette[3];
3297 raster->grays[4] = palette[4];
3298 }
3299
3300 #else
3301
3302 FT_UNUSED( raster );
3303 FT_UNUSED( mode );
3304 FT_UNUSED( palette );
3305
3306 #endif
3307 }
3308
3309
3310 static int
3311 ft_black_render( PRaster raster,
3312 const FT_Raster_Params* params )
3313 {
3314 const FT_Outline* outline = (const FT_Outline*)params->source;
3315 const FT_Bitmap* target_map = params->target;
3316 PWorker worker;
3317
3318
3319 if ( !raster || !raster->buffer || !raster->buffer_size )
3320 return Raster_Err_Not_Ini;
3321
3322 /* return immediately if the outline is empty */
3323 if ( outline->n_points == 0 || outline->n_contours <= 0 )
3324 return Raster_Err_None;
3325
3326 if ( !outline || !outline->contours || !outline->points )
3327 return Raster_Err_Invalid;
3328
3329 if ( outline->n_points != outline->contours[outline->n_contours - 1] + 1 )
3330 return Raster_Err_Invalid;
3331
3332 worker = raster->worker;
3333
3334 /* this version of the raster does not support direct rendering, sorry */
3335 if ( params->flags & FT_RASTER_FLAG_DIRECT )
3336 return Raster_Err_Unsupported;
3337
3338 if ( !target_map || !target_map->buffer )
3339 return Raster_Err_Invalid;
3340
3341 ras.outline = *outline;
3342 ras.target = *target_map;
3343
3344 worker->buff = (PLong) raster->buffer;
3345 worker->sizeBuff = worker->buff +
3346 raster->buffer_size / sizeof ( Long );
3347 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
3348 worker->grays = raster->grays;
3349 worker->gray_width = raster->gray_width;
3350 #endif
3351
3352 return ( ( params->flags & FT_RASTER_FLAG_AA )
3353 ? Render_Gray_Glyph( RAS_VAR )
3354 : Render_Glyph( RAS_VAR ) );
3355 }
3356
3357
3358 const FT_Raster_Funcs ft_standard_raster =
3359 {
3360 FT_GLYPH_FORMAT_OUTLINE,
3361 (FT_Raster_New_Func) ft_black_new,
3362 (FT_Raster_Reset_Func) ft_black_reset,
3363 (FT_Raster_Set_Mode_Func)ft_black_set_mode,
3364 (FT_Raster_Render_Func) ft_black_render,
3365 (FT_Raster_Done_Func) ft_black_done
3366 };
3367
3368
3369 /* END */
A free Windows-compatible Operating System