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