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