PageRenderTime 69ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 1ms

/src/freetype/src/raster/ftraster.c

https://bitbucket.org/cabalistic/ogredeps/
C | 3612 lines | 2079 code | 732 blank | 801 comment | 336 complexity | 7039c09154560704ab85e1459afc4098 MD5 | raw file
Possible License(s): LGPL-3.0, BSD-3-Clause, CPL-1.0, Unlicense, GPL-2.0, GPL-3.0, LGPL-2.0, MPL-2.0-no-copyleft-exception, BSD-2-Clause, LGPL-2.1 
    

  1. /***************************************************************************/
    2. 

  2. /*                                                                         */
    3. 

  3. /*  ftraster.c                                                             */
    4. 

  4. /*                                                                         */
    5. 

  5. /*    The FreeType glyph rasterizer (body).                                */
    6. 

  6. /*                                                                         */
    7. 

  7. /*  Copyright 1996-2003, 2005, 2007-2012 by                                */
    8. 

  8. /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    9. 

  9. /*                                                                         */
    10. 

  10. /*  This file is part of the FreeType project, and may only be used,       */
    11. 

  11. /*  modified, and distributed under the terms of the FreeType project      */
    12. 

  12. /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
    13. 

  13. /*  this file you indicate that you have read the license and              */
    14. 

  14. /*  understand and accept it fully.                                        */
    15. 

  15. /*                                                                         */
    16. 

  16. /***************************************************************************/
    17. 

  17. 

  18.   /*************************************************************************/
    19. 

  19.   /*                                                                       */
    20. 

  20.   /* This file can be compiled without the rest of the FreeType engine, by */
    21. 

  21.   /* defining the _STANDALONE_ macro when compiling it.  You also need to  */
    22. 

  22.   /* put the files `ftimage.h' and `ftmisc.h' into the $(incdir)           */
    23. 

  23.   /* directory.  Typically, you should do something like                   */
    24. 

  24.   /*                                                                       */
    25. 

  25.   /* - copy `src/raster/ftraster.c' (this file) to your current directory  */
    26. 

  26.   /*                                                                       */
    27. 

  27.   /* - copy `include/freetype/ftimage.h' and `src/raster/ftmisc.h'         */
    28. 

  28.   /*   to your current directory                                           */
    29. 

  29.   /*                                                                       */
    30. 

  30.   /* - compile `ftraster' with the _STANDALONE_ macro defined, as in       */
    31. 

  31.   /*                                                                       */
    32. 

  32.   /*     cc -c -D_STANDALONE_ ftraster.c                                   */
    33. 

  33.   /*                                                                       */
    34. 

  34.   /* The renderer can be initialized with a call to                        */
    35. 

  35.   /* `ft_standard_raster.raster_new'; a bitmap can be generated            */
    36. 

  36.   /* with a call to `ft_standard_raster.raster_render'.                    */
    37. 

  37.   /*                                                                       */
    38. 

  38.   /* See the comments and documentation in the file `ftimage.h' for more   */
    39. 

  39.   /* details on how the raster works.                                      */
    40. 

  40.   /*                                                                       */
    41. 

  41.   /*************************************************************************/
    42. 

  42. 

  43. 

  44.   /*************************************************************************/
    45. 

  45.   /*                                                                       */
    46. 

  46.   /* This is a rewrite of the FreeType 1.x scan-line converter             */
    47. 

  47.   /*                                                                       */
    48. 

  48.   /*************************************************************************/
    49. 

  49. 

  50. #ifdef _STANDALONE_
    51. 

  51. 

  52. #define FT_CONFIG_STANDARD_LIBRARY_H  <stdlib.h>
    53. 

  53. 

  54. #include <string.h>           /* for memset */
    55. 

  55. 

  56. #include "ftmisc.h"
    57. 

  57. #include "ftimage.h"
    58. 

  58. 

  59. #else /* !_STANDALONE_ */
    60. 

  60. 

  61. #include <ft2build.h>
    62. 

  62. #include "ftraster.h"
    63. 

  63. #include FT_INTERNAL_CALC_H   /* for FT_MulDiv only */
    64. 

  64. 

  65. #include "rastpic.h"
    66. 

  66. 

  67. #endif /* !_STANDALONE_ */
    68. 

  68. 

  69. 

  70.   /*************************************************************************/
    71. 

  71.   /*                                                                       */
    72. 

  72.   /* A simple technical note on how the raster works                       */
    73. 

  73.   /* -----------------------------------------------                       */
    74. 

  74.   /*                                                                       */
    75. 

  75.   /*   Converting an outline into a bitmap is achieved in several steps:   */
    76. 

  76.   /*                                                                       */
    77. 

  77.   /*   1 - Decomposing the outline into successive `profiles'.  Each       */
    78. 

  78.   /*       profile is simply an array of scanline intersections on a given */
    79. 

  79.   /*       dimension.  A profile's main attributes are                     */
    80. 

  80.   /*                                                                       */
    81. 

  81.   /*       o its scanline position boundaries, i.e. `Ymin' and `Ymax'      */
    82. 

  82.   /*                                                                       */
    83. 

  83.   /*       o an array of intersection coordinates for each scanline        */
    84. 

  84.   /*         between `Ymin' and `Ymax'                                     */
    85. 

  85.   /*                                                                       */
    86. 

  86.   /*       o a direction, indicating whether it was built going `up' or    */
    87. 

  87.   /*         `down', as this is very important for filling rules           */
    88. 

  88.   /*                                                                       */
    89. 

  89.   /*       o its drop-out mode                                             */
    90. 

  90.   /*                                                                       */
    91. 

  91.   /*   2 - Sweeping the target map's scanlines in order to compute segment */
    92. 

  92.   /*       `spans' which are then filled.  Additionally, this pass         */
    93. 

  93.   /*       performs drop-out control.                                      */
    94. 

  94.   /*                                                                       */
    95. 

  95.   /*   The outline data is parsed during step 1 only.  The profiles are    */
    96. 

  96.   /*   built from the bottom of the render pool, used as a stack.  The     */
    97. 

  97.   /*   following graphics shows the profile list under construction:       */
    98. 

  98.   /*                                                                       */
    99. 

  99.   /*     __________________________________________________________ _ _    */
    100. 

  100.   /*    |         |                 |         |                 |          */
    101. 

  101.   /*    | profile | coordinates for | profile | coordinates for |-->       */
    102. 

  102.   /*    |    1    |  profile 1      |    2    |  profile 2      |-->       */
    103. 

  103.   /*    |_________|_________________|_________|_________________|__ _ _    */
    104. 

  104.   /*                                                                       */
    105. 

  105.   /*    ^                                                       ^          */
    106. 

  106.   /*    |                                                       |          */
    107. 

  107.   /* start of render pool                                      top         */
    108. 

  108.   /*                                                                       */
    109. 

  109.   /*   The top of the profile stack is kept in the `top' variable.         */
    110. 

  110.   /*                                                                       */
    111. 

  111.   /*   As you can see, a profile record is pushed on top of the render     */
    112. 

  112.   /*   pool, which is then followed by its coordinates/intersections.  If  */
    113. 

  113.   /*   a change of direction is detected in the outline, a new profile is  */
    114. 

  114.   /*   generated until the end of the outline.                             */
    115. 

  115.   /*                                                                       */
    116. 

  116.   /*   Note that when all profiles have been generated, the function       */
    117. 

  117.   /*   Finalize_Profile_Table() is used to record, for each profile, its   */
    118. 

  118.   /*   bottom-most scanline as well as the scanline above its upmost       */
    119. 

  119.   /*   boundary.  These positions are called `y-turns' because they (sort  */
    120. 

  120.   /*   of) correspond to local extrema.  They are stored in a sorted list  */
    121. 

  121.   /*   built from the top of the render pool as a downwards stack:         */
    122. 

  122.   /*                                                                       */
    123. 

  123.   /*      _ _ _______________________________________                      */
    124. 

  124.   /*                            |                    |                     */
    125. 

  125.   /*                         <--| sorted list of     |                     */
    126. 

  126.   /*                         <--|  extrema scanlines |                     */
    127. 

  127.   /*      _ _ __________________|____________________|                     */
    128. 

  128.   /*                                                                       */
    129. 

  129.   /*                            ^                    ^                     */
    130. 

  130.   /*                            |                    |                     */
    131. 

  131.   /*                         maxBuff           sizeBuff = end of pool      */
    132. 

  132.   /*                                                                       */
    133. 

  133.   /*   This list is later used during the sweep phase in order to          */
    134. 

  134.   /*   optimize performance (see technical note on the sweep below).       */
    135. 

  135.   /*                                                                       */
    136. 

  136.   /*   Of course, the raster detects whether the two stacks collide and    */
    137. 

  137.   /*   handles the situation properly.                                     */
    138. 

  138.   /*                                                                       */
    139. 

  139.   /*************************************************************************/
    140. 

  140. 

  141. 

  142.   /*************************************************************************/
    143. 

  143.   /*************************************************************************/
    144. 

  144.   /**                                                                     **/
    145. 

  145.   /**  CONFIGURATION MACROS                                               **/
    146. 

  146.   /**                                                                     **/
    147. 

  147.   /*************************************************************************/
    148. 

  148.   /*************************************************************************/
    149. 

  149. 

  150.   /* define DEBUG_RASTER if you want to compile a debugging version */
    151. 

  151. /* #define DEBUG_RASTER */
    152. 

  152. 

  153.   /* define FT_RASTER_OPTION_ANTI_ALIASING if you want to support */
    154. 

  154.   /* 5-levels anti-aliasing                                       */
    155. 

  155. /* #define FT_RASTER_OPTION_ANTI_ALIASING */
    156. 

  156. 

  157.   /* The size of the two-lines intermediate bitmap used */
    158. 

  158.   /* for anti-aliasing, in bytes.                       */
    159. 

  159. #define RASTER_GRAY_LINES  2048
    160. 

  160. 

  161. 

  162.   /*************************************************************************/
    163. 

  163.   /*************************************************************************/
    164. 

  164.   /**                                                                     **/
    165. 

  165.   /**  OTHER MACROS (do not change)                                       **/
    166. 

  166.   /**                                                                     **/
    167. 

  167.   /*************************************************************************/
    168. 

  168.   /*************************************************************************/
    169. 

  169. 

  170.   /*************************************************************************/
    171. 

  171.   /*                                                                       */
    172. 

  172.   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
    173. 

  173.   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
    174. 

  174.   /* messages during execution.                                            */
    175. 

  175.   /*                                                                       */
    176. 

  176. #undef  FT_COMPONENT
    177. 

  177. #define FT_COMPONENT  trace_raster
    178. 

  178. 

  179. 

  180. #ifdef _STANDALONE_
    181. 

  181. 

  182. 

  183.   /* This macro is used to indicate that a function parameter is unused. */
    184. 

  184.   /* Its purpose is simply to reduce compiler warnings.  Note also that  */
    185. 

  185.   /* simply defining it as `(void)x' doesn't avoid warnings with certain */
    186. 

  186.   /* ANSI compilers (e.g. LCC).                                          */
    187. 

  187. #define FT_UNUSED( x )  (x) = (x)
    188. 

  188. 

  189.   /* Disable the tracing mechanism for simplicity -- developers can      */
    190. 

  190.   /* activate it easily by redefining these two macros.                  */
    191. 

  191. #ifndef FT_ERROR
    192. 

  192. #define FT_ERROR( x )  do { } while ( 0 )     /* nothing */
    193. 

  193. #endif
    194. 

  194. 

  195. #ifndef FT_TRACE
    196. 

  196. #define FT_TRACE( x )   do { } while ( 0 )    /* nothing */
    197. 

  197. #define FT_TRACE1( x )  do { } while ( 0 )    /* nothing */
    198. 

  198. #define FT_TRACE6( x )  do { } while ( 0 )    /* nothing */
    199. 

  199. #endif
    200. 

  200. 

  201. #define Raster_Err_None          0
    202. 

  202. #define Raster_Err_Not_Ini      -1
    203. 

  203. #define Raster_Err_Overflow     -2
    204. 

  204. #define Raster_Err_Neg_Height   -3
    205. 

  205. #define Raster_Err_Invalid      -4
    206. 

  206. #define Raster_Err_Unsupported  -5
    207. 

  207. 

  208. #define ft_memset  memset
    209. 

  209. 

  210. #define FT_DEFINE_RASTER_FUNCS( class_, glyph_format_, raster_new_, \
    211. 

  211.                                 raster_reset_, raster_set_mode_,    \
    212. 

  212.                                 raster_render_, raster_done_ )      \
    213. 

  213.           const FT_Raster_Funcs class_ =                            \
    214. 

  214.           {                                                         \
    215. 

  215.             glyph_format_,                                          \
    216. 

  216.             raster_new_,                                            \
    217. 

  217.             raster_reset_,                                          \
    218. 

  218.             raster_set_mode_,                                       \
    219. 

  219.             raster_render_,                                         \
    220. 

  220.             raster_done_                                            \
    221. 

  221.          };
    222. 

  222. 

  223. #else /* !_STANDALONE_ */
    224. 

  224. 

  225. 

  226. #include FT_INTERNAL_OBJECTS_H
    227. 

  227. #include FT_INTERNAL_DEBUG_H        /* for FT_TRACE() and FT_ERROR() */
    228. 

  228. 

  229. #include "rasterrs.h"
    230. 

  230. 

  231. #define Raster_Err_None         Raster_Err_Ok
    232. 

  232. #define Raster_Err_Not_Ini      Raster_Err_Raster_Uninitialized
    233. 

  233. #define Raster_Err_Overflow     Raster_Err_Raster_Overflow
    234. 

  234. #define Raster_Err_Neg_Height   Raster_Err_Raster_Negative_Height
    235. 

  235. #define Raster_Err_Invalid      Raster_Err_Invalid_Outline
    236. 

  236. #define Raster_Err_Unsupported  Raster_Err_Cannot_Render_Glyph
    237. 

  237. 

  238. 

  239. #endif /* !_STANDALONE_ */
    240. 

  240. 

  241. 

  242. #ifndef FT_MEM_SET
    243. 

  243. #define FT_MEM_SET( d, s, c )  ft_memset( d, s, c )
    244. 

  244. #endif
    245. 

  245. 

  246. #ifndef FT_MEM_ZERO
    247. 

  247. #define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
    248. 

  248. #endif
    249. 

  249. 

  250.   /* FMulDiv means `Fast MulDiv'; it is used in case where `b' is       */
    251. 

  251.   /* typically a small value and the result of a*b is known to fit into */
    252. 

  252.   /* 32 bits.                                                           */
    253. 

  253. #define FMulDiv( a, b, c )  ( (a) * (b) / (c) )
    254. 

  254. 

  255.   /* On the other hand, SMulDiv means `Slow MulDiv', and is used typically */
    256. 

  256.   /* for clipping computations.  It simply uses the FT_MulDiv() function   */
    257. 

  257.   /* defined in `ftcalc.h'.                                                */
    258. 

  258. #define SMulDiv  FT_MulDiv
    259. 

  259. 

  260.   /* The rasterizer is a very general purpose component; please leave */
    261. 

  261.   /* the following redefinitions there (you never know your target    */
    262. 

  262.   /* environment).                                                    */
    263. 

  263. 

  264. #ifndef TRUE
    265. 

  265. #define TRUE   1
    266. 

  266. #endif
    267. 

  267. 

  268. #ifndef FALSE
    269. 

  269. #define FALSE  0
    270. 

  270. #endif
    271. 

  271. 

  272. #ifndef NULL
    273. 

  273. #define NULL  (void*)0
    274. 

  274. #endif
    275. 

  275. 

  276. #ifndef SUCCESS
    277. 

  277. #define SUCCESS  0
    278. 

  278. #endif
    279. 

  279. 

  280. #ifndef FAILURE
    281. 

  281. #define FAILURE  1
    282. 

  282. #endif
    283. 

  283. 

  284. 

  285. #define MaxBezier  32   /* The maximum number of stacked Bezier curves. */
    286. 

  286.                         /* Setting this constant to more than 32 is a   */
    287. 

  287.                         /* pure waste of space.                         */
    288. 

  288. 

  289. #define Pixel_Bits  6   /* fractional bits of *input* coordinates */
    290. 

  290. 

  291. 

  292.   /*************************************************************************/
    293. 

  293.   /*************************************************************************/
    294. 

  294.   /**                                                                     **/
    295. 

  295.   /**  SIMPLE TYPE DECLARATIONS                                           **/
    296. 

  296.   /**                                                                     **/
    297. 

  297.   /*************************************************************************/
    298. 

  298.   /*************************************************************************/
    299. 

  299. 

  300.   typedef int             Int;
    301. 

  301.   typedef unsigned int    UInt;
    302. 

  302.   typedef short           Short;
    303. 

  303.   typedef unsigned short  UShort, *PUShort;
    304. 

  304.   typedef long            Long, *PLong;
    305. 

  305. 

  306.   typedef unsigned char   Byte, *PByte;
    307. 

  307.   typedef char            Bool;
    308. 

  308. 

  309. 

  310.   typedef union  Alignment_
    311. 

  311.   {
    312. 

  312.     long    l;
    313. 

  313.     void*   p;
    314. 

  314.     void  (*f)(void);
    315. 

  315. 

  316.   } Alignment, *PAlignment;
    317. 

  317. 

  318. 

  319.   typedef struct  TPoint_
    320. 

  320.   {
    321. 

  321.     Long  x;
    322. 

  322.     Long  y;
    323. 

  323. 

  324.   } TPoint;
    325. 

  325. 

  326. 

  327.   /* values for the `flags' bit field */
    328. 

  328. #define Flow_Up           0x8
    329. 

  329. #define Overshoot_Top     0x10
    330. 

  330. #define Overshoot_Bottom  0x20
    331. 

  331. 

  332. 

  333.   /* States of each line, arc, and profile */
    334. 

  334.   typedef enum  TStates_
    335. 

  335.   {
    336. 

  336.     Unknown_State,
    337. 

  337.     Ascending_State,
    338. 

  338.     Descending_State,
    339. 

  339.     Flat_State
    340. 

  340. 

  341.   } TStates;
    342. 

  342. 

  343. 

  344.   typedef struct TProfile_  TProfile;
    345. 

  345.   typedef TProfile*         PProfile;
    346. 

  346. 

  347.   struct  TProfile_
    348. 

  348.   {
    349. 

  349.     FT_F26Dot6  X;           /* current coordinate during sweep          */
    350. 

  350.     PProfile    link;        /* link to next profile (various purposes)  */
    351. 

  351.     PLong       offset;      /* start of profile's data in render pool   */
    352. 

  352.     unsigned    flags;       /* Bit 0-2: drop-out mode                   */
    353. 

  353.                              /* Bit 3: profile orientation (up/down)     */
    354. 

  354.                              /* Bit 4: is top profile?                   */
    355. 

  355.                              /* Bit 5: is bottom profile?                */
    356. 

  356.     long        height;      /* profile's height in scanlines            */
    357. 

  357.     long        start;       /* profile's starting scanline              */
    358. 

  358. 

  359.     unsigned    countL;      /* number of lines to step before this      */
    360. 

  360.                              /* profile becomes drawable                 */
    361. 

  361. 

  362.     PProfile    next;        /* next profile in same contour, used       */
    363. 

  363.                              /* during drop-out control                  */
    364. 

  364.   };
    365. 

  365. 

  366.   typedef PProfile   TProfileList;
    367. 

  367.   typedef PProfile*  PProfileList;
    368. 

  368. 

  369. 

  370.   /* Simple record used to implement a stack of bands, required */
    371. 

  371.   /* by the sub-banding mechanism                               */
    372. 

  372.   typedef struct  black_TBand_
    373. 

  373.   {
    374. 

  374.     Short  y_min;   /* band's minimum */
    375. 

  375.     Short  y_max;   /* band's maximum */
    376. 

  376. 

  377.   } black_TBand;
    378. 

  378. 

  379. 

  380. #define AlignProfileSize \
    381. 

  381.   ( ( sizeof ( TProfile ) + sizeof ( Alignment ) - 1 ) / sizeof ( long ) )
    382. 

  382. 

  383. 

  384. #undef RAS_ARG
    385. 

  385. #undef RAS_ARGS
    386. 

  386. #undef RAS_VAR
    387. 

  387. #undef RAS_VARS
    388. 

  388. 

  389. #ifdef FT_STATIC_RASTER
    390. 

  390. 

  391. 

  392. #define RAS_ARGS       /* void */
    393. 

  393. #define RAS_ARG        /* void */
    394. 

  394. 

  395. #define RAS_VARS       /* void */
    396. 

  396. #define RAS_VAR        /* void */
    397. 

  397. 

  398. #define FT_UNUSED_RASTER  do { } while ( 0 )
    399. 

  399. 

  400. 

  401. #else /* !FT_STATIC_RASTER */
    402. 

  402. 

  403. 

  404. #define RAS_ARGS       black_PWorker  worker,
    405. 

  405. #define RAS_ARG        black_PWorker  worker
    406. 

  406. 

  407. #define RAS_VARS       worker,
    408. 

  408. #define RAS_VAR        worker
    409. 

  409. 

  410. #define FT_UNUSED_RASTER  FT_UNUSED( worker )
    411. 

  411. 

  412. 

  413. #endif /* !FT_STATIC_RASTER */
    414. 

  414. 

  415. 

  416.   typedef struct black_TWorker_  black_TWorker, *black_PWorker;
    417. 

  417. 

  418. 

  419.   /* prototypes used for sweep function dispatch */
    420. 

  420.   typedef void
    421. 

  421.   Function_Sweep_Init( RAS_ARGS Short*  min,
    422. 

  422.                                 Short*  max );
    423. 

  423. 

  424.   typedef void
    425. 

  425.   Function_Sweep_Span( RAS_ARGS Short       y,
    426. 

  426.                                 FT_F26Dot6  x1,
    427. 

  427.                                 FT_F26Dot6  x2,
    428. 

  428.                                 PProfile    left,
    429. 

  429.                                 PProfile    right );
    430. 

  430. 

  431.   typedef void
    432. 

  432.   Function_Sweep_Step( RAS_ARG );
    433. 

  433. 

  434. 

  435.   /* NOTE: These operations are only valid on 2's complement processors */
    436. 

  436. #undef FLOOR
    437. 

  437. #undef CEILING
    438. 

  438. #undef TRUNC
    439. 

  439. #undef SCALED
    440. 

  440. 

  441. #define FLOOR( x )    ( (x) & -ras.precision )
    442. 

  442. #define CEILING( x )  ( ( (x) + ras.precision - 1 ) & -ras.precision )
    443. 

  443. #define TRUNC( x )    ( (signed long)(x) >> ras.precision_bits )
    444. 

  444. #define FRAC( x )     ( (x) & ( ras.precision - 1 ) )
    445. 

  445. #define SCALED( x )   ( ( (x) << ras.scale_shift ) - ras.precision_half )
    446. 

  446. 

  447. #define IS_BOTTOM_OVERSHOOT( x )  ( CEILING( x ) - x >= ras.precision_half )
    448. 

  448. #define IS_TOP_OVERSHOOT( x )     ( x - FLOOR( x ) >= ras.precision_half )
    449. 

  449. 

  450.   /* The most used variables are positioned at the top of the structure. */
    451. 

  451.   /* Thus, their offset can be coded with less opcodes, resulting in a   */
    452. 

  452.   /* smaller executable.                                                 */
    453. 

  453. 

  454.   struct  black_TWorker_
    455. 

  455.   {
    456. 

  456.     Int         precision_bits;     /* precision related variables         */
    457. 

  457.     Int         precision;
    458. 

  458.     Int         precision_half;
    459. 

  459.     Int         precision_shift;
    460. 

  460.     Int         precision_step;
    461. 

  461.     Int         precision_jitter;
    462. 

  462. 

  463.     Int         scale_shift;        /* == precision_shift   for bitmaps    */
    464. 

  464.                                     /* == precision_shift+1 for pixmaps    */
    465. 

  465. 

  466.     PLong       buff;               /* The profiles buffer                 */
    467. 

  467.     PLong       sizeBuff;           /* Render pool size                    */
    468. 

  468.     PLong       maxBuff;            /* Profiles buffer size                */
    469. 

  469.     PLong       top;                /* Current cursor in buffer            */
    470. 

  470. 

  471.     FT_Error    error;
    472. 

  472. 

  473.     Int         numTurns;           /* number of Y-turns in outline        */
    474. 

  474. 

  475.     TPoint*     arc;                /* current Bezier arc pointer          */
    476. 

  476. 

  477.     UShort      bWidth;             /* target bitmap width                 */
    478. 

  478.     PByte       bTarget;            /* target bitmap buffer                */
    479. 

  479.     PByte       gTarget;            /* target pixmap buffer                */
    480. 

  480. 

  481.     Long        lastX, lastY;
    482. 

  482.     Long        minY, maxY;
    483. 

  483. 

  484.     UShort      num_Profs;          /* current number of profiles          */
    485. 

  485. 

  486.     Bool        fresh;              /* signals a fresh new profile which   */
    487. 

  487.                                     /* `start' field must be completed     */
    488. 

  488.     Bool        joint;              /* signals that the last arc ended     */
    489. 

  489.                                     /* exactly on a scanline.  Allows      */
    490. 

  490.                                     /* removal of doublets                 */
    491. 

  491.     PProfile    cProfile;           /* current profile                     */
    492. 

  492.     PProfile    fProfile;           /* head of linked list of profiles     */
    493. 

  493.     PProfile    gProfile;           /* contour's first profile in case     */
    494. 

  494.                                     /* of impact                           */
    495. 

  495. 

  496.     TStates     state;              /* rendering state                     */
    497. 

  497. 

  498.     FT_Bitmap   target;             /* description of target bit/pixmap    */
    499. 

  499.     FT_Outline  outline;
    500. 

  500. 

  501.     Long        traceOfs;           /* current offset in target bitmap     */
    502. 

  502.     Long        traceG;             /* current offset in target pixmap     */
    503. 

  503. 

  504.     Short       traceIncr;          /* sweep's increment in target bitmap  */
    505. 

  505. 

  506.     Short       gray_min_x;         /* current min x during gray rendering */
    507. 

  507.     Short       gray_max_x;         /* current max x during gray rendering */
    508. 

  508. 

  509.     /* dispatch variables */
    510. 

  510. 

  511.     Function_Sweep_Init*  Proc_Sweep_Init;
    512. 

  512.     Function_Sweep_Span*  Proc_Sweep_Span;
    513. 

  513.     Function_Sweep_Span*  Proc_Sweep_Drop;
    514. 

  514.     Function_Sweep_Step*  Proc_Sweep_Step;
    515. 

  515. 

  516.     Byte        dropOutControl;     /* current drop_out control method     */
    517. 

  517. 

  518.     Bool        second_pass;        /* indicates whether a horizontal pass */
    519. 

  519.                                     /* should be performed to control      */
    520. 

  520.                                     /* drop-out accurately when calling    */
    521. 

  521.                                     /* Render_Glyph.  Note that there is   */
    522. 

  522.                                     /* no horizontal pass during gray      */
    523. 

  523.                                     /* rendering.                          */
    524. 

  524. 

  525.     TPoint      arcs[3 * MaxBezier + 1]; /* The Bezier stack               */
    526. 

  526. 

  527.     black_TBand  band_stack[16];    /* band stack used for sub-banding     */
    528. 

  528.     Int          band_top;          /* band stack top                      */
    529. 

  529. 

  530. #ifdef FT_RASTER_OPTION_ANTI_ALIASING
    531. 

  531. 

  532.     Byte*       grays;
    533. 

  533. 

  534.     Byte        gray_lines[RASTER_GRAY_LINES];
    535. 

  535.                                 /* Intermediate table used to render the   */
    536. 

  536.                                 /* graylevels pixmaps.                     */
    537. 

  537.                                 /* gray_lines is a buffer holding two      */
    538. 

  538.                                 /* monochrome scanlines                    */
    539. 

  539. 

  540.     Short       gray_width;     /* width in bytes of one monochrome        */
    541. 

  541.                                 /* intermediate scanline of gray_lines.    */
    542. 

  542.                                 /* Each gray pixel takes 2 bits long there */
    543. 

  543. 

  544.                        /* The gray_lines must hold 2 lines, thus with size */
    545. 

  545.                        /* in bytes of at least `gray_width*2'.             */
    546. 

  546. 

  547. #endif /* FT_RASTER_ANTI_ALIASING */
    548. 

  548. 

  549.   };
    550. 

  550. 

  551. 

  552.   typedef struct  black_TRaster_
    553. 

  553.   {
    554. 

  554.     char*          buffer;
    555. 

  555.     long           buffer_size;
    556. 

  556.     void*          memory;
    557. 

  557.     black_PWorker  worker;
    558. 

  558.     Byte           grays[5];
    559. 

  559.     Short          gray_width;
    560. 

  560. 

  561.   } black_TRaster, *black_PRaster;
    562. 

  562. 

  563. #ifdef FT_STATIC_RASTER
    564. 

  564. 

  565.   static black_TWorker  cur_ras;
    566. 

  566. #define ras  cur_ras
    567. 

  567. 

  568. #else /* !FT_STATIC_RASTER */
    569. 

  569. 

  570. #define ras  (*worker)
    571. 

  571. 

  572. #endif /* !FT_STATIC_RASTER */
    573. 

  573. 

  574. 

  575. #ifdef FT_RASTER_OPTION_ANTI_ALIASING
    576. 

  576. 

  577.   /* A lookup table used to quickly count set bits in four gray 2x2 */
    578. 

  578.   /* cells.  The values of the table have been produced with the    */
    579. 

  579.   /* following code:                                                */
    580. 

  580.   /*                                                                */
    581. 

  581.   /*   for ( i = 0; i < 256; i++ )                                  */
    582. 

  582.   /*   {                                                            */
    583. 

  583.   /*     l = 0;                                                     */
    584. 

  584.   /*     j = i;                                                     */
    585. 

  585.   /*                                                                */
    586. 

  586.   /*     for ( c = 0; c < 4; c++ )                                  */
    587. 

  587.   /*     {                                                          */
    588. 

  588.   /*       l <<= 4;                                                 */
    589. 

  589.   /*                                                                */
    590. 

  590.   /*       if ( j & 0x80 ) l++;                                     */
    591. 

  591.   /*       if ( j & 0x40 ) l++;                                     */
    592. 

  592.   /*                                                                */
    593. 

  593.   /*       j = ( j << 2 ) & 0xFF;                                   */
    594. 

  594.   /*     }                                                          */
    595. 

  595.   /*     printf( "0x%04X", l );                                     */
    596. 

  596.   /*   }                                                            */
    597. 

  597.   /*                                                                */
    598. 

  598. 

  599.   static const short  count_table[256] =
    600. 

  600.   {
    601. 

  601.     0x0000, 0x0001, 0x0001, 0x0002, 0x0010, 0x0011, 0x0011, 0x0012,
    602. 

  602.     0x0010, 0x0011, 0x0011, 0x0012, 0x0020, 0x0021, 0x0021, 0x0022,
    603. 

  603.     0x0100, 0x0101, 0x0101, 0x0102, 0x0110, 0x0111, 0x0111, 0x0112,
    604. 

  604.     0x0110, 0x0111, 0x0111, 0x0112, 0x0120, 0x0121, 0x0121, 0x0122,
    605. 

  605.     0x0100, 0x0101, 0x0101, 0x0102, 0x0110, 0x0111, 0x0111, 0x0112,
    606. 

  606.     0x0110, 0x0111, 0x0111, 0x0112, 0x0120, 0x0121, 0x0121, 0x0122,
    607. 

  607.     0x0200, 0x0201, 0x0201, 0x0202, 0x0210, 0x0211, 0x0211, 0x0212,
    608. 

  608.     0x0210, 0x0211, 0x0211, 0x0212, 0x0220, 0x0221, 0x0221, 0x0222,
    609. 

  609.     0x1000, 0x1001, 0x1001, 0x1002, 0x1010, 0x1011, 0x1011, 0x1012,
    610. 

  610.     0x1010, 0x1011, 0x1011, 0x1012, 0x1020, 0x1021, 0x1021, 0x1022,
    611. 

  611.     0x1100, 0x1101, 0x1101, 0x1102, 0x1110, 0x1111, 0x1111, 0x1112,
    612. 

  612.     0x1110, 0x1111, 0x1111, 0x1112, 0x1120, 0x1121, 0x1121, 0x1122,
    613. 

  613.     0x1100, 0x1101, 0x1101, 0x1102, 0x1110, 0x1111, 0x1111, 0x1112,
    614. 

  614.     0x1110, 0x1111, 0x1111, 0x1112, 0x1120, 0x1121, 0x1121, 0x1122,
    615. 

  615.     0x1200, 0x1201, 0x1201, 0x1202, 0x1210, 0x1211, 0x1211, 0x1212,
    616. 

  616.     0x1210, 0x1211, 0x1211, 0x1212, 0x1220, 0x1221, 0x1221, 0x1222,
    617. 

  617.     0x1000, 0x1001, 0x1001, 0x1002, 0x1010, 0x1011, 0x1011, 0x1012,
    618. 

  618.     0x1010, 0x1011, 0x1011, 0x1012, 0x1020, 0x1021, 0x1021, 0x1022,
    619. 

  619.     0x1100, 0x1101, 0x1101, 0x1102, 0x1110, 0x1111, 0x1111, 0x1112,
    620. 

  620.     0x1110, 0x1111, 0x1111, 0x1112, 0x1120, 0x1121, 0x1121, 0x1122,
    621. 

  621.     0x1100, 0x1101, 0x1101, 0x1102, 0x1110, 0x1111, 0x1111, 0x1112,
    622. 

  622.     0x1110, 0x1111, 0x1111, 0x1112, 0x1120, 0x1121, 0x1121, 0x1122,
    623. 

  623.     0x1200, 0x1201, 0x1201, 0x1202, 0x1210, 0x1211, 0x1211, 0x1212,
    624. 

  624.     0x1210, 0x1211, 0x1211, 0x1212, 0x1220, 0x1221, 0x1221, 0x1222,
    625. 

  625.     0x2000, 0x2001, 0x2001, 0x2002, 0x2010, 0x2011, 0x2011, 0x2012,
    626. 

  626.     0x2010, 0x2011, 0x2011, 0x2012, 0x2020, 0x2021, 0x2021, 0x2022,
    627. 

  627.     0x2100, 0x2101, 0x2101, 0x2102, 0x2110, 0x2111, 0x2111, 0x2112,
    628. 

  628.     0x2110, 0x2111, 0x2111, 0x2112, 0x2120, 0x2121, 0x2121, 0x2122,
    629. 

  629.     0x2100, 0x2101, 0x2101, 0x2102, 0x2110, 0x2111, 0x2111, 0x2112,
    630. 

  630.     0x2110, 0x2111, 0x2111, 0x2112, 0x2120, 0x2121, 0x2121, 0x2122,
    631. 

  631.     0x2200, 0x2201, 0x2201, 0x2202, 0x2210, 0x2211, 0x2211, 0x2212,
    632. 

  632.     0x2210, 0x2211, 0x2211, 0x2212, 0x2220, 0x2221, 0x2221, 0x2222
    633. 

  633.   };
    634. 

  634. 

  635. #endif /* FT_RASTER_OPTION_ANTI_ALIASING */
    636. 

  636. 

  637. 

  638. 

  639.   /*************************************************************************/
    640. 

  640.   /*************************************************************************/
    641. 

  641.   /**                                                                     **/
    642. 

  642.   /**  PROFILES COMPUTATION                                               **/
    643. 

  643.   /**                                                                     **/
    644. 

  644.   /*************************************************************************/
    645. 

  645.   /*************************************************************************/
    646. 

  646. 

  647. 

  648.   /*************************************************************************/
    649. 

  649.   /*                                                                       */
    650. 

  650.   /* <Function>                                                            */
    651. 

  651.   /*    Set_High_Precision                                                 */
    652. 

  652.   /*                                                                       */
    653. 

  653.   /* <Description>                                                         */
    654. 

  654.   /*    Set precision variables according to param flag.                   */
    655. 

  655.   /*                                                                       */
    656. 

  656.   /* <Input>                                                               */
    657. 

  657.   /*    High :: Set to True for high precision (typically for ppem < 18),  */
    658. 

  658.   /*            false otherwise.                                           */
    659. 

  659.   /*                                                                       */
    660. 

  660.   static void
    661. 

  661.   Set_High_Precision( RAS_ARGS Int  High )
    662. 

  662.   {
    663. 

  663.     /*
    664. 

  664.      * `precision_step' is used in `Bezier_Up' to decide when to split a
    665. 

  665.      * given y-monotonous Bezier arc that crosses a scanline before
    666. 

  666.      * approximating it as a straight segment.  The default value of 32 (for
    667. 

  667.      * low accuracy) corresponds to
    668. 

  668.      *
    669. 

  669.      *   32 / 64 == 0.5 pixels ,
    670. 

  670.      *
    671. 

  671.      * while for the high accuracy case we have
    672. 

  672.      *
    673. 

  673.      *   256/ (1 << 12) = 0.0625 pixels .
    674. 

  674.      *
    675. 

  675.      * `precision_jitter' is an epsilon threshold used in
    676. 

  676.      * `Vertical_Sweep_Span' to deal with small imperfections in the Bezier
    677. 

  677.      * decomposition (after all, we are working with approximations only);
    678. 

  678.      * it avoids switching on additional pixels which would cause artifacts
    679. 

  679.      * otherwise.
    680. 

  680.      *
    681. 

  681.      * The value of `precision_jitter' has been determined heuristically.
    682. 

  682.      *
    683. 

  683.      */
    684. 

  684. 

  685.     if ( High )
    686. 

  686.     {
    687. 

  687.       ras.precision_bits   = 12;
    688. 

  688.       ras.precision_step   = 256;
    689. 

  689.       ras.precision_jitter = 30;
    690. 

  690.     }
    691. 

  691.     else
    692. 

  692.     {
    693. 

  693.       ras.precision_bits   = 6;
    694. 

  694.       ras.precision_step   = 32;
    695. 

  695.       ras.precision_jitter = 2;
    696. 

  696.     }
    697. 

  697. 

  698.     FT_TRACE6(( "Set_High_Precision(%s)\n", High ? "true" : "false" ));
    699. 

  699. 

  700.     ras.precision       = 1 << ras.precision_bits;
    701. 

  701.     ras.precision_half  = ras.precision / 2;
    702. 

  702.     ras.precision_shift = ras.precision_bits - Pixel_Bits;
    703. 

  703.   }
    704. 

  704. 

  705. 

  706.   /*************************************************************************/
    707. 

  707.   /*                                                                       */
    708. 

  708.   /* <Function>                                                            */
    709. 

  709.   /*    New_Profile                                                        */
    710. 

  710.   /*                                                                       */
    711. 

  711.   /* <Description>                                                         */
    712. 

  712.   /*    Create a new profile in the render pool.                           */
    713. 

  713.   /*                                                                       */
    714. 

  714.   /* <Input>                                                               */
    715. 

  715.   /*    aState    :: The state/orientation of the new profile.             */
    716. 

  716.   /*                                                                       */
    717. 

  717.   /*    overshoot :: Whether the profile's unrounded start position        */
    718. 

  718.   /*                 differs by at least a half pixel.                     */
    719. 

  719.   /*                                                                       */
    720. 

  720.   /* <Return>                                                              */
    721. 

  721.   /*   SUCCESS on success.  FAILURE in case of overflow or of incoherent   */
    722. 

  722.   /*   profile.                                                            */
    723. 

  723.   /*                                                                       */
    724. 

  724.   static Bool
    725. 

  725.   New_Profile( RAS_ARGS TStates  aState,
    726. 

  726.                         Bool     overshoot )
    727. 

  727.   {
    728. 

  728.     if ( !ras.fProfile )
    729. 

  729.     {
    730. 

  730.       ras.cProfile  = (PProfile)ras.top;
    731. 

  731.       ras.fProfile  = ras.cProfile;
    732. 

  732.       ras.top      += AlignProfileSize;
    733. 

  733.     }
    734. 

  734. 

  735.     if ( ras.top >= ras.maxBuff )
    736. 

  736.     {
    737. 

  737.       ras.error = Raster_Err_Overflow;
    738. 

  738.       return FAILURE;
    739. 

  739.     }
    740. 

  740. 

  741.     ras.cProfile->flags  = 0;
    742. 

  742.     ras.cProfile->start  = 0;
    743. 

  743.     ras.cProfile->height = 0;
    744. 

  744.     ras.cProfile->offset = ras.top;
    745. 

  745.     ras.cProfile->link   = (PProfile)0;
    746. 

  746.     ras.cProfile->next   = (PProfile)0;
    747. 

  747.     ras.cProfile->flags  = ras.dropOutControl;
    748. 

  748. 

  749.     switch ( aState )
    750. 

  750.     {
    751. 

  751.     case Ascending_State:
    752. 

  752.       ras.cProfile->flags |= Flow_Up;
    753. 

  753.       if ( overshoot )
    754. 

  754.         ras.cProfile->flags |= Overshoot_Bottom;
    755. 

  755. 

  756.       FT_TRACE6(( "New ascending profile = %p\n", ras.cProfile ));
    757. 

  757.       break;
    758. 

  758. 

  759.     case Descending_State:
    760. 

  760.       if ( overshoot )
    761. 

  761.         ras.cProfile->flags |= Overshoot_Top;
    762. 

  762.       FT_TRACE6(( "New descending profile = %p\n", ras.cProfile ));
    763. 

  763.       break;
    764. 

  764. 

  765.     default:
    766. 

  766.       FT_ERROR(( "New_Profile: invalid profile direction\n" ));
    767. 

  767.       ras.error = Raster_Err_Invalid;
    768. 

  768.       return FAILURE;
    769. 

  769.     }
    770. 

  770. 

  771.     if ( !ras.gProfile )
    772. 

  772.       ras.gProfile = ras.cProfile;
    773. 

  773. 

  774.     ras.state = aState;
    775. 

  775.     ras.fresh = TRUE;
    776. 

  776.     ras.joint = FALSE;
    777. 

  777. 

  778.     return SUCCESS;
    779. 

  779.   }
    780. 

  780. 

  781. 

  782.   /*************************************************************************/
    783. 

  783.   /*                                                                       */
    784. 

  784.   /* <Function>                                                            */
    785. 

  785.   /*    End_Profile                                                        */
    786. 

  786.   /*                                                                       */
    787. 

  787.   /* <Description>                                                         */
    788. 

  788.   /*    Finalize the current profile.                                      */
    789. 

  789.   /*                                                                       */
    790. 

  790.   /* <Input>                                                               */
    791. 

  791.   /*    overshoot :: Whether the profile's unrounded end position differs  */
    792. 

  792.   /*                 by at least a half pixel.                             */
    793. 

  793.   /*                                                                       */
    794. 

  794.   /* <Return>                                                              */
    795. 

  795.   /*    SUCCESS on success.  FAILURE in case of overflow or incoherency.   */
    796. 

  796.   /*                                                                       */
    797. 

  797.   static Bool
    798. 

  798.   End_Profile( RAS_ARGS Bool  overshoot )
    799. 

  799.   {
    800. 

  800.     Long      h;
    801. 

  801.     PProfile  oldProfile;
    802. 

  802. 

  803. 

  804.     h = (Long)( ras.top - ras.cProfile->offset );
    805. 

  805. 

  806.     if ( h < 0 )
    807. 

  807.     {
    808. 

  808.       FT_ERROR(( "End_Profile: negative height encountered\n" ));
    809. 

  809.       ras.error = Raster_Err_Neg_Height;
    810. 

  810.       return FAILURE;
    811. 

  811.     }
    812. 

  812. 

  813.     if ( h > 0 )
    814. 

  814.     {
    815. 

  815.       FT_TRACE6(( "Ending profile %p, start = %ld, height = %ld\n",
    816. 

  816.                   ras.cProfile, ras.cProfile->start, h ));
    817. 

  817. 

  818.       ras.cProfile->height = h;
    819. 

  819.       if ( overshoot )
    820. 

  820.       {
    821. 

  821.         if ( ras.cProfile->flags & Flow_Up )
    822. 

  822.           ras.cProfile->flags |= Overshoot_Top;
    823. 

  823.         else
    824. 

  824.           ras.cProfile->flags |= Overshoot_Bottom;
    825. 

  825.       }
    826. 

  826. 

  827.       oldProfile   = ras.cProfile;
    828. 

  828.       ras.cProfile = (PProfile)ras.top;
    829. 

  829. 

  830.       ras.top += AlignProfileSize;
    831. 

  831. 

  832.       ras.cProfile->height = 0;
    833. 

  833.       ras.cProfile->offset = ras.top;
    834. 

  834. 

  835.       oldProfile->next = ras.cProfile;
    836. 

  836.       ras.num_Profs++;
    837. 

  837.     }
    838. 

  838. 

  839.     if ( ras.top >= ras.maxBuff )
    840. 

  840.     {
    841. 

  841.       FT_TRACE1(( "overflow in End_Profile\n" ));
    842. 

  842.       ras.error = Raster_Err_Overflow;
    843. 

  843.       return FAILURE;
    844. 

  844.     }
    845. 

  845. 

  846.     ras.joint = FALSE;
    847. 

  847. 

  848.     return SUCCESS;
    849. 

  849.   }
    850. 

  850. 

  851. 

  852.   /*************************************************************************/
    853. 

  853.   /*                                                                       */
    854. 

  854.   /* <Function>                                                            */
    855. 

  855.   /*    Insert_Y_Turn                                                      */
    856. 

  856.   /*                                                                       */
    857. 

  857.   /* <Description>                                                         */
    858. 

  858.   /*    Insert a salient into the sorted list placed on top of the render  */
    859. 

  859.   /*    pool.                                                              */
    860. 

  860.   /*                                                                       */
    861. 

  861.   /* <Input>                                                               */
    862. 

  862.   /*    New y scanline position.                                           */
    863. 

  863.   /*                                                                       */
    864. 

  864.   /* <Return>                                                              */
    865. 

  865.   /*    SUCCESS on success.  FAILURE in case of overflow.                  */
    866. 

  866.   /*                                                                       */
    867. 

  867.   static Bool
    868. 

  868.   Insert_Y_Turn( RAS_ARGS Int  y )
    869. 

  869.   {
    870. 

  870.     PLong  y_turns;
    871. 

  871.     Int    y2, n;
    872. 

  872. 

  873. 

  874.     n       = ras.numTurns - 1;
    875. 

  875.     y_turns = ras.sizeBuff - ras.numTurns;
    876. 

  876. 

  877.     /* look for first y value that is <= */
    878. 

  878.     while ( n >= 0 && y < y_turns[n] )
    879. 

  879.       n--;
    880. 

  880. 

  881.     /* if it is <, simply insert it, ignore if == */
    882. 

  882.     if ( n >= 0 && y > y_turns[n] )
    883. 

  883.       while ( n >= 0 )
    884. 

  884.       {
    885. 

  885.         y2 = (Int)y_turns[n];
    886. 

  886.         y_turns[n] = y;
    887. 

  887.         y = y2;
    888. 

  888.         n--;
    889. 

  889.       }
    890. 

  890. 

  891.     if ( n < 0 )
    892. 

  892.     {
    893. 

  893.       ras.maxBuff--;
    894. 

  894.       if ( ras.maxBuff <= ras.top )
    895. 

  895.       {
    896. 

  896.         ras.error = Raster_Err_Overflow;
    897. 

  897.         return FAILURE;
    898. 

  898.       }
    899. 

  899.       ras.numTurns++;
    900. 

  900.       ras.sizeBuff[-ras.numTurns] = y;
    901. 

  901.     }
    902. 

  902. 

  903.     return SUCCESS;
    904. 

  904.   }
    905. 

  905. 

  906. 

  907.   /*************************************************************************/
    908. 

  908.   /*                                                                       */
    909. 

  909.   /* <Function>                                                            */
    910. 

  910.   /*    Finalize_Profile_Table                                             */
    911. 

  911.   /*                                                                       */
    912. 

  912.   /* <Description>                                                         */
    913. 

  913.   /*    Adjust all links in the profiles list.                             */
    914. 

  914.   /*                                                                       */
    915. 

  915.   /* <Return>                                                              */
    916. 

  916.   /*    SUCCESS on success.  FAILURE in case of overflow.                  */
    917. 

  917.   /*                                                                       */
    918. 

  918.   static Bool
    919. 

  919.   Finalize_Profile_Table( RAS_ARG )
    920. 

  920.   {
    921. 

  921.     Int       bottom, top;
    922. 

  922.     UShort    n;
    923. 

  923.     PProfile  p;
    924. 

  924. 

  925. 

  926.     n = ras.num_Profs;
    927. 

  927.     p = ras.fProfile;
    928. 

  928. 

  929.     if ( n > 1 && p )
    930. 

  930.     {
    931. 

  931.       while ( n > 0 )
    932. 

  932.       {
    933. 

  933.         if ( n > 1 )
    934. 

  934.           p->link = (PProfile)( p->offset + p->height );
    935. 

  935.         else
    936. 

  936.           p->link = NULL;
    937. 

  937. 

  938.         if ( p->flags & Flow_Up )
    939. 

  939.         {
    940. 

  940.           bottom = (Int)p->start;
    941. 

  941.           top    = (Int)( p->start + p->height - 1 );
    942. 

  942.         }
    943. 

  943.         else
    944. 

  944.         {
    945. 

  945.           bottom     = (Int)( p->start - p->height + 1 );
    946. 

  946.           top        = (Int)p->start;
    947. 

  947.           p->start   = bottom;
    948. 

  948.           p->offset += p->height - 1;
    949. 

  949.         }
    950. 

  950. 

  951.         if ( Insert_Y_Turn( RAS_VARS bottom )  ||
    952. 

  952.              Insert_Y_Turn( RAS_VARS top + 1 ) )
    953. 

  953.           return FAILURE;
    954. 

  954. 

  955.         p = p->link;
    956. 

  956.         n--;
    957. 

  957.       }
    958. 

  958.     }
    959. 

  959.     else
    960. 

  960.       ras.fProfile = NULL;
    961. 

  961. 

  962.     return SUCCESS;
    963. 

  963.   }
    964. 

  964. 

  965. 

  966.   /*************************************************************************/
    967. 

  967.   /*                                                                       */
    968. 

  968.   /* <Function>                                                            */
    969. 

  969.   /*    Split_Conic                                                        */
    970. 

  970.   /*                                                                       */
    971. 

  971.   /* <Description>                                                         */
    972. 

  972.   /*    Subdivide one conic Bezier into two joint sub-arcs in the Bezier   */
    973. 

  973.   /*    stack.                                                             */
    974. 

  974.   /*                                                                       */
    975. 

  975.   /* <Input>                                                               */
    976. 

  976.   /*    None (subdivided Bezier is taken from the top of the stack).       */
    977. 

  977.   /*                                                                       */
    978. 

  978.   /* <Note>                                                                */
    979. 

  979.   /*    This routine is the `beef' of this component.  It is  _the_ inner  */
    980. 

  980.   /*    loop that should be optimized to hell to get the best performance. */
    981. 

  981.   /*                                                                       */
    982. 

  982.   static void
    983. 

  983.   Split_Conic( TPoint*  base )
    984. 

  984.   {
    985. 

  985.     Long  a, b;
    986. 

  986. 

  987. 

  988.     base[4].x = base[2].x;
    989. 

  989.     b = base[1].x;
    990. 

  990.     a = base[3].x = ( base[2].x + b ) / 2;
    991. 

  991.     b = base[1].x = ( base[0].x + b ) / 2;
    992. 

  992.     base[2].x = ( a + b ) / 2;
    993. 

  993. 

  994.     base[4].y = base[2].y;
    995. 

  995.     b = base[1].y;
    996. 

  996.     a = base[3].y = ( base[2].y + b ) / 2;
    997. 

  997.     b = base[1].y = ( base[0].y + b ) / 2;
    998. 

  998.     base[2].y = ( a + b ) / 2;
    999. 

  999. 

  1000.     /* hand optimized.  gcc doesn't seem to be too good at common      */
    1001. 

  1001.     /* expression substitution and instruction scheduling ;-)          */
    1002. 

  1002.   }
    1003. 

  1003. 

  1004. 

  1005.   /*************************************************************************/
    1006. 

  1006.   /*                                                                       */
    1007. 

  1007.   /* <Function>                                                            */
    1008. 

  1008.   /*    Split_Cubic                                                        */
    1009. 

  1009.   /*                                                                       */
    1010. 

  1010.   /* <Description>                                                         */
    1011. 

  1011.   /*    Subdivide a third-order Bezier arc into two joint sub-arcs in the  */
    1012. 

  1012.   /*    Bezier stack.                                                      */
    1013. 

  1013.   /*                                                                       */
    1014. 

  1014.   /* <Note>                                                                */
    1015. 

  1015.   /*    This routine is the `beef' of the component.  It is one of _the_   */
    1016. 

  1016.   /*    inner loops that should be optimized like hell to get the best     */
    1017. 

  1017.   /*    performance.                                                       */
    1018. 

  1018.   /*                                                                       */
    1019. 

  1019.   static void
    1020. 

  1020.   Split_Cubic( TPoint*  base )
    1021. 

  1021.   {
    1022. 

  1022.     Long  a, b, c, d;
    1023. 

  1023. 

  1024. 

  1025.     base[6].x = base[3].x;
    1026. 

  1026.     c = base[1].x;
    1027. 

  1027.     d = base[2].x;
    1028. 

  1028.     base[1].x = a = ( base[0].x + c + 1 ) >> 1;
    1029. 

  1029.     base[5].x = b = ( base[3].x + d + 1 ) >> 1;
    1030. 

  1030.     c = ( c + d + 1 ) >> 1;
    1031. 

  1031.     base[2].x = a = ( a + c + 1 ) >> 1;
    1032. 

  1032.     base[4].x = b = ( b + c + 1 ) >> 1;
    1033. 

  1033.     base[3].x = ( a + b + 1 ) >> 1;
    1034. 

  1034. 

  1035.     base[6].y = base[3].y;
    1036. 

  1036.     c = base[1].y;
    1037. 

  1037.     d = base[2].y;
    1038. 

  1038.     base[1].y = a = ( base[0].y + c + 1 ) >> 1;
    1039. 

  1039.     base[5].y = b = ( base[3].y + d + 1 ) >> 1;
    1040. 

  1040.     c = ( c + d + 1 ) >> 1;
    1041. 

  1041.     base[2].y = a = ( a + c + 1 ) >> 1;
    1042. 

  1042.     base[4].y = b = ( b + c + 1 ) >> 1;
    1043. 

  1043.     base[3].y = ( a + b + 1 ) >> 1;
    1044. 

  1044.   }
    1045. 

  1045. 

  1046. 

  1047.   /*************************************************************************/
    1048. 

  1048.   /*                                                                       */
    1049. 

  1049.   /* <Function>                                                            */
    1050. 

  1050.   /*    Line_Up                                                            */
    1051. 

  1051.   /*                                                                       */
    1052. 

  1052.   /* <Description>                                                         */
    1053. 

  1053.   /*    Compute the x-coordinates of an ascending line segment and store   */
    1054. 

  1054.   /*    them in the render pool.                                           */
    1055. 

  1055.   /*                                                                       */
    1056. 

  1056.   /* <Input>                                                               */
    1057. 

  1057.   /*    x1   :: The x-coordinate of the segment's start point.             */
    1058. 

  1058.   /*                                                                       */
    1059. 

  1059.   /*    y1   :: The y-coordinate of the segment's start point.             */
    1060. 

  1060.   /*                                                                       */
    1061. 

  1061.   /*    x2   :: The x-coordinate of the segment's end point.               */
    1062. 

  1062.   /*                                                                       */
    1063. 

  1063.   /*    y2   :: The y-coordinate of the segment's end point.               */
    1064. 

  1064.   /*                                                                       */
    1065. 

  1065.   /*    miny :: A lower vertical clipping bound value.                     */
    1066. 

  1066.   /*                                                                       */
    1067. 

  1067.   /*    maxy :: An upper vertical clipping bound value.                    */
    1068. 

  1068.   /*                                                                       */
    1069. 

  1069.   /* <Return>                                                              */
    1070. 

  1070.   /*    SUCCESS on success, FAILURE on render pool overflow.               */
    1071. 

  1071.   /*                                                                       */
    1072. 

  1072.   static Bool
    1073. 

  1073.   Line_Up( RAS_ARGS Long  x1,
    1074. 

  1074.                     Long  y1,
    1075. 

  1075.                     Long  x2,
    1076. 

  1076.                     Long  y2,
    1077. 

  1077.                     Long  miny,
    1078. 

  1078.                     Long  maxy )
    1079. 

  1079.   {
    1080. 

  1080.     Long   Dx, Dy;
    1081. 

  1081.     Int    e1, e2, f1, f2, size;     /* XXX: is `Short' sufficient? */
    1082. 

  1082.     Long   Ix, Rx, Ax;
    1083. 

  1083. 

  1084.     PLong  top;
    1085. 

  1085. 

  1086. 

  1087.     Dx = x2 - x1;
    1088. 

  1088.     Dy = y2 - y1;
    1089. 

  1089. 

  1090.     if ( Dy <= 0 || y2 < miny || y1 > maxy )
    1091. 

  1091.       return SUCCESS;
    1092. 

  1092. 

  1093.     if ( y1 < miny )
    1094. 

  1094.     {
    1095. 

  1095.       /* Take care: miny-y1 can be a very large value; we use     */
    1096. 

  1096.       /*            a slow MulDiv function to avoid clipping bugs */
    1097. 

  1097.       x1 += SMulDiv( Dx, miny - y1, Dy );
    1098. 

  1098.       e1  = (Int)TRUNC( miny );
    1099. 

  1099.       f1  = 0;
    1100. 

  1100.     }
    1101. 

  1101.     else
    1102. 

  1102.     {
    1103. 

  1103.       e1 = (Int)TRUNC( y1 );
    1104. 

  1104.       f1 = (Int)FRAC( y1 );
    1105. 

  1105.     }
    1106. 

  1106. 

  1107.     if ( y2 > maxy )
    1108. 

  1108.     {
    1109. 

  1109.       /* x2 += FMulDiv( Dx, maxy - y2, Dy );  UNNECESSARY */
    1110. 

  1110.       e2  = (Int)TRUNC( maxy );
    1111. 

  1111.       f2  = 0;
    1112. 

  1112.     }
    1113. 

  1113.     else
    1114. 

  1114.     {
    1115. 

  1115.       e2 = (Int)TRUNC( y2 );
    1116. 

  1116.       f2 = (Int)FRAC( y2 );
    1117. 

  1117.     }
    1118. 

  1118. 

  1119.     if ( f1 > 0 )
    1120. 

  1120.     {
    1121. 

  1121.       if ( e1 == e2 )
    1122. 

  1122.         return SUCCESS;
    1123. 

  1123.       else
    1124. 

  1124.       {
    1125. 

  1125.         x1 += SMulDiv( Dx, ras.precision - f1, Dy );
    1126. 

  1126.         e1 += 1;
    1127. 

  1127.       }
    1128. 

  1128.     }
    1129. 

  1129.     else
    1130. 

  1130.       if ( ras.joint )
    1131. 

  1131.       {
    1132. 

  1132.         ras.top--;
    1133. 

  1133.         ras.joint = FALSE;
    1134. 

  1134.       }
    1135. 

  1135. 

  1136.     ras.joint = (char)( f2 == 0 );
    1137. 

  1137. 

  1138.     if ( ras.fresh )
    1139. 

  1139.     {
    1140. 

  1140.       ras.cProfile->start = e1;
    1141. 

  1141.       ras.fresh           = FALSE;
    1142. 

  1142.     }
    1143. 

  1143. 

  1144.     size = e2 - e1 + 1;
    1145. 

  1145.     if ( ras.top + size >= ras.maxBuff )
    1146. 

  1146.     {
    1147. 

  1147.       ras.error = Raster_Err_Overflow;
    1148. 

  1148.       return FAILURE;
    1149. 

  1149.     }
    1150. 

  1150. 

  1151.     if ( Dx > 0 )
    1152. 

  1152.     {
    1153. 

  1153.       Ix = SMulDiv( ras.precision, Dx, Dy);
    1154. 

  1154.       Rx = ( ras.precision * Dx ) % Dy;
    1155. 

  1155.       Dx = 1;
    1156. 

  1156.     }
    1157. 

  1157.     else
    1158. 

  1158.     {
    1159. 

  1159.       Ix = SMulDiv( ras.precision, -Dx, Dy) * -1;
    1160. 

  1160.       Rx =    ( ras.precision * -Dx ) % Dy;
    1161. 

  1161.       Dx = -1;
    1162. 

  1162.     }
    1163. 

  1163. 

  1164.     Ax  = -Dy;
    1165. 

  1165.     top = ras.top;
    1166. 

  1166. 

  1167.     while ( size > 0 )
    1168. 

  1168.     {
    1169. 

  1169.       *top++ = x1;
    1170. 

  1170. 

  1171.       x1 += Ix;
    1172. 

  1172.       Ax += Rx;
    1173. 

  1173.       if ( Ax >= 0 )
    1174. 

  1174.       {
    1175. 

  1175.         Ax -= Dy;
    1176. 

  1176.         x1 += Dx;
    1177. 

  1177.       }
    1178. 

  1178.       size--;
    1179. 

  1179.     }
    1180. 

  1180. 

  1181.     ras.top = top;
    1182. 

  1182.     return SUCCESS;
    1183. 

  1183.   }
    1184. 

  1184. 

  1185. 

  1186.   /*************************************************************************/
    1187. 

  1187.   /*                                                                       */
    1188. 

  1188.   /* <Function>                                                            */
    1189. 

  1189.   /*    Line_Down                                                          */
    1190. 

  1190.   /*                                                                       */
    1191. 

  1191.   /* <Description>                                                         */
    1192. 

  1192.   /*    Compute the x-coordinates of an descending line segment and store  */
    1193. 

  1193.   /*    them in the render pool.                                           */
    1194. 

  1194.   /*                                                                       */
    1195. 

  1195.   /* <Input>                                                               */
    1196. 

  1196.   /*    x1   :: The x-coordinate of the segment's start point.             */
    1197. 

  1197.   /*                                                                       */
    1198. 

  1198.   /*    y1   :: The y-coordinate of the segment's start point.             */
    1199. 

  1199.   /*                                                                       */
    1200. 

  1200.   /*    x2   :: The x-coordinate of the segment's end point.               */
    1201. 

  1201.   /*                                                                       */
    1202. 

  1202.   /*    y2   :: The y-coordinate of the segment's end point.               */
    1203. 

  1203.   /*                                                                       */
    1204. 

  1204.   /*    miny :: A lower vertical clipping bound value.                     */
    1205. 

  1205.   /*                                                                       */
    1206. 

  1206.   /*    maxy :: An upper vertical clipping bound value.                    */
    1207. 

  1207.   /*                                                                       */
    1208. 

  1208.   /* <Return>                                                              */
    1209. 

  1209.   /*    SUCCESS on success, FAILURE on render pool overflow.               */
    1210. 

  1210.   /*                                                                       */
    1211. 

  1211.   static Bool
    1212. 

  1212.   Line_Down( RAS_ARGS Long  x1,
    1213. 

  1213.                       Long  y1,
    1214. 

  1214.                       Long  x2,
    1215. 

  1215.                       Long  y2,
    1216. 

  1216.                       Long  miny,
    1217. 

  1217.                       Long  maxy )
    1218. 

  1218.   {
    1219. 

  1219.     Bool  result, fresh;
    1220. 

  1220. 

  1221. 

  1222.     fresh  = ras.fresh;
    1223. 

  1223. 

  1224.     result = Line_Up( RAS_VARS x1, -y1, x2, -y2, -maxy, -miny );
    1225. 

  1225. 

  1226.     if ( fresh && !ras.fresh )
    1227. 

  1227.       ras.cProfile->start = -ras.cProfile->start;
    1228. 

  1228. 

  1229.     return result;
    1230. 

  1230.   }
    1231. 

  1231. 

  1232. 

  1233.   /* A function type describing the functions used to split Bezier arcs */
    1234. 

  1234.   typedef void  (*TSplitter)( TPoint*  base );
    1235. 

  1235. 

  1236. 

  1237.   /*************************************************************************/
    1238. 

  1238.   /*                                                                       */
    1239. 

  1239.   /* <Function>                                                            */
    1240. 

  1240.   /*    Bezier_Up                                                          */
    1241. 

  1241.   /*                                                                       */
    1242. 

  1242.   /* <Description>                                                         */
    1243. 

  1243.   /*    Compute the x-coordinates of an ascending Bezier arc and store     */
    1244. 

  1244.   /*    them in the render pool.                                           */
    1245. 

  1245.   /*                                                                       */
    1246. 

  1246.   /* <Input>                                                               */
    1247. 

  1247.   /*    degree   :: The degree of the Bezier arc (either 2 or 3).          */
    1248. 

  1248.   /*                                                                       */
    1249. 

  1249.   /*    splitter :: The function to split Bezier arcs.                     */
    1250. 

  1250.   /*                                                                       */
    1251. 

  1251.   /*    miny     :: A lower vertical clipping bound value.                 */
    1252. 

  1252.   /*                                                                       */
    1253. 

  1253.   /*    maxy     :: An upper vertical clipping bound value.                */
    1254. 

  1254.   /*                                                                       */
    1255. 

  1255.   /* <Return>                                                              */
    1256. 

  1256.   /*    SUCCESS on success, FAILURE on render pool overflow.               */
    1257. 

  1257.   /*                                                                       */
    1258. 

  1258.   static Bool
    1259. 

  1259.   Bezier_Up( RAS_ARGS Int        degree,
    1260. 

  1260.                       TSplitter  splitter,
    1261. 

  1261.                       Long       miny,
    1262. 

  1262.                       Long       maxy )
    1263. 

  1263.   {
    1264. 

  1264.     Long   y1, y2, e, e2, e0;
    1265. 

  1265.     Short  f1;
    1266. 

  1266. 

  1267.     TPoint*  arc;
    1268. 

  1268.     TPoint*  start_arc;
    1269. 

  1269. 

  1270.     PLong top;
    1271. 

  1271. 

  1272. 

  1273.     arc = ras.arc;
    1274. 

  1274.     y1  = arc[degree].y;
    1275. 

  1275.     y2  = arc[0].y;
    1276. 

  1276.     top = ras.top;
    1277. 

  1277. 

  1278.     if ( y2 < miny || y1 > maxy )
    1279. 

  1279.       goto Fin;
    1280. 

  1280. 

  1281.     e2 = FLOOR( y2 );
    1282. 

  1282. 

  1283.     if ( e2 > maxy )
    1284. 

  1284.       e2 = maxy;
    1285. 

  1285. 

  1286.     e0 = miny;
    1287. 

  1287. 

  1288.     if ( y1 < miny )
    1289. 

  1289.       e = miny;
    1290. 

  1290.     else
    1291. 

  1291.     {
    1292. 

  1292.       e  = CEILING( y1 );
    1293. 

  1293.       f1 = (Short)( FRAC( y1 ) );
    1294. 

  1294.       e0 = e;
    1295. 

  1295. 

  1296.       if ( f1 == 0 )
    1297. 

  1297.       {
    1298. 

  1298.         if ( ras.joint )
    1299. 

  1299.         {
    1300. 

  1300.           top--;
    1301. 

  1301.           ras.joint = FALSE;
    1302. 

  1302.         }
    1303. 

  1303. 

  1304.         *top++ = arc[degree].x;
    1305. 

  1305. 

  1306.         e += ras.precision;
    1307. 

  1307.       }
    1308. 

  1308.     }
    1309. 

  1309. 

  1310.     if ( ras.fresh )
    1311. 

  1311.     {
    1312. 

  1312.       ras.cProfile->start = TRUNC( e0 );
    1313. 

  1313.       ras.fresh = FALSE;
    1314. 

  1314.     }
    1315. 

  1315. 

  1316.     if ( e2 < e )
    1317. 

  1317.       goto Fin;
    1318. 

  1318. 

  1319.     if ( ( top + TRUNC( e2 - e ) + 1 ) >= ras.maxBuff )
    1320. 

  1320.     {
    1321. 

  1321.       ras.top   = top;
    1322. 

  1322.       ras.error = Raster_Err_Overflow;
    1323. 

  1323.       return FAILURE;
    1324. 

  1324.     }
    1325. 

  1325. 

  1326.     start_arc = arc;
    1327. 

  1327. 

  1328.     while ( arc >= start_arc && e <= e2 )
    1329. 

  1329.     {
    1330. 

  1330.       ras.joint = FALSE;
    1331. 

  1331. 

  1332.       y2 = arc[0].y;
    1333. 

  1333. 

  1334.       if ( y2 > e )
    1335. 

  1335.       {
    1336. 

  1336.         y1 = arc[degree].y;
    1337. 

  1337.         if ( y2 - y1 >= ras.precision_step )
    1338. 

  1338.         {
    1339. 

  1339.           splitter( arc );
    1340. 

  1340.           arc += degree;
    1341. 

  1341.         }
    1342. 

  1342.         else
    1343. 

  1343.         {
    1344. 

  1344.           *top++ = arc[degree].x + FMulDiv( arc[0].x - arc[degree].x,
    1345. 

  1345.                                             e - y1, y2 - y1 );
    1346. 

  1346.           arc -= degree;
    1347. 

  1347.           e   += ras.precision;
    1348. 

  1348.         }
    1349. 

  1349.       }
    1350. 

  1350.       else
    1351. 

  1351.       {
    1352. 

  1352.         if ( y2 == e )
    1353. 

  1353.         {
    1354. 

  1354.           ras.joint  = TRUE;
    1355. 

  1355.           *top++     = arc[0].x;
    1356. 

  1356. 

  1357.           e += ras.precision;
    1358. 

  1358.         }
    1359. 

  1359.         arc -= degree;
    1360. 

  1360.       }
    1361. 

  1361.     }
    1362. 

  1362. 

  1363.   Fin:
    1364. 

  1364.     ras.top  = top;
    1365. 

  1365.     ras.arc -= degree;
    1366. 

  1366.     return SUCCESS;
    1367. 

  1367.   }
    1368. 

  1368. 

  1369. 

  1370.   /*************************************************************************/
    1371. 

  1371.   /*                                                                       */
    1372. 

  1372.   /* <Function>                                                            */
    1373. 

  1373.   /*    Bezier_Down                                                        */
    1374. 

  1374.   /*                                                                       */
    1375. 

  1375.   /* <Description>                                                         */
    1376. 

  1376.   /*    Compute the x-coordinates of an descending Bezier arc and store    */
    1377. 

  1377.   /*    them in the render pool.                                           */
    1378. 

  1378.   /*                                                                       */
    1379. 

  1379.   /* <Input>                                                               */
    1380. 

  1380.   /*    degree   :: The degree of the Bezier arc (either 2 or 3).          */
    1381. 

  1381.   /*                                                                       */
    1382. 

  1382.   /*    splitter :: The function to split Bezier arcs.                     */
    1383. 

  1383.   /*                                                                       */
    1384. 

  1384.   /*    miny     :: A lower vertical clipping bound value.                 */
    1385. 

  1385.   /*                                                                       */
    1386. 

  1386.   /*    maxy     :: An upper vertical clipping bound value.                */
    1387. 

  1387.   /*                                                                       */
    1388. 

  1388.   /* <Return>                                                              */
    1389. 

  1389.   /*    SUCCESS on success, FAILURE on render pool overflow.               */
    1390. 

  1390.   /*                                                                       */
    1391. 

  1391.   static Bool
    1392. 

  1392.   Bezier_Down( RAS_ARGS Int        degree,
    1393. 

  1393.                         TSplitter  splitter,
    1394. 

  1394.                         Long       miny,
    1395. 

  1395.                         Long       maxy )
    1396. 

  1396.   {
    1397. 

  1397.     TPoint*  arc = ras.arc;
    1398. 

  1398.     Bool     result, fresh;
    1399. 

  1399. 

  1400. 

  1401.     arc[0].y = -arc[0].y;
    1402. 

  1402.     arc[1].y = -arc[1].y;
    1403. 

  1403.     arc[2].y = -arc[2].y;
    1404. 

  1404.     if ( degree > 2 )
    1405. 

  1405.       arc[3].y = -arc[3].y;
    1406. 

  1406. 

  1407.     fresh = ras.fresh;
    1408. 

  1408. 

  1409.     result = Bezier_Up( RAS_VARS degree, splitter, -maxy, -miny );
    1410. 

  1410. 

  1411.     if ( fresh && !ras.fresh )
    1412. 

  1412.       ras.cProfile->start = -ras.cProfile->start;
    1413. 

  1413. 

  1414.     arc[0].y = -arc[0].y;
    1415. 

  1415.     return result;
    1416. 

  1416.   }
    1417. 

  1417. 

  1418. 

  1419.   /*************************************************************************/
    1420. 

  1420.   /*                                                                       */
    1421. 

  1421.   /* <Function>                                                            */
    1422. 

  1422.   /*    Line_To                                                            */
    1423. 

  1423.   /*                                                                       */
    1424. 

  1424.   /* <Description>                                                         */
    1425. 

  1425.   /*    Inject a new line segment and adjust the Profiles list.            */
    1426. 

  1426.   /*                                                                       */
    1427. 

  1427.   /* <Input>                                                               */
    1428. 

  1428.   /*   x :: The x-coordinate of the segment's end point (its start point   */
    1429. 

  1429.   /*        is stored in `lastX').                                         */
    1430. 

  1430.   /*                                                                       */
    1431. 

  1431.   /*   y :: The y-coordinate of the segment's end point (its start point   */
    1432. 

  1432.   /*        is stored in `lastY').                                         */
    1433. 

  1433.   /*                                                                       */
    1434. 

  1434.   /* <Return>                                                              */
    1435. 

  1435.   /*   SUCCESS on success, FAILURE on render pool overflow or incorrect    */
    1436. 

  1436.   /*   profile.                                                            */
    1437. 

  1437.   /*                                                                       */
    1438. 

  1438.   static Bool
    1439. 

  1439.   Line_To( RAS_ARGS Long  x,
    1440. 

  1440.                     Long  y )
    1441. 

  1441.   {
    1442. 

  1442.     /* First, detect a change of direction */
    1443. 

  1443. 

  1444.     switch ( ras.state )
    1445. 

  1445.     {
    1446. 

  1446.     case Unknown_State:
    1447. 

  1447.       if ( y > ras.lastY )
    1448. 

  1448.       {
    1449. 

  1449.         if ( New_Profile( RAS_VARS Ascending_State,
    1450. 

  1450.                                    IS_BOTTOM_OVERSHOOT( ras.lastY ) ) )
    1451. 

  1451.           return FAILURE;
    1452. 

  1452.       }
    1453. 

  1453.       else
    1454. 

  1454.       {
    1455. 

  1455.         if ( y < ras.lastY )
    1456. 

  1456.           if ( New_Profile( RAS_VARS Descending_State,
    1457. 

  1457.                                      IS_TOP_OVERSHOOT( ras.lastY ) ) )
    1458. 

  1458.             return FAILURE;
    1459. 

  1459.       }
    1460. 

  1460.       break;
    1461. 

  1461. 

  1462.     case Ascending_State:
    1463. 

  1463.       if ( y < ras.lastY )
    1464. 

  1464.       {
    1465. 

  1465.         if ( End_Profile( RAS_VARS IS_TOP_OVERSHOOT( ras.lastY ) ) ||
    1466. 

  1466.              New_Profile( RAS_VARS Descending_State,
    1467. 

  1467.                                    IS_TOP_OVERSHOOT( ras.lastY ) ) )
    1468. 

  1468.           return FAILURE;
    1469. 

  1469.       }
    1470. 

  1470.       break;
    1471. 

  1471. 

  1472.     case Descending_State:
    1473. 

  1473.       if ( y > ras.lastY )
    1474. 

  1474.       {
    1475. 

  1475.         if ( End_Profile( RAS_VARS IS_BOTTOM_OVERSHOOT( ras.lastY ) ) ||
    1476. 

  1476.              New_Profile( RAS_VARS Ascending_State,
    1477. 

  1477.                                    IS_BOTTOM_OVERSHOOT( ras.lastY ) ) )
    1478. 

  1478.           return FAILURE;
    1479. 

  1479.       }
    1480. 

  1480.       break;
    1481. 

  1481. 

  1482.     default:
    1483. 

  1483.       ;
    1484. 

  1484.     }
    1485. 

  1485. 

  1486.     /* Then compute the lines */
    1487. 

  1487. 

  1488.     switch ( ras.state )
    1489. 

  1489.     {
    1490. 

  1490.     case Ascending_State:
    1491. 

  1491.       if ( Line_Up( RAS_VARS ras.lastX, ras.lastY,
    1492. 

  1492.                              x, y, ras.minY, ras.maxY ) )
    1493. 

  1493.         return FAILURE;
    1494. 

  1494.       break;
    1495. 

  1495. 

  1496.     case Descending_State:
    1497. 

  1497.       if ( Line_Down( RAS_VARS ras.lastX, ras.lastY,
    1498. 

  1498.                                x, y, ras.minY, ras.maxY ) )
    1499. 

  1499.         return FAILURE;
    1500. 

  1500.       break;
    1501. 

  1501. 

  1502.     default:
    1503. 

  1503.       ;
    1504. 

  1504.     }
    1505. 

  1505. 

  1506.     ras.lastX = x;
    1507. 

  1507.     ras.lastY = y;
    1508. 

  1508. 

  1509.     return SUCCESS;
    1510. 

  1510.   }
    1511. 

  1511. 

  1512. 

  1513.   /*************************************************************************/
    1514. 

  1514.   /*                                                                       */
    1515. 

  1515.   /* <Function>                                                            */
    1516. 

  1516.   /*    Conic_To                                                           */
    1517. 

  1517.   /*                                                                       */
    1518. 

  1518.   /* <Description>                                                         */
    1519. 

  1519.   /*    Inject a new conic arc and adjust the profile list.                */
    1520. 

  1520.   /*                                                                       */
    1521. 

  1521.   /* <Input>                                                               */
    1522. 

  1522.   /*   cx :: The x-coordinate of the arc's new control point.              */
    1523. 

  1523.   /*                                                                       */
    1524. 

  1524.   /*   cy :: The y-coordinate of the arc's new control point.              */
    1525. 

  1525.   /*                                                                       */
    1526. 

  1526.   /*   x  :: The x-coordinate of the arc's end point (its start point is   */
    1527. 

  1527.   /*         stored in `lastX').                                           */
    1528. 

  1528.   /*                                                                       */
    1529. 

  1529.   /*   y  :: The y-coordinate of the arc's end point (its start point is   */
    1530. 

  1530.   /*         stored in `lastY').                                           */
    1531. 

  1531.   /*                                                                       */
    1532. 

  1532.   /* <Return>                                                              */
    1533. 

  1533.   /*   SUCCESS on success, FAILURE on render pool overflow or incorrect    */
    1534. 

  1534.   /*   profile.                                                            */
    1535. 

  1535.   /*                                                                       */
    1536. 

  1536.   static Bool
    1537. 

  1537.   Conic_To( RAS_ARGS Long  cx,
    1538. 

  1538.                      Long  cy,
    1539. 

  1539.                      Long  x,
    1540. 

  1540.                      Long  y )
    1541. 

  1541.   {
    1542. 

  1542.     Long     y1, y2, y3, x3, ymin, ymax;
    1543. 

  1543.     TStates  state_bez;
    1544. 

  1544. 

  1545. 

  1546.     ras.arc      = ras.arcs;
    1547. 

  1547.     ras.arc[2].x = ras.lastX;
    1548. 

  1548.     ras.arc[2].y = ras.lastY;
    1549. 

  1549.     ras.arc[1].x = cx;
    1550. 

  1550.     ras.arc[1].y = cy;
    1551. 

  1551.     ras.arc[0].x = x;
    1552. 

  1552.     ras.arc[0].y = y;
    1553. 

  1553. 

  1554.     do
    1555. 

  1555.     {
    1556. 

  1556.       y1 = ras.arc[2].y;
    1557. 

  1557.       y2 = ras.arc[1].y;
    1558. 

  1558.       y3 = ras.arc[0].y;
    1559. 

  1559.       x3 = ras.arc[0].x;
    1560. 

  1560. 

  1561.       /* first, categorize the Bezier arc */
    1562. 

  1562. 

  1563.       if ( y1 <= y3 )
    1564. 

  1564.       {
    1565. 

  1565.         ymin = y1;
    1566. 

  1566.         ymax = y3;
    1567. 

  1567.       }
    1568. 

  1568.       else
    1569. 

  1569.       {
    1570. 

  1570.         ymin = y3;
    1571. 

  1571.         ymax = y1;
    1572. 

  1572.       }
    1573. 

  1573. 

  1574.       if ( y2 < ymin || y2 > ymax )
    1575. 

  1575.       {
    1576. 

  1576.         /* this arc has no given direction, split it! */
    1577. 

  1577.         Split_Conic( ras.arc );
    1578. 

  1578.         ras.arc += 2;
    1579. 

  1579.       }
    1580. 

  1580.       else if ( y1 == y3 )
    1581. 

  1581.       {
    1582. 

  1582.         /* this arc is flat, ignore it and pop it from the Bezier stack */
    1583. 

  1583.         ras.arc -= 2;
    1584. 

  1584.       }
    1585. 

  1585.       else
    1586. 

  1586.       {
    1587. 

  1587.         /* the arc is y-monotonous, either ascending or descending */
    1588. 

  1588.         /* detect a change of direction                            */
    1589. 

  1589.         state_bez = y1 < y3 ? Ascending_State : Descending_State;
    1590. 

  1590.         if ( ras.state != state_bez )
    1591. 

  1591.         {
    1592. 

  1592.           Bool  o = state_bez == Ascending_State ? IS_BOTTOM_OVERSHOOT( y1 )
    1593. 

  1593.                                                  : IS_TOP_OVERSHOOT( y1 );
    1594. 

  1594. 

  1595. 

  1596.           /* finalize current profile if any */
    1597. 

  1597.           if ( ras.state != Unknown_State &&
    1598. 

  1598.                End_Profile( RAS_VARS o )  )
    1599. 

  1599.             goto Fail;
    1600. 

  1600. 

  1601.           /* create a new profile */
    1602. 

  1602.           if ( New_Profile( RAS_VARS state_bez, o ) )
    1603. 

  1603.             goto Fail;
    1604. 

  1604.         }
    1605. 

  1605. 

  1606.         /* now call the appropriate routine */
    1607. 

  1607.         if ( state_bez == Ascending_State )
    1608. 

  1608.         {
    1609. 

  1609.           if ( Bezier_Up( RAS_VARS 2, Split_Conic, ras.minY, ras.maxY ) )
    1610. 

  1610.             goto Fail;
    1611. 

  1611.         }
    1612. 

  1612.         else
    1613. 

  1613.           if ( Bezier_Down( RAS_VARS 2, Split_Conic, ras.minY, ras.maxY ) )
    1614. 

  1614.             goto Fail;
    1615. 

  1615.       }
    1616. 

  1616. 

  1617.     } while ( ras.arc >= ras.arcs );
    1618. 

  1618. 

  1619.     ras.lastX = x3;
    1620. 

  1620.     ras.lastY = y3;
    1621. 

  1621. 

  1622.     return SUCCESS;
    1623. 

  1623. 

  1624.   Fail:
    1625. 

  1625.     return FAILURE;
    1626. 

  1626.   }
    1627. 

  1627. 

  1628. 

  1629.   /*************************************************************************/
    1630. 

  1630.   /*                                                                       */
    1631. 

  1631.   /* <Function>                                                            */
    1632. 

  1632.   /*    Cubic_To                                                           */
    1633. 

  1633.   /*                                                                       */
    1634. 

  1634.   /* <Description>                                                         */
    1635. 

  1635.   /*    Inject a new cubic arc and adjust the profile list.                */
    1636. 

  1636.   /*                                                                       */
    1637. 

  1637.   /* <Input>                                                               */
    1638. 

  1638.   /*   cx1 :: The x-coordinate of the arc's first new control point.       */
    1639. 

  1639.   /*                                                                       */
    1640. 

  1640.   /*   cy1 :: The y-coordinate of the arc's first new control point.       */
    1641. 

  1641.   /*                                                                       */
    1642. 

  1642.   /*   cx2 :: The x-coordinate of the arc's second new control point.      */
    1643. 

  1643.   /*                                                                       */
    1644. 

  1644.   /*   cy2 :: The y-coordinate of the arc's second new control point.      */
    1645. 

  1645.   /*                                                                       */
    1646. 

  1646.   /*   x   :: The x-coordinate of the arc's end point (its start point is  */
    1647. 

  1647.   /*          stored in `lastX').                                          */
    1648. 

  1648.   /*                                                                       */
    1649. 

  1649.   /*   y   :: The y-coordinate of the arc's end point (its start point is  */
    1650. 

  1650.   /*          stored in `lastY').                                          */
    1651. 

  1651.   /*                                                                       */
    1652. 

  1652.   /* <Return>                                                              */
    1653. 

  1653.   /*   SUCCESS on success, FAILURE on render pool overflow or incorrect    */
    1654. 

  1654.   /*   profile.                                                            */
    1655. 

  1655.   /*                                                                       */
    1656. 

  1656.   static Bool
    1657. 

  1657.   Cubic_To( RAS_ARGS Long  cx1,
    1658. 

  1658.                      Long  cy1,
    1659. 

  1659.                      Long  cx2,
    1660. 

  1660.                      Long  cy2,
    1661. 

  1661.                      Long  x,
    1662. 

  1662.                      Long  y )
    1663. 

  1663.   {
    1664. 

  1664.     Long     y1, y2, y3, y4, x4, ymin1, ymax1, ymin2, ymax2;
    1665. 

  1665.     TStates  state_bez;
    1666. 

  1666. 

  1667. 

  1668.     ras.arc      = ras.arcs;
    1669. 

  1669.     ras.arc[3].x = ras.lastX;
    1670. 

  1670.     ras.arc[3].y = ras.lastY;
    1671. 

  1671.     ras.arc[2].x = cx1;
    1672. 

  1672.     ras.arc[2].y = cy1;
    1673. 

  1673.     ras.arc[1].x = cx2;
    1674. 

  1674.     ras.arc[1].y = cy2;
    1675. 

  1675.     ras.arc[0].x = x;
    1676. 

  1676.     ras.arc[0].y = y;
    1677. 

  1677. 

  1678.     do
    1679. 

  1679.     {
    1680. 

  1680.       y1 = ras.arc[3].y;
    1681. 

  1681.       y2 = ras.arc[2].y;
    1682. 

  1682.       y3 = ras.arc[1].y;
    1683. 

  1683.       y4 = ras.arc[0].y;
    1684. 

  1684.       x4 = ras.arc[0].x;
    1685. 

  1685. 

  1686.       /* first, categorize the Bezier arc */
    1687. 

  1687. 

  1688.       if ( y1 <= y4 )
    1689. 

  1689.       {
    1690. 

  1690.         ymin1 = y1;
    1691. 

  1691.         ymax1 = y4;
    1692. 

  1692.       }
    1693. 

  1693.       else
    1694. 

  1694.       {
    1695. 

  1695.         ymin1 = y4;
    1696. 

  1696.         ymax1 = y1;
    1697. 

  1697.       }
    1698. 

  1698. 

  1699.       if ( y2 <= y3 )
    1700. 

  1700.       {
    1701. 

  1701.         ymin2 = y2;
    1702. 

  1702.         ymax2 = y3;
    1703. 

  1703.       }
    1704. 

  1704.       else
    1705. 

  1705.       {
    1706. 

  1706.         ymin2 = y3;
    1707. 

  1707.         ymax2 = y2;
    1708. 

  1708.       }
    1709. 

  1709. 

  1710.       if ( ymin2 < ymin1 || ymax2 > ymax1 )
    1711. 

  1711.       {
    1712. 

  1712.         /* this arc has no given direction, split it! */
    1713. 

  1713.         Split_Cubic( ras.arc );
    1714. 

  1714.         ras.arc += 3;
    1715. 

  1715.       }
    1716. 

  1716.       else if ( y1 == y4 )
    1717. 

  1717.       {
    1718. 

  1718.         /* this arc is flat, ignore it and pop it from the Bezier stack */
    1719. 

  1719.         ras.arc -= 3;
    1720. 

  1720.       }
    1721. 

  1721.       else
    1722. 

  1722.       {
    1723. 

  1723.         state_bez = ( y1 <= y4 ) ? Ascending_State : Descending_State;
    1724. 

  1724. 

  1725.         /* detect a change of direction */
    1726. 

  1726.         if ( ras.state != state_bez )
    1727. 

  1727.         {
    1728. 

  1728.           Bool  o = state_bez == Ascending_State ? IS_BOTTOM_OVERSHOOT( y1 )
    1729. 

  1729.                                                  : IS_TOP_OVERSHOOT( y1 );
    1730. 

  1730. 

  1731. 

  1732.           /* finalize current profile if any */
    1733. 

  1733.           if ( ras.state != Unknown_State &&
    1734. 

  1734.                End_Profile( RAS_VARS o )  )
    1735. 

  1735.             goto Fail;
    1736. 

  1736. 

  1737.           if ( New_Profile( RAS_VARS state_bez, o ) )
    1738. 

  1738.             goto Fail;
    1739. 

  1739.         }
    1740. 

  1740. 

  1741.         /* compute intersections */
    1742. 

  1742.         if ( state_bez == Ascending_State )
    1743. 

  1743.         {
    1744. 

  1744.           if ( Bezier_Up( RAS_VARS 3, Split_Cubic, ras.minY, ras.maxY ) )
    1745. 

  1745.             goto Fail;
    1746. 

  1746.         }
    1747. 

  1747.         else
    1748. 

  1748.           if ( Bezier_Down( RAS_VARS 3, Split_Cubic, ras.minY, ras.maxY ) )
    1749. 

  1749.             goto Fail;
    1750. 

  1750.       }
    1751. 

  1751. 

  1752.     } while ( ras.arc >= ras.arcs );
    1753. 

  1753. 

  1754.     ras.lastX = x4;
    1755. 

  1755.     ras.lastY = y4;
    1756. 

  1756. 

  1757.     return SUCCESS;
    1758. 

  1758. 

  1759.   Fail:
    1760. 

  1760.     return FAILURE;
    1761. 

  1761.   }
    1762. 

  1762. 

  1763. 

  1764. #undef  SWAP_
    1765. 

  1765. #define SWAP_( x, y )  do                \
    1766. 

  1766.                        {                 \
    1767. 

  1767.                          Long  swap = x; \
    1768. 

  1768.                                          \
    1769. 

  1769.                                          \
    1770. 

  1770.                          x = y;          \
    1771. 

  1771.                          y = swap;       \
    1772. 

  1772.                        } while ( 0 )
    1773. 

  1773. 

  1774. 

  1775.   /*************************************************************************/
    1776. 

  1776.   /*                                                                       */
    1777. 

  1777.   /* <Function>                                                            */
    1778. 

  1778.   /*    Decompose_Curve                                                    */
    1779. 

  1779.   /*                                                                       */
    1780. 

  1780.   /* <Description>                                                         */
    1781. 

  1781.   /*    Scan the outline arrays in order to emit individual segments and   */
    1782. 

  1782.   /*    Beziers by calling Line_To() and Bezier_To().  It handles all      */
    1783. 

  1783.   /*    weird cases, like when the first point is off the curve, or when   */
    1784. 

  1784.   /*    there are simply no `on' points in the contour!                    */
    1785. 

  1785.   /*                                                                       */
    1786. 

  1786.   /* <Input>                                                               */
    1787. 

  1787.   /*    first   :: The index of the first point in the contour.            */
    1788. 

  1788.   /*                                                                       */
    1789. 

  1789.   /*    last    :: The index of the last point in the contour.             */
    1790. 

  1790.   /*                                                                       */
    1791. 

  1791.   /*    flipped :: If set, flip the direction of the curve.                */
    1792. 

  1792.   /*                                                                       */
    1793. 

  1793.   /* <Return>                                                              */
    1794. 

  1794.   /*    SUCCESS on success, FAILURE on error.                              */
    1795. 

  1795.   /*                                                                       */
    1796. 

  1796.   static Bool
    1797. 

  1797.   Decompose_Curve( RAS_ARGS UShort  first,
    1798. 

  1798.                             UShort  last,
    1799. 

  1799.                             int     flipped )
    1800. 

  1800.   {
    1801. 

  1801.     FT_Vector   v_last;
    1802. 

  1802.     FT_Vector   v_control;
    1803. 

  1803.     FT_Vector   v_start;
    1804. 

  1804. 

  1805.     FT_Vector*  points;
    1806. 

  1806.     FT_Vector*  point;
    1807. 

  1807.     FT_Vector*  limit;
    1808. 

  1808.     char*       tags;
    1809. 

  1809. 

  1810.     unsigned    tag;       /* current point's state           */
    1811. 

  1811. 

  1812. 

  1813.     points = ras.outline.points;
    1814. 

  1814.     limit  = points + last;
    1815. 

  1815. 

  1816.     v_start.x = SCALED( points[first].x );
    1817. 

  1817.     v_start.y = SCALED( points[first].y );
    1818. 

  1818.     v_last.x  = SCALED( points[last].x );
    1819. 

  1819.     v_last.y  = SCALED( points[last].y );
    1820. 

  1820. 

  1821.     if ( flipped )
    1822. 

  1822.     {
    1823. 

  1823.       SWAP_( v_start.x, v_start.y );
    1824. 

  1824.       SWAP_( v_last.x, v_last.y );
    1825. 

  1825.     }
    1826. 

  1826. 

  1827.     v_control = v_start;
    1828. 

  1828. 

  1829.     point = points + first;
    1830. 

  1830.     tags  = ras.outline.tags + first;
    1831. 

  1831. 

  1832.     /* set scan mode if necessary */
    1833. 

  1833.     if ( tags[0] & FT_CURVE_TAG_HAS_SCANMODE )
    1834. 

  1834.       ras.dropOutControl = (Byte)tags[0] >> 5;
    1835. 

  1835. 

  1836.     tag = FT_CURVE_TAG( tags[0] );
    1837. 

  1837. 

  1838.     /* A contour cannot start with a cubic control point! */
    1839. 

  1839.     if ( tag == FT_CURVE_TAG_CUBIC )
    1840. 

  1840.       goto Invalid_Outline;
    1841. 

  1841. 

  1842.     /* check first point to determine origin */
    1843. 

  1843.     if ( tag == FT_CURVE_TAG_CONIC )
    1844. 

  1844.     {
    1845. 

  1845.       /* first point is conic control.  Yes, this happens. */
    1846. 

  1846.       if ( FT_CURVE_TAG( ras.outline.tags[last] ) == FT_CURVE_TAG_ON )
    1847. 

  1847.       {
    1848. 

  1848.         /* start at last point if it is on the curve */
    1849. 

  1849.         v_start = v_last;
    1850. 

  1850.         limit--;
    1851. 

  1851.       }
    1852. 

  1852.       else
    1853. 

  1853.       {
    1854. 

  1854.         /* if both first and last points are conic,         */
    1855. 

  1855.         /* start at their middle and record its position    */
    1856. 

  1856.         /* for closure                                      */
    1857. 

  1857.         v_start.x = ( v_start.x + v_last.x ) / 2;
    1858. 

  1858.         v_start.y = ( v_start.y + v_last.y ) / 2;
    1859. 

  1859. 

  1860.         v_last = v_start;
    1861. 

  1861.       }
    1862. 

  1862.       point--;
    1863. 

  1863.       tags--;
    1864. 

  1864.     }
    1865. 

  1865. 

  1866.     ras.lastX = v_start.x;
    1867. 

  1867.     ras.lastY = v_start.y;
    1868. 

  1868. 

  1869.     while ( point < limit )
    1870. 

  1870.     {
    1871. 

  1871.       point++;
    1872. 

  1872.       tags++;
    1873. 

  1873. 

  1874.       tag = FT_CURVE_TAG( tags[0] );
    1875. 

  1875. 

  1876.       switch ( tag )
    1877. 

  1877.       {
    1878. 

  1878.       case FT_CURVE_TAG_ON:  /* emit a single line_to */
    1879. 

  1879.         {
    1880. 

  1880.           Long  x, y;
    1881. 

  1881. 

  1882. 

  1883.           x = SCALED( point->x );
    1884. 

  1884.           y = SCALED( point->y );
    1885. 

  1885.           if ( flipped )
    1886. 

  1886.             SWAP_( x, y );
    1887. 

  1887. 

  1888.           if ( Line_To( RAS_VARS x, y ) )
    1889. 

  1889.             goto Fail;
    1890. 

  1890.           continue;
    1891. 

  1891.         }
    1892. 

  1892. 

  1893.       case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
    1894. 

  1894.         v_control.x = SCALED( point[0].x );
    1895. 

  1895.         v_control.y = SCALED( point[0].y );
    1896. 

  1896. 

  1897.         if ( flipped )
    1898. 

  1898.           SWAP_( v_control.x, v_control.y );
    1899. 

  1899. 

  1900.       Do_Conic:
    1901. 

  1901.         if ( point < limit )
    1902. 

  1902.         {
    1903. 

  1903.           FT_Vector  v_middle;
    1904. 

  1904.           Long       x, y;
    1905. 

  1905. 

  1906. 

  1907.           point++;
    1908. 

  1908.           tags++;
    1909. 

  1909.           tag = FT_CURVE_TAG( tags[0] );
    1910. 

  1910. 

  1911.           x = SCALED( point[0].x );
    1912. 

  1912.           y = SCALED( point[0].y );
    1913. 

  1913. 

  1914.           if ( flipped )
    1915. 

  1915.             SWAP_( x, y );
    1916. 

  1916. 

  1917.           if ( tag == FT_CURVE_TAG_ON )
    1918. 

  1918.           {
    1919. 

  1919.             if ( Conic_To( RAS_VARS v_control.x, v_control.y, x, y ) )
    1920. 

  1920.               goto Fail;
    1921. 

  1921.             continue;
    1922. 

  1922.           }
    1923. 

  1923. 

  1924.           if ( tag != FT_CURVE_TAG_CONIC )
    1925. 

  1925.             goto Invalid_Outline;
    1926. 

  1926. 

  1927.           v_middle.x = ( v_control.x + x ) / 2;
    1928. 

  1928.           v_middle.y = ( v_control.y + y ) / 2;
    1929. 

  1929. 

  1930.           if ( Conic_To( RAS_VARS v_control.x, v_control.y,
    1931. 

  1931.                                   v_middle.x,  v_middle.y ) )
    1932. 

  1932.             goto Fail;
    1933. 

  1933. 

  1934.           v_control.x = x;
    1935. 

  1935.           v_control.y = y;
    1936. 

  1936. 

  1937.           goto Do_Conic;
    1938. 

  1938.         }
    1939. 

  1939. 

  1940.         if ( Conic_To( RAS_VARS v_control.x, v_control.y,
    1941. 

  1941.                                 v_start.x,   v_start.y ) )
    1942. 

  1942.           goto Fail;
    1943. 

  1943. 

  1944.         goto Close;
    1945. 

  1945. 

  1946.       default:  /* FT_CURVE_TAG_CUBIC */
    1947. 

  1947.         {
    1948. 

  1948.           Long  x1, y1, x2, y2, x3, y3;
    1949. 

  1949. 

  1950. 

  1951.           if ( point + 1 > limit                             ||
    1952. 

  1952.                FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
    1953. 

  1953.             goto Invalid_Outline;
    1954. 

  1954. 

  1955.           point += 2;
    1956. 

  1956.           tags  += 2;
    1957. 

  1957. 

  1958.           x1 = SCALED( point[-2].x );
    1959. 

  1959.           y1 = SCALED( point[-2].y );
    1960. 

  1960.           x2 = SCALED( point[-1].x );
    1961. 

  1961.           y2 = SCALED( point[-1].y );
    1962. 

  1962. 

  1963.           if ( flipped )
    1964. 

  1964.           {
    1965. 

  1965.             SWAP_( x1, y1 );
    1966. 

  1966.             SWAP_( x2, y2 );
    1967. 

  1967.           }
    1968. 

  1968. 

  1969.           if ( point <= limit )
    1970. 

  1970.           {
    1971. 

  1971.             x3 = SCALED( point[0].x );
    1972. 

  1972.             y3 = SCALED( point[0].y );
    1973. 

  1973. 

  1974.             if ( flipped )
    1975. 

  1975.               SWAP_( x3, y3 );
    1976. 

  1976. 

  1977.             if ( Cubic_To( RAS_VARS x1, y1, x2, y2, x3, y3 ) )
    1978. 

  1978.               goto Fail;
    1979. 

  1979.             continue;
    1980. 

  1980.           }
    1981. 

  1981. 

  1982.           if ( Cubic_To( RAS_VARS x1, y1, x2, y2, v_start.x, v_start.y ) )
    1983. 

  1983.             goto Fail;
    1984. 

  1984.           goto Close;
    1985. 

  1985.         }
    1986. 

  1986.       }
    1987. 

  1987.     }
    1988. 

  1988. 

  1989.     /* close the contour with a line segment */
    1990. 

  1990.     if ( Line_To( RAS_VARS v_start.x, v_start.y ) )
    1991. 

  1991.       goto Fail;
    1992. 

  1992. 

  1993.   Close:
    1994. 

  1994.     return SUCCESS;
    1995. 

  1995. 

  1996.   Invalid_Outline:
    1997. 

  1997.     ras.error = Raster_Err_Invalid;
    1998. 

  1998. 

  1999.   Fail:
    2000. 

  2000.     return FAILURE;
    2001. 

  2001.   }
    2002. 

  2002. 

  2003. 

  2004.   /*************************************************************************/
    2005. 

  2005.   /*                                                                       */
    2006. 

  2006.   /* <Function>                                                            */
    2007. 

  2007.   /*    Convert_Glyph                                                      */
    2008. 

  2008.   /*                                                                       */
    2009. 

  2009.   /* <Description>                                                         */
    2010. 

  2010.   /*    Convert a glyph into a series of segments and arcs and make a      */
    2011. 

  2011.   /*    profiles list with them.                                           */
    2012. 

  2012.   /*                                                                       */
    2013. 

  2013.   /* <Input>                                                               */
    2014. 

  2014.   /*    flipped :: If set, flip the direction of curve.                    */
    2015. 

  2015.   /*                                                                       */
    2016. 

  2016.   /* <Return>                                                              */
    2017. 

  2017.   /*    SUCCESS on success, FAILURE if any error was encountered during    */
    2018. 

  2018.   /*    rendering.                                                         */
    2019. 

  2019.   /*                                                                       */
    2020. 

  2020.   static Bool
    2021. 

  2021.   Convert_Glyph( RAS_ARGS int  flipped )
    2022. 

  2022.   {
    2023. 

  2023.     int       i;
    2024. 

  2024.     unsigned  start;
    2025. 

  2025. 

  2026.     PProfile  lastProfile;
    2027. 

  2027. 

  2028. 

  2029.     ras.fProfile = NULL;
    2030. 

  2030.     ras.joint    = FALSE;
    2031. 

  2031.     ras.fresh    = FALSE;
    2032. 

  2032. 

  2033.     ras.maxBuff  = ras.sizeBuff - AlignProfileSize;
    2034. 

  2034. 

  2035.     ras.numTurns = 0;
    2036. 

  2036. 

  2037.     ras.cProfile         = (PProfile)ras.top;
    2038. 

  2038.     ras.cProfile->offset = ras.top;
    2039. 

  2039.     ras.num_Profs        = 0;
    2040. 

  2040. 

  2041.     start = 0;
    2042. 

  2042. 

  2043.     for ( i = 0; i < ras.outline.n_contours; i++ )
    2044. 

  2044.     {
    2045. 

  2045.       Bool  o;
    2046. 

  2046. 

  2047. 

  2048.       ras.state    = Unknown_State;
    2049. 

  2049.       ras.gProfile = NULL;
    2050. 

  2050. 

  2051.       if ( Decompose_Curve( RAS_VARS (unsigned short)start,
    2052. 

  2052.                                      ras.outline.contours[i],
    2053. 

  2053.                                      flipped ) )
    2054. 

  2054.         return FAILURE;
    2055. 

  2055. 

  2056.       start = ras.outline.contours[i] + 1;
    2057. 

  2057. 

  2058.       /* we must now check whether the extreme arcs join or not */
    2059. 

  2059.       if ( FRAC( ras.lastY ) == 0 &&
    2060. 

  2060.            ras.lastY >= ras.minY  &&
    2061. 

  2061.            ras.lastY <= ras.maxY  )
    2062. 

  2062.         if ( ras.gProfile                        &&
    2063. 

  2063.              ( ras.gProfile->flags & Flow_Up ) ==
    2064. 

  2064.                ( ras.cProfile->flags & Flow_Up ) )
    2065. 

  2065.           ras.top--;
    2066. 

  2066.         /* Note that ras.gProfile can be nil if the contour was too small */
    2067. 

  2067.         /* to be drawn.                                                   */
    2068. 

  2068. 

  2069.       lastProfile = ras.cProfile;
    2070. 

  2070.       if ( ras.cProfile->flags & Flow_Up )
    2071. 

  2071.         o = IS_TOP_OVERSHOOT( ras.lastY );
    2072. 

  2072.       else
    2073. 

  2073.         o = IS_BOTTOM_OVERSHOOT( ras.lastY );
    2074. 

  2074.       if ( End_Profile( RAS_VARS o ) )
    2075. 

  2075.         return FAILURE;
    2076. 

  2076. 

  2077.       /* close the `next profile in contour' linked list */
    2078. 

  2078.       if ( ras.gProfile )
    2079. 

  2079.         lastProfile->next = ras.gProfile;
    2080. 

  2080.     }
    2081. 

  2081. 

  2082.     if ( Finalize_Profile_Table( RAS_VAR ) )
    2083. 

  2083.       return FAILURE;
    2084. 

  2084. 

  2085.     return (Bool)( ras.top < ras.maxBuff ? SUCCESS : FAILURE );
    2086. 

  2086.   }
    2087. 

  2087. 

  2088. 

  2089.   /*************************************************************************/
    2090. 

  2090.   /*************************************************************************/
    2091. 

  2091.   /**                                                                     **/
    2092. 

  2092.   /**  SCAN-LINE SWEEPS AND DRAWING                                       **/
    2093. 

  2093.   /**                                                                     **/
    2094. 

  2094.   /*************************************************************************/
    2095. 

  2095.   /*************************************************************************/
    2096. 

  2096. 

  2097. 

  2098.   /*************************************************************************/
    2099. 

  2099.   /*                                                                       */
    2100. 

  2100.   /*  Init_Linked                                                          */
    2101. 

  2101.   /*                                                                       */
    2102. 

  2102.   /*    Initializes an empty linked list.                                  */
    2103. 

  2103.   /*                                                                       */
    2104. 

  2104.   static void
    2105. 

  2105.   Init_Linked( TProfileList*  l )
    2106. 

  2106.   {
    2107. 

  2107.     *l = NULL;
    2108. 

  2108.   }
    2109. 

  2109. 

  2110. 

  2111.   /*************************************************************************/
    2112. 

  2112.   /*                                                                       */
    2113. 

  2113.   /*  InsNew                                                               */
    2114. 

  2114.   /*                                                                       */
    2115. 

  2115.   /*    Inserts a new profile in a linked list.                            */
    2116. 

  2116.   /*                                                                       */
    2117. 

  2117.   static void
    2118. 

  2118.   InsNew( PProfileList  list,
    2119. 

  2119.           PProfile      profile )
    2120. 

  2120.   {
    2121. 

  2121.     PProfile  *old, current;
    2122. 

  2122.     Long       x;
    2123. 

  2123. 

  2124. 

  2125.     old     = list;
    2126. 

  2126.     current = *old;
    2127. 

  2127.     x       = profile->X;
    2128. 

  2128. 

  2129.     while ( current )
    2130. 

  2130.     {
    2131. 

  2131.       if ( x < current->X )
    2132. 

  2132.         break;
    2133. 

  2133.       old     = &current->link;
    2134. 

  2134.       current = *old;
    2135. 

  2135.     }
    2136. 

  2136. 

  2137.     profile->link = current;
    2138. 

  2138.     *old          = profile;
    2139. 

  2139.   }
    2140. 

  2140. 

  2141. 

  2142.   /*************************************************************************/
    2143. 

  2143.   /*                                                                       */
    2144. 

  2144.   /*  DelOld                                                               */
    2145. 

  2145.   /*                                                                       */
    2146. 

  2146.   /*    Removes an old profile from a linked list.                         */
    2147. 

  2147.   /*                                                                       */
    2148. 

  2148.   static void
    2149. 

  2149.   DelOld( PProfileList  list,
    2150. 

  2150.           PProfile      profile )
    2151. 

  2151.   {
    2152. 

  2152.     PProfile  *old, current;
    2153. 

  2153. 

  2154. 

  2155.     old     = list;
    2156. 

  2156.     current = *old;
    2157. 

  2157. 

  2158.     while ( current )
    2159. 

  2159.     {
    2160. 

  2160.       if ( current == profile )
    2161. 

  2161.       {
    2162. 

  2162.         *old = current->link;
    2163. 

  2163.         return;
    2164. 

  2164.       }
    2165. 

  2165. 

  2166.       old     = &current->link;
    2167. 

  2167.       current = *old;
    2168. 

  2168.     }
    2169. 

  2169. 

  2170.     /* we should never get there, unless the profile was not part of */
    2171. 

  2171.     /* the list.                                                     */
    2172. 

  2172.   }
    2173. 

  2173. 

  2174. 

  2175.   /*************************************************************************/
    2176. 

  2176.   /*                                                                       */
    2177. 

  2177.   /*  Sort                                                                 */
    2178. 

  2178.   /*                                                                       */
    2179. 

  2179.   /*    Sorts a trace list.  In 95%, the list is already sorted.  We need  */
    2180. 

  2180.   /*    an algorithm which is fast in this case.  Bubble sort is enough    */
    2181. 

  2181.   /*    and simple.                                                        */
    2182. 

  2182.   /*                                                                       */
    2183. 

  2183.   static void
    2184. 

  2184.   Sort( PProfileList  list )
    2185. 

  2185.   {
    2186. 

  2186.     PProfile  *old, current, next;
    2187. 

  2187. 

  2188. 

  2189.     /* First, set the new X coordinate of each profile */
    2190. 

  2190.     current = *list;
    2191. 

  2191.     while ( current )
    2192. 

  2192.     {
    2193. 

  2193.       current->X       = *current->offset;
    2194. 

  2194.       current->offset += current->flags & Flow_Up ? 1 : -1;
    2195. 

  2195.       current->height--;
    2196. 

  2196.       current = current->link;
    2197. 

  2197.     }
    2198. 

  2198. 

  2199.     /* Then sort them */
    2200. 

  2200.     old     = list;
    2201. 

  2201.     current = *old;
    2202. 

  2202. 

  2203.     if ( !current )
    2204. 

  2204.       return;
    2205. 

  2205. 

  2206.     next = current->link;
    2207. 

  2207. 

  2208.     while ( next )
    2209. 

  2209.     {
    2210. 

  2210.       if ( current->X <= next->X )
    2211. 

  2211.       {
    2212. 

  2212.         old     = &current->link;
    2213. 

  2213.         current = *old;
    2214. 

  2214. 

  2215.         if ( !current )
    2216. 

  2216.           return;
    2217. 

  2217.       }
    2218. 

  2218.       else
    2219. 

  2219.       {
    2220. 

  2220.         *old          = next;
    2221. 

  2221.         current->link = next->link;
    2222. 

  2222.         next->link    = current;
    2223. 

  2223. 

  2224.         old     = list;
    2225. 

  2225.         current = *old;
    2226. 

  2226.       }
    2227. 

  2227. 

  2228.       next = current->link;
    2229. 

  2229.     }
    2230. 

  2230.   }
    2231. 

  2231. 

  2232. 

  2233.   /*************************************************************************/
    2234. 

  2234.   /*                                                                       */
    2235. 

  2235.   /*  Vertical Sweep Procedure Set                                         */
    2236. 

  2236.   /*                                                                       */
    2237. 

  2237.   /*  These four routines are used during the vertical black/white sweep   */
    2238. 

  2238.   /*  phase by the generic Draw_Sweep() function.                          */
    2239. 

  2239.   /*                                                                       */
    2240. 

  2240.   /*************************************************************************/
    2241. 

  2241. 

  2242.   static void
    2243. 

  2243.   Vertical_Sweep_Init( RAS_ARGS Short*  min,
    2244. 

  2244.                                 Short*  max )
    2245. 

  2245.   {
    2246. 

  2246.     Long  pitch = ras.target.pitch;
    2247. 

  2247. 

  2248.     FT_UNUSED( max );
    2249. 

  2249. 

  2250. 

  2251.     ras.traceIncr = (Short)-pitch;
    2252. 

  2252.     ras.traceOfs  = -*min * pitch;
    2253. 

  2253.     if ( pitch > 0 )
    2254. 

  2254.       ras.traceOfs += ( ras.target.rows - 1 ) * pitch;
    2255. 

  2255. 

  2256.     ras.gray_min_x = 0;
    2257. 

  2257.     ras.gray_max_x = 0;
    2258. 

  2258.   }
    2259. 

  2259. 

  2260. 

  2261.   static void
    2262. 

  2262.   Vertical_Sweep_Span( RAS_ARGS Short       y,
    2263. 

  2263.                                 FT_F26Dot6  x1,
    2264. 

  2264.                                 FT_F26Dot6  x2,
    2265. 

  2265.                                 PProfile    left,
    2266. 

  2266.                                 PProfile    right )
    2267. 

  2267.   {
    2268. 

  2268.     Long   e1, e2;
    2269. 

  2269.     int    c1, c2;
    2270. 

  2270.     Byte   f1, f2;
    2271. 

  2271.     Byte*  target;
    2272. 

  2272. 

  2273.     FT_UNUSED( y );
    2274. 

  2274.     FT_UNUSED( left );
    2275. 

  2275.     FT_UNUSED( right );
    2276. 

  2276. 

  2277. 

  2278.     /* Drop-out control */
    2279. 

  2279. 

  2280.     e1 = TRUNC( CEILING( x1 ) );
    2281. 

  2281. 

  2282.     if ( x2 - x1 - ras.precision <= ras.precision_jitter )
    2283. 

  2283.       e2 = e1;
    2284. 

  2284.     else
    2285. 

  2285.       e2 = TRUNC( FLOOR( x2 ) );
    2286. 

  2286. 

  2287.     if ( e2 >= 0 && e1 < ras.bWidth )
    2288. 

  2288.     {
    2289. 

  2289.       if ( e1 < 0 )
    2290. 

  2290.         e1 = 0;
    2291. 

  2291.       if ( e2 >= ras.bWidth )
    2292. 

  2292.         e2 = ras.bWidth - 1;
    2293. 

  2293. 

  2294.       c1 = (Short)( e1 >> 3 );
    2295. 

  2295.       c2 = (Short)( e2 >> 3 );
    2296. 

  2296. 

  2297.       f1 = (Byte)  ( 0xFF >> ( e1 & 7 ) );
    2298. 

  2298.       f2 = (Byte) ~( 0x7F >> ( e2 & 7 ) );
    2299. 

  2299. 

  2300.       if ( ras.gray_min_x > c1 )
    2301. 

  2301.         ras.gray_min_x = (short)c1;
    2302. 

  2302.       if ( ras.gray_max_x < c2 )
    2303. 

  2303.         ras.gray_max_x = (short)c2;
    2304. 

  2304. 

  2305.       target = ras.bTarget + ras.traceOfs + c1;
    2306. 

  2306.       c2 -= c1;
    2307. 

  2307. 

  2308.       if ( c2 > 0 )
    2309. 

  2309.       {
    2310. 

  2310.         target[0] |= f1;
    2311. 

  2311. 

  2312.         /* memset() is slower than the following code on many platforms. */
    2313. 

  2313.         /* This is due to the fact that, in the vast majority of cases,  */
    2314. 

  2314.         /* the span length in bytes is relatively small.                 */
    2315. 

  2315.         c2--;
    2316. 

  2316.         while ( c2 > 0 )
    2317. 

  2317.         {
    2318. 

  2318.           *(++target) = 0xFF;
    2319. 

  2319.           c2--;
    2320. 

  2320.         }
    2321. 

  2321.         target[1] |= f2;
    2322. 

  2322.       }
    2323. 

  2323.       else
    2324. 

  2324.         *target |= ( f1 & f2 );
    2325. 

  2325.     }
    2326. 

  2326.   }
    2327. 

  2327. 

  2328. 

  2329.   static void
    2330. 

  2330.   Vertical_Sweep_Drop( RAS_ARGS Short       y,
    2331. 

  2331.                                 FT_F26Dot6  x1,
    2332. 

  2332.                                 FT_F26Dot6  x2,
    2333. 

  2333.                                 PProfile    left,
    2334. 

  2334.                                 PProfile    right )
    2335. 

  2335.   {
    2336. 

  2336.     Long   e1, e2, pxl;
    2337. 

  2337.     Short  c1, f1;
    2338. 

  2338. 

  2339. 

  2340.     /* Drop-out control */
    2341. 

  2341. 

  2342.     /*   e2            x2                    x1           e1   */
    2343. 

  2343.     /*                                                         */
    2344. 

  2344.     /*                 ^                     |                 */
    2345. 

  2345.     /*                 |                     |                 */
    2346. 

  2346.     /*   +-------------+---------------------+------------+    */
    2347. 

  2347.     /*                 |                     |                 */
    2348. 

  2348.     /*                 |                     v                 */
    2349. 

  2349.     /*                                                         */
    2350. 

  2350.     /* pixel         contour              contour       pixel  */
    2351. 

  2351.     /* center                                           center */
    2352. 

  2352. 

  2353.     /* drop-out mode    scan conversion rules (as defined in OpenType) */
    2354. 

  2354.     /* --------------------------------------------------------------- */
    2355. 

  2355.     /*  0                1, 2, 3                                       */
    2356. 

  2356.     /*  1                1, 2, 4                                       */
    2357. 

  2357.     /*  2                1, 2                                          */
    2358. 

  2358.     /*  3                same as mode 2                                */
    2359. 

  2359.     /*  4                1, 2, 5                                       */
    2360. 

  2360.     /*  5                1, 2, 6                                       */
    2361. 

  2361.     /*  6, 7             same as mode 2                                */
    2362. 

  2362. 

  2363.     e1  = CEILING( x1 );
    2364. 

  2364.     e2  = FLOOR  ( x2 );
    2365. 

  2365.     pxl = e1;
    2366. 

  2366. 

  2367.     if ( e1 > e2 )
    2368. 

  2368.     {
    2369. 

  2369.       Int  dropOutControl = left->flags & 7;
    2370. 

  2370. 

  2371. 

  2372.       if ( e1 == e2 + ras.precision )
    2373. 

  2373.       {
    2374. 

  2374.         switch ( dropOutControl )
    2375. 

  2375.         {
    2376. 

  2376.         case 0: /* simple drop-outs including stubs */
    2377. 

  2377.           pxl = e2;
    2378. 

  2378.           break;
    2379. 

  2379. 

  2380.         case 4: /* smart drop-outs including stubs */
    2381. 

  2381.           pxl = FLOOR( ( x1 + x2 - 1 ) / 2 + ras.precision_half );
    2382. 

  2382.           break;
    2383. 

  2383. 

  2384.         case 1: /* simple drop-outs excluding stubs */
    2385. 

  2385.         case 5: /* smart drop-outs excluding stubs  */
    2386. 

  2386. 

  2387.           /* Drop-out Control Rules #4 and #6 */
    2388. 

  2388. 

  2389.           /* The specification neither provides an exact definition */
    2390. 

  2390.           /* of a `stub' nor gives exact rules to exclude them.     */
    2391. 

  2391.           /*                                                        */
    2392. 

  2392.           /* Here the constraints we use to recognize a stub.       */
    2393. 

  2393.           /*                                                        */
    2394. 

  2394.           /*  upper stub:                                           */
    2395. 

  2395.           /*                                                        */
    2396. 

  2396.           /*   - P_Left and P_Right are in the same contour         */
    2397. 

  2397.           /*   - P_Right is the successor of P_Left in that contour */
    2398. 

  2398.           /*   - y is the top of P_Left and P_Right                 */
    2399. 

  2399.           /*                                                        */
    2400. 

  2400.           /*  lower stub:                                           */
    2401. 

  2401.           /*                                                        */
    2402. 

  2402.           /*   - P_Left and P_Right are in the same contour         */
    2403. 

  2403.           /*   - P_Left is the successor of P_Right in that contour */
    2404. 

  2404.           /*   - y is the bottom of P_Left                          */
    2405. 

  2405.           /*                                                        */
    2406. 

  2406.           /* We draw a stub if the following constraints are met.   */
    2407. 

  2407.           /*                                                        */
    2408. 

  2408.           /*   - for an upper or lower stub, there is top or bottom */
    2409. 

  2409.           /*     overshoot, respectively                            */
    2410. 

  2410.           /*   - the covered interval is greater or equal to a half */
    2411. 

  2411.           /*     pixel                                              */
    2412. 

  2412. 

  2413.           /* upper stub test */
    2414. 

  2414.           if ( left->next == right                &&
    2415. 

  2415.                left->height <= 0                  &&
    2416. 

  2416.                !( left->flags & Overshoot_Top   &&
    2417. 

  2417.                   x2 - x1 >= ras.precision_half ) )
    2418. 

  2418.             return;
    2419. 

  2419. 

  2420.           /* lower stub test */
    2421. 

  2421.           if ( right->next == left                 &&
    2422. 

  2422.                left->start == y                    &&
    2423. 

  2423.                !( left->flags & Overshoot_Bottom &&
    2424. 

  2424.                   x2 - x1 >= ras.precision_half  ) )
    2425. 

  2425.             return;
    2426. 

  2426. 

  2427.           if ( dropOutControl == 1 )
    2428. 

  2428.             pxl = e2;
    2429. 

  2429.           else
    2430. 

  2430.             pxl = FLOOR( ( x1 + x2 - 1 ) / 2 + ras.precision_half );
    2431. 

  2431.           break;
    2432. 

  2432. 

  2433.         default: /* modes 2, 3, 6, 7 */
    2434. 

  2434.           return;  /* no drop-out control */
    2435. 

  2435.         }
    2436. 

  2436. 

  2437.         /* undocumented but confirmed: If the drop-out would result in a  */
    2438. 

  2438.         /* pixel outside of the bounding box, use the pixel inside of the */
    2439. 

  2439.         /* bounding box instead                                           */
    2440. 

  2440.         if ( pxl < 0 )
    2441. 

  2441.           pxl = e1;
    2442. 

  2442.         else if ( TRUNC( pxl ) >= ras.bWidth )
    2443. 

  2443.           pxl = e2;
    2444. 

  2444. 

  2445.         /* check that the other pixel isn't set */
    2446. 

  2446.         e1 = pxl == e1 ? e2 : e1;
    2447. 

  2447. 

  2448.         e1 = TRUNC( e1 );
    2449. 

  2449. 

  2450.         c1 = (Short)( e1 >> 3 );
    2451. 

  2451.         f1 = (Short)( e1 &  7 );
    2452. 

  2452. 

  2453.         if ( e1 >= 0 && e1 < ras.bWidth                      &&
    2454. 

  2454.              ras.bTarget[ras.traceOfs + c1] & ( 0x80 >> f1 ) )
    2455. 

  2455.           return;
    2456. 

  2456.       }
    2457. 

  2457.       else
    2458. 

  2458.         return;
    2459. 

  2459.     }
    2460. 

  2460. 

  2461.     e1 = TRUNC( pxl );
    2462. 

  2462. 

  2463.     if ( e1 >= 0 && e1 < ras.bWidth )
    2464. 

  2464.     {
    2465. 

  2465.       c1 = (Short)( e1 >> 3 );
    2466. 

  2466.       f1 = (Short)( e1 & 7 );
    2467. 

  2467. 

  2468.       if ( ras.gray_min_x > c1 )
    2469. 

  2469.         ras.gray_min_x = c1;
    2470. 

  2470.       if ( ras.gray_max_x < c1 )
    2471. 

  2471.         ras.gray_max_x = c1;
    2472. 

  2472. 

  2473.       ras.bTarget[ras.traceOfs + c1] |= (char)( 0x80 >> f1 );
    2474. 

  2474.     }
    2475. 

  2475.   }
    2476. 

  2476. 

  2477. 

  2478.   static void
    2479. 

  2479.   Vertical_Sweep_Step( RAS_ARG )
    2480. 

  2480.   {
    2481. 

  2481.     ras.traceOfs += ras.traceIncr;
    2482. 

  2482.   }
    2483. 

  2483. 

  2484. 

  2485.   /***********************************************************************/
    2486. 

  2486.   /*                                                                     */
    2487. 

  2487.   /*  Horizontal Sweep Procedure Set                                     */
    2488. 

  2488.   /*                                                                     */
    2489. 

  2489.   /*  These four routines are used during the horizontal black/white     */
    2490. 

  2490.   /*  sweep phase by the generic Draw_Sweep() function.                  */
    2491. 

  2491.   /*                                                                     */
    2492. 

  2492.   /***********************************************************************/
    2493. 

  2493. 

  2494.   static void
    2495. 

  2495.   Horizontal_Sweep_Init( RAS_ARGS Short*  min,
    2496. 

  2496.                                   Short*  max )
    2497. 

  2497.   {
    2498. 

  2498.     /* nothing, really */
    2499. 

  2499.     FT_UNUSED_RASTER;
    2500. 

  2500.     FT_UNUSED( min );
    2501. 

  2501.     FT_UNUSED( max );
    2502. 

  2502.   }
    2503. 

  2503. 

  2504. 

  2505.   static void
    2506. 

  2506.   Horizontal_Sweep_Span( RAS_ARGS Short       y,
    2507. 

  2507.                                   FT_F26Dot6  x1,
    2508. 

  2508.                                   FT_F26Dot6  x2,
    2509. 

  2509.                                   PProfile    left,
    2510. 

  2510.                                   PProfile    right )
    2511. 

  2511.   {
    2512. 

  2512.     Long   e1, e2;
    2513. 

  2513.     PByte  bits;
    2514. 

  2514.     Byte   f1;
    2515. 

  2515. 

  2516.     FT_UNUSED( left );
    2517. 

  2517.     FT_UNUSED( right );
    2518. 

  2518. 

  2519. 

  2520.     if ( x2 - x1 < ras.precision )
    2521. 

  2521.     {
    2522. 

  2522.       e1 = CEILING( x1 );
    2523. 

  2523.       e2 = FLOOR  ( x2 );
    2524. 

  2524. 

  2525.       if ( e1 == e2 )
    2526. 

  2526.       {
    2527. 

  2527.         bits = ras.bTarget + ( y >> 3 );
    2528. 

  2528.         f1   = (Byte)( 0x80 >> ( y & 7 ) );
    2529. 

  2529. 

  2530.         e1 = TRUNC( e1 );
    2531. 

  2531. 

  2532.         if ( e1 >= 0 && e1 < ras.target.rows )
    2533. 

  2533.         {
    2534. 

  2534.           PByte  p;
    2535. 

  2535. 

  2536. 

  2537.           p = bits - e1 * ras.target.pitch;
    2538. 

  2538.           if ( ras.target.pitch > 0 )
    2539. 

  2539.             p += ( ras.target.rows - 1 ) * ras.target.pitch;
    2540. 

  2540. 

  2541.           p[0] |= f1;
    2542. 

  2542.         }
    2543. 

  2543.       }
    2544. 

  2544.     }
    2545. 

  2545.   }
    2546. 

  2546. 

  2547. 

  2548.   static void
    2549. 

  2549.   Horizontal_Sweep_Drop( RAS_ARGS Short       y,
    2550. 

  2550.                                   FT_F26Dot6  x1,
    2551. 

  2551.                                   FT_F26Dot6  x2,
    2552. 

  2552.                                   PProfile    left,
    2553. 

  2553.                                   PProfile    right )
    2554. 

  2554.   {
    2555. 

  2555.     Long   e1, e2, pxl;
    2556. 

  2556.     PByte  bits;
    2557. 

  2557.     Byte   f1;
    2558. 

  2558. 

  2559. 

  2560.     /* During the horizontal sweep, we only take care of drop-outs */
    2561. 

  2561. 

  2562.     /* e1     +       <-- pixel center */
    2563. 

  2563.     /*        |                        */
    2564. 

  2564.     /* x1  ---+-->    <-- contour      */
    2565. 

  2565.     /*        |                        */
    2566. 

  2566.     /*        |                        */
    2567. 

  2567.     /* x2  <--+---    <-- contour      */
    2568. 

  2568.     /*        |                        */
    2569. 

  2569.     /*        |                        */
    2570. 

  2570.     /* e2     +       <-- pixel center */
    2571. 

  2571. 

  2572.     e1  = CEILING( x1 );
    2573. 

  2573.     e2  = FLOOR  ( x2 );
    2574. 

  2574.     pxl = e1;
    2575. 

  2575. 

  2576.     if ( e1 > e2 )
    2577. 

  2577.     {
    2578. 

  2578.       Int  dropOutControl = left->flags & 7;
    2579. 

  2579. 

  2580. 

  2581.       if ( e1 == e2 + ras.precision )
    2582. 

  2582.       {
    2583. 

  2583.         switch ( dropOutControl )
    2584. 

  2584.         {
    2585. 

  2585.         case 0: /* simple drop-outs including stubs */
    2586. 

  2586.           pxl = e2;
    2587. 

  2587.           break;
    2588. 

  2588. 

  2589.         case 4: /* smart drop-outs including stubs */
    2590. 

  2590.           pxl = FLOOR( ( x1 + x2 - 1 ) / 2 + ras.precision_half );
    2591. 

  2591.           break;
    2592. 

  2592. 

  2593.         case 1: /* simple drop-outs excluding stubs */
    2594. 

  2594.         case 5: /* smart drop-outs excluding stubs  */
    2595. 

  2595.           /* see Vertical_Sweep_Drop for details */
    2596. 

  2596. 

  2597.           /* rightmost stub test */
    2598. 

  2598.           if ( left->next == right                &&
    2599. 

  2599.                left->height <= 0                  &&
    2600. 

  2600.                !( left->flags & Overshoot_Top   &&
    2601. 

  2601.                   x2 - x1 >= ras.precision_half ) )
    2602. 

  2602.             return;
    2603. 

  2603. 

  2604.           /* leftmost stub test */
    2605. 

  2605.           if ( right->next == left                 &&
    2606. 

  2606.                left->start == y                    &&
    2607. 

  2607.                !( left->flags & Overshoot_Bottom &&
    2608. 

  2608.                   x2 - x1 >= ras.precision_half  ) )
    2609. 

  2609.             return;
    2610. 

  2610. 

  2611.           if ( dropOutControl == 1 )
    2612. 

  2612.             pxl = e2;
    2613. 

  2613.           else
    2614. 

  2614.             pxl = FLOOR( ( x1 + x2 - 1 ) / 2 + ras.precision_half );
    2615. 

  2615.           break;
    2616. 

  2616. 

  2617.         default: /* modes 2, 3, 6, 7 */
    2618. 

  2618.           return;  /* no drop-out control */
    2619. 

  2619.         }
    2620. 

  2620. 

  2621.         /* undocumented but confirmed: If the drop-out would result in a  */
    2622. 

  2622.         /* pixel outside of the bounding box, use the pixel inside of the */
    2623. 

  2623.         /* bounding box instead                                           */
    2624. 

  2624.         if ( pxl < 0 )
    2625. 

  2625.           pxl = e1;
    2626. 

  2626.         else if ( TRUNC( pxl ) >= ras.target.rows )
    2627. 

  2627.           pxl = e2;
    2628. 

  2628. 

  2629.         /* check that the other pixel isn't set */
    2630. 

  2630.         e1 = pxl == e1 ? e2 : e1;
    2631. 

  2631. 

  2632.         e1 = TRUNC( e1 );
    2633. 

  2633. 

  2634.         bits = ras.bTarget + ( y >> 3 );
    2635. 

  2635.         f1   = (Byte)( 0x80 >> ( y & 7 ) );
    2636. 

  2636. 

  2637.         bits -= e1 * ras.target.pitch;
    2638. 

  2638.         if ( ras.target.pitch > 0 )
    2639. 

  2639.           bits += ( ras.target.rows - 1 ) * ras.target.pitch;
    2640. 

  2640. 

  2641.         if ( e1 >= 0              &&
    2642. 

  2642.              e1 < ras.target.rows &&
    2643. 

  2643.              *bits & f1           )
    2644. 

  2644.           return;
    2645. 

  2645.       }
    2646. 

  2646.       else
    2647. 

  2647.         return;
    2648. 

  2648.     }
    2649. 

  2649. 

  2650.     bits = ras.bTarget + ( y >> 3 );
    2651. 

  2651.     f1   = (Byte)( 0x80 >> ( y & 7 ) );
    2652. 

  2652. 

  2653.     e1 = TRUNC( pxl );
    2654. 

  2654. 

  2655.     if ( e1 >= 0 && e1 < ras.target.rows )
    2656. 

  2656.     {
    2657. 

  2657.       bits -= e1 * ras.target.pitch;
    2658. 

  2658.       if ( ras.target.pitch > 0 )
    2659. 

  2659.         bits += ( ras.target.rows - 1 ) * ras.target.pitch;
    2660. 

  2660. 

  2661.       bits[0] |= f1;
    2662. 

  2662.     }
    2663. 

  2663.   }
    2664. 

  2664. 

  2665. 

  2666.   static void
    2667. 

  2667.   Horizontal_Sweep_Step( RAS_ARG )
    2668. 

  2668.   {
    2669. 

  2669.     /* Nothing, really */
    2670. 

  2670.     FT_UNUSED_RASTER;
    2671. 

  2671.   }
    2672. 

  2672. 

  2673. 

  2674. #ifdef FT_RASTER_OPTION_ANTI_ALIASING
    2675. 

  2675. 

  2676. 

  2677.   /*************************************************************************/
    2678. 

  2678.   /*                                                                       */
    2679. 

  2679.   /*  Vertical Gray Sweep Procedure Set                                    */
    2680. 

  2680.   /*                                                                       */
    2681. 

  2681.   /*  These two routines are used during the vertical gray-levels sweep    */
    2682. 

  2682.   /*  phase by the generic Draw_Sweep() function.                          */
    2683. 

  2683.   /*                                                                       */
    2684. 

  2684.   /*  NOTES                                                                */
    2685. 

  2685.   /*                                                                       */
    2686. 

  2686.   /*  - The target pixmap's width *must* be a multiple of 4.               */
    2687. 

  2687.   /*                                                                       */
    2688. 

  2688.   /*  - You have to use the function Vertical_Sweep_Span() for the gray    */
    2689. 

  2689.   /*    span call.                                                         */
    2690. 

  2690.   /*                                                                       */
    2691. 

  2691.   /*************************************************************************/
    2692. 

  2692. 

  2693.   static void
    2694. 

  2694.   Vertical_Gray_Sweep_Init( RAS_ARGS Short*  min,
    2695. 

  2695.                                      Short*  max )
    2696. 

  2696.   {
    2697. 

  2697.     Long  pitch, byte_len;
    2698. 

  2698. 

  2699. 

  2700.     *min = *min & -2;
    2701. 

  2701.     *max = ( *max + 3 ) & -2;
    2702. 

  2702. 

  2703.     ras.traceOfs  = 0;
    2704. 

  2704.     pitch         = ras.target.pitch;
    2705. 

  2705.     byte_len      = -pitch;
    2706. 

  2706.     ras.traceIncr = (Short)byte_len;
    2707. 

  2707.     ras.traceG    = ( *min / 2 ) * byte_len;
    2708. 

  2708. 

  2709.     if ( pitch > 0 )
    2710. 

  2710.     {
    2711. 

  2711.       ras.traceG += ( ras.target.rows - 1 ) * pitch;
    2712. 

  2712.       byte_len    = -byte_len;
    2713. 

  2713.     }
    2714. 

  2714. 

  2715.     ras.gray_min_x =  (Short)byte_len;
    2716. 

  2716.     ras.gray_max_x = -(Short)byte_len;
    2717. 

  2717.   }
    2718. 

  2718. 

  2719. 

  2720.   static void
    2721. 

  2721.   Vertical_Gray_Sweep_Step( RAS_ARG )
    2722. 

  2722.   {
    2723. 

  2723.     Int     c1, c2;
    2724. 

  2724.     PByte   pix, bit, bit2;
    2725. 

  2725.     short*  count = (short*)count_table;
    2726. 

  2726.     Byte*   grays;
    2727. 

  2727. 

  2728. 

  2729.     ras.traceOfs += ras.gray_width;
    2730. 

  2730. 

  2731.     if ( ras.traceOfs > ras.gray_width )
    2732. 

  2732.     {
    2733. 

  2733.       pix   = ras.gTarget + ras.traceG + ras.gray_min_x * 4;
    2734. 

  2734.       grays = ras.grays;
    2735. 

  2735. 

  2736.       if ( ras.gray_max_x >= 0 )
    2737. 

  2737.       {
    2738. 

  2738.         Long  last_pixel = ras.target.width - 1;
    2739. 

  2739.         Int   last_cell  = last_pixel >> 2;
    2740. 

  2740.         Int   last_bit   = last_pixel & 3;
    2741. 

  2741.         Bool  over       = 0;
    2742. 

  2742. 

  2743. 

  2744.         if ( ras.gray_max_x >= last_cell && last_bit != 3 )
    2745. 

  2745.         {
    2746. 

  2746.           ras.gray_max_x = last_cell - 1;
    2747. 

  2747.           over = 1;
    2748. 

  2748.         }
    2749. 

  2749. 

  2750.         if ( ras.gray_min_x < 0 )
    2751. 

  2751.           ras.gray_min_x = 0;
    2752. 

  2752. 

  2753.         bit  = ras.bTarget + ras.gray_min_x;
    2754. 

  2754.         bit2 = bit + ras.gray_width;
    2755. 

  2755. 

  2756.         c1 = ras.gray_max_x - ras.gray_min_x;
    2757. 

  2757. 

  2758.         while ( c1 >= 0 )
    2759. 

  2759.         {
    2760. 

  2760.           c2 = count[*bit] + count[*bit2];
    2761. 

  2761. 

  2762.           if ( c2 )
    2763. 

  2763.           {
    2764. 

  2764.             pix[0] = grays[(c2 >> 12) & 0x000F];
    2765. 

  2765.             pix[1] = grays[(c2 >> 8 ) & 0x000F];
    2766. 

  2766.             pix[2] = grays[(c2 >> 4 ) & 0x000F];
    2767. 

  2767.             pix[3] = grays[ c2        & 0x000F];
    2768. 

  2768. 

  2769.             *bit  = 0;
    2770. 

  2770.             *bit2 = 0;
    2771. 

  2771.           }
    2772. 

  2772. 

  2773.           bit++;
    2774. 

  2774.           bit2++;
    2775. 

  2775.           pix += 4;
    2776. 

  2776.           c1--;
    2777. 

  2777.         }
    2778. 

  2778. 

  2779.         if ( over )
    2780. 

  2780.         {
    2781. 

  2781.           c2 = count[*bit] + count[*bit2];
    2782. 

  2782.           if ( c2 )
    2783. 

  2783.           {
    2784. 

  2784.             switch ( last_bit )
    2785. 

  2785.             {
    2786. 

  2786.             case 2:
    2787. 

  2787.               pix[2] = grays[(c2 >> 4 ) & 0x000F];
    2788. 

  2788.             case 1:
    2789. 

  2789.               pix[1] = grays[(c2 >> 8 ) & 0x000F];
    2790. 

  2790.             default:
    2791. 

  2791.               pix[0] = grays[(c2 >> 12) & 0x000F];
    2792. 

  2792.             }
    2793. 

  2793. 

  2794.             *bit  = 0;
    2795. 

  2795.             *bit2 = 0;
    2796. 

  2796.           }
    2797. 

  2797.         }
    2798. 

  2798.       }
    2799. 

  2799. 

  2800.       ras.traceOfs = 0;
    2801. 

  2801.       ras.traceG  += ras.traceIncr;
    2802. 

  2802. 

  2803.       ras.gray_min_x =  32000;
    2804. 

  2804.       ras.gray_max_x = -32000;
    2805. 

  2805.     }
    2806. 

  2806.   }
    2807. 

  2807. 

  2808. 

  2809.   static void
    2810. 

  2810.   Horizontal_Gray_Sweep_Span( RAS_ARGS Short       y,
    2811. 

  2811.                                        FT_F26Dot6  x1,
    2812. 

  2812.                                        FT_F26Dot6  x2,
    2813. 

  2813.                                        PProfile    left,
    2814. 

  2814.                                        PProfile    right )
    2815. 

  2815.   {
    2816. 

  2816.     /* nothing, really */
    2817. 

  2817.     FT_UNUSED_RASTER;
    2818. 

  2818.     FT_UNUSED( y );
    2819. 

  2819.     FT_UNUSED( x1 );
    2820. 

  2820.     FT_UNUSED( x2 );
    2821. 

  2821.     FT_UNUSED( left );
    2822. 

  2822.     FT_UNUSED( right );
    2823. 

  2823.   }
    2824. 

  2824. 

  2825. 

  2826.   static void
    2827. 

  2827.   Horizontal_Gray_Sweep_Drop( RAS_ARGS Short       y,
    2828. 

  2828.                                        FT_F26Dot6  x1,
    2829. 

  2829.                                        FT_F26Dot6  x2,
    2830. 

  2830.                                        PProfile    left,
    2831. 

  2831.                                        PProfile    right )
    2832. 

  2832.   {
    2833. 

  2833.     Long   e1, e2;
    2834. 

  2834.     PByte  pixel;
    2835. 

  2835.     Byte   color;
    2836. 

  2836. 

  2837. 

  2838.     /* During the horizontal sweep, we only take care of drop-outs */
    2839. 

  2839. 

  2840.     e1 = CEILING( x1 );
    2841. 

  2841.     e2 = FLOOR  ( x2 );
    2842. 

  2842. 

  2843.     if ( e1 > e2 )
    2844. 

  2844.     {
    2845. 

  2845.       Int  dropOutControl = left->flags & 7;
    2846. 

  2846. 

  2847. 

  2848.       if ( e1 == e2 + ras.precision )
    2849. 

  2849.       {
    2850. 

  2850.         switch ( dropOutControl )
    2851. 

  2851.         {
    2852. 

  2852.         case 0: /* simple drop-outs including stubs */
    2853. 

  2853.           e1 = e2;
    2854. 

  2854.           break;
    2855. 

  2855. 

  2856.         case 4: /* smart drop-outs including stubs */
    2857. 

  2857.           e1 = FLOOR( ( x1 + x2 - 1 ) / 2 + ras.precision_half );
    2858. 

  2858.           break;
    2859. 

  2859. 

  2860.         case 1: /* simple drop-outs excluding stubs */
    2861. 

  2861.         case 5: /* smart drop-outs excluding stubs  */
    2862. 

  2862.           /* see Vertical_Sweep_Drop for details */
    2863. 

  2863. 

  2864.           /* rightmost stub test */
    2865. 

  2865.           if ( left->next == right && left->height <= 0 )
    2866. 

  2866.             return;
    2867. 

  2867. 

  2868.           /* leftmost stub test */
    2869. 

  2869.           if ( right->next == left && left->start == y )
    2870. 

  2870.             return;
    2871. 

  2871. 

  2872.           if ( dropOutControl == 1 )
    2873. 

  2873.             e1 = e2;
    2874. 

  2874.           else
    2875. 

  2875.             e1 = FLOOR( ( x1 + x2 - 1 ) / 2 + ras.precision_half );
    2876. 

  2876. 

  2877.           break;
    2878. 

  2878. 

  2879.         default: /* modes 2, 3, 6, 7 */
    2880. 

  2880.           return;  /* no drop-out control */
    2881. 

  2881.         }
    2882. 

  2882.       }
    2883. 

  2883.       else
    2884. 

  2884.         return;
    2885. 

  2885.     }
    2886. 

  2886. 

  2887.     if ( e1 >= 0 )
    2888. 

  2888.     {
    2889. 

  2889.       if ( x2 - x1 >= ras.precision_half )
    2890. 

  2890.         color = ras.grays[2];
    2891. 

  2891.       else
    2892. 

  2892.         color = ras.grays[1];
    2893. 

  2893. 

  2894.       e1 = TRUNC( e1 ) / 2;
    2895. 

  2895.       if ( e1 < ras.target.rows )
    2896. 

  2896.       {
    2897. 

  2897.         pixel = ras.gTarget - e1 * ras.target.pitch + y / 2;
    2898. 

  2898.         if ( ras.target.pitch > 0 )
    2899. 

  2899.           pixel += ( ras.target.rows - 1 ) * ras.target.pitch;
    2900. 

  2900. 

  2901.         if ( pixel[0] == ras.grays[0] )
    2902. 

  2902.           pixel[0] = color;
    2903. 

  2903.       }
    2904. 

  2904.     }
    2905. 

  2905.   }
    2906. 

  2906. 

  2907. 

  2908. #endif /* FT_RASTER_OPTION_ANTI_ALIASING */
    2909. 

  2909. 

  2910. 

  2911.   /*************************************************************************/
    2912. 

  2912.   /*                                                                       */
    2913. 

  2913.   /*  Generic Sweep Drawing routine                                        */
    2914. 

  2914.   /*                                                                       */
    2915. 

  2915.   /*************************************************************************/
    2916. 

  2916. 

  2917.   static Bool
    2918. 

  2918.   Draw_Sweep( RAS_ARG )
    2919. 

  2919.   {
    2920. 

  2920.     Short         y, y_change, y_height;
    2921. 

  2921. 

  2922.     PProfile      P, Q, P_Left, P_Right;
    2923. 

  2923. 

  2924.     Short         min_Y, max_Y, top, bottom, dropouts;
    2925. 

  2925. 

  2926.     Long          x1, x2, xs, e1, e2;
    2927. 

  2927. 

  2928.     TProfileList  waiting;
    2929. 

  2929.     TProfileList  draw_left, draw_right;
    2930. 

  2930. 

  2931. 

  2932.     /* initialize empty linked lists */
    2933. 

  2933. 

  2934.     Init_Linked( &waiting );
    2935. 

  2935. 

  2936.     Init_Linked( &draw_left  );
    2937. 

  2937.     Init_Linked( &draw_right );
    2938. 

  2938. 

  2939.     /* first, compute min and max Y */
    2940. 

  2940. 

  2941.     P     = ras.fProfile;
    2942. 

  2942.     max_Y = (Short)TRUNC( ras.minY );
    2943. 

  2943.     min_Y = (Short)TRUNC( ras.maxY );
    2944. 

  2944. 

  2945.     while ( P )
    2946. 

  2946.     {
    2947. 

  2947.       Q = P->link;
    2948. 

  2948. 

  2949.       bottom = (Short)P->start;
    2950. 

  2950.       top    = (Short)( P->start + P->height - 1 );
    2951. 

  2951. 

  2952.       if ( min_Y > bottom )
    2953. 

  2953.         min_Y = bottom;
    2954. 

  2954.       if ( max_Y < top )
    2955. 

  2955.         max_Y = top;
    2956. 

  2956. 

  2957.       P->X = 0;
    2958. 

  2958.       InsNew( &waiting, P );
    2959. 

  2959. 

  2960.       P = Q;
    2961. 

  2961.     }
    2962. 

  2962. 

  2963.     /* check the Y-turns */
    2964. 

  2964.     if ( ras.numTurns == 0 )
    2965. 

  2965.     {
    2966. 

  2966.       ras.error = Raster_Err_Invalid;
    2967. 

  2967.       return FAILURE;
    2968. 

  2968.     }
    2969. 

  2969. 

  2970.     /* now initialize the sweep */
    2971. 

  2971. 

  2972.     ras.Proc_Sweep_Init( RAS_VARS &min_Y, &max_Y );
    2973. 

  2973. 

  2974.     /* then compute the distance of each profile from min_Y */
    2975. 

  2975. 

  2976.     P = waiting;
    2977. 

  2977. 

  2978.     while ( P )
    2979. 

  2979.     {
    2980. 

  2980.       P->countL = (UShort)( P->start - min_Y );
    2981. 

  2981.       P = P->link;
    2982. 

  2982.     }
    2983. 

  2983. 

  2984.     /* let's go */
    2985. 

  2985. 

  2986.     y        = min_Y;
    2987. 

  2987.     y_height = 0;
    2988. 

  2988. 

  2989.     if ( ras.numTurns > 0                     &&
    2990. 

  2990.          ras.sizeBuff[-ras.numTurns] == min_Y )
    2991. 

  2991.       ras.numTurns--;
    2992. 

  2992. 

  2993.     while ( ras.numTurns > 0 )
    2994. 

  2994.     {
    2995. 

  2995.       /* check waiting list for new activations */
    2996. 

  2996. 

  2997.       P = waiting;
    2998. 

  2998. 

  2999.       while ( P )
    3000. 

  3000.       {
    3001. 

  3001.         Q = P->link;
    3002. 

  3002.         P->countL -= y_height;
    3003. 

  3003.         if ( P->countL == 0 )
    3004. 

  3004.         {
    3005. 

  3005.           DelOld( &waiting, P );
    3006. 

  3006. 

  3007.           if ( P->flags & Flow_Up )
    3008. 

  3008.             InsNew( &draw_left,  P );
    3009. 

  3009.           else
    3010. 

  3010.             InsNew( &draw_right, P );
    3011. 

  3011.         }
    3012. 

  3012. 

  3013.         P = Q;
    3014. 

  3014.       }
    3015. 

  3015. 

  3016.       /* sort the drawing lists */
    3017. 

  3017. 

  3018.       Sort( &draw_left );
    3019. 

  3019.       Sort( &draw_right );
    3020. 

  3020. 

  3021.       y_change = (Short)ras.sizeBuff[-ras.numTurns--];
    3022. 

  3022.       y_height = (Short)( y_change - y );
    3023. 

  3023. 

  3024.       while ( y < y_change )
    3025. 

  3025.       {
    3026. 

  3026.         /* let's trace */
    3027. 

  3027. 

  3028.         dropouts = 0;
    3029. 

  3029. 

  3030.         P_Left  = draw_left;
    3031. 

  3031.         P_Right = draw_right;
    3032. 

  3032. 

  3033.         while ( P_Left )
    3034. 

  3034.         {
    3035. 

  3035.           x1 = P_Left ->X;
    3036. 

  3036.           x2 = P_Right->X;
    3037. 

  3037. 

  3038.           if ( x1 > x2 )
    3039. 

  3039.           {
    3040. 

  3040.             xs = x1;
    3041. 

  3041.             x1 = x2;
    3042. 

  3042.             x2 = xs;
    3043. 

  3043.           }
    3044. 

  3044. 

  3045.           e1 = FLOOR( x1 );
    3046. 

  3046.           e2 = CEILING( x2 );
    3047. 

  3047. 

  3048.           if ( x2 - x1 <= ras.precision &&
    3049. 

  3049.                e1 != x1 && e2 != x2     )
    3050. 

  3050.           {
    3051. 

  3051.             if ( e1 > e2 || e2 == e1 + ras.precision )
    3052. 

  3052.             {
    3053. 

  3053.               Int  dropOutControl = P_Left->flags & 7;
    3054. 

  3054. 

  3055. 

  3056.               if ( dropOutControl != 2 )
    3057. 

  3057.               {
    3058. 

  3058.                 /* a drop-out was detected */
    3059. 

  3059. 

  3060.                 P_Left ->X = x1;
    3061. 

  3061.                 P_Right->X = x2;
    3062. 

  3062. 

  3063.                 /* mark profile for drop-out processing */
    3064. 

  3064.                 P_Left->countL = 1;
    3065. 

  3065.                 dropouts++;
    3066. 

  3066.               }
    3067. 

  3067. 

  3068.               goto Skip_To_Next;
    3069. 

  3069.             }
    3070. 

  3070.           }
    3071. 

  3071. 

  3072.           ras.Proc_Sweep_Span( RAS_VARS y, x1, x2, P_Left, P_Right );
    3073. 

  3073. 

  3074.         Skip_To_Next:
    3075. 

  3075. 

  3076.           P_Left  = P_Left->link;
    3077. 

  3077.           P_Right = P_Right->link;
    3078. 

  3078.         }
    3079. 

  3079. 

  3080.         /* handle drop-outs _after_ the span drawing --       */
    3081. 

  3081.         /* drop-out processing has been moved out of the loop */
    3082. 

  3082.         /* for performance tuning                             */
    3083. 

  3083.         if ( dropouts > 0 )
    3084. 

  3084.           goto Scan_DropOuts;
    3085. 

  3085. 

  3086.       Next_Line:
    3087. 

  3087. 

  3088.         ras.Proc_Sweep_Step( RAS_VAR );
    3089. 

  3089. 

  3090.         y++;
    3091. 

  3091. 

  3092.         if ( y < y_change )
    3093. 

  3093.         {
    3094. 

  3094.           Sort( &draw_left  );
    3095. 

  3095.           Sort( &draw_right );
    3096. 

  3096.         }
    3097. 

  3097.       }
    3098. 

  3098. 

  3099.       /* now finalize the profiles that need it */
    3100. 

  3100. 

  3101.       P = draw_left;
    3102. 

  3102.       while ( P )
    3103. 

  3103.       {
    3104. 

  3104.         Q = P->link;
    3105. 

  3105.         if ( P->height == 0 )
    3106. 

  3106.           DelOld( &draw_left, P );
    3107. 

  3107.         P = Q;
    3108. 

  3108.       }
    3109. 

  3109. 

  3110.       P = draw_right;
    3111. 

  3111.       while ( P )
    3112. 

  3112.       {
    3113. 

  3113.         Q = P->link;
    3114. 

  3114.         if ( P->height == 0 )
    3115. 

  3115.           DelOld( &draw_right, P );
    3116. 

  3116.         P = Q;
    3117. 

  3117.       }
    3118. 

  3118.     }
    3119. 

  3119. 

  3120.     /* for gray-scaling, flush the bitmap scanline cache */
    3121. 

  3121.     while ( y <= max_Y )
    3122. 

  3122.     {
    3123. 

  3123.       ras.Proc_Sweep_Step( RAS_VAR );
    3124. 

  3124.       y++;
    3125. 

  3125.     }
    3126. 

  3126. 

  3127.     return SUCCESS;
    3128. 

  3128. 

  3129.   Scan_DropOuts:
    3130. 

  3130. 

  3131.     P_Left  = draw_left;
    3132. 

  3132.     P_Right = draw_right;
    3133. 

  3133. 

  3134.     while ( P_Left )
    3135. 

  3135.     {
    3136. 

  3136.       if ( P_Left->countL )
    3137. 

  3137.       {
    3138. 

  3138.         P_Left->countL = 0;
    3139. 

  3139. #if 0
    3140. 

  3140.         dropouts--;  /* -- this is useful when debugging only */
    3141. 

  3141. #endif
    3142. 

  3142.         ras.Proc_Sweep_Drop( RAS_VARS y,
    3143. 

  3143.                                       P_Left->X,
    3144. 

  3144.                                       P_Right->X,
    3145. 

  3145.                                       P_Left,
    3146. 

  3146.                                       P_Right );
    3147. 

  3147.       }
    3148. 

  3148. 

  3149.       P_Left  = P_Left->link;
    3150. 

  3150.       P_Right = P_Right->link;
    3151. 

  3151.     }
    3152. 

  3152. 

  3153.     goto Next_Line;
    3154. 

  3154.   }
    3155. 

  3155. 

  3156. 

  3157.   /*************************************************************************/
    3158. 

  3158.   /*                                                                       */
    3159. 

  3159.   /* <Function>                                                            */
    3160. 

  3160.   /*    Render_Single_Pass                                                 */
    3161. 

  3161.   /*                                                                       */
    3162. 

  3162.   /* <Description>                                                         */
    3163. 

  3163.   /*    Perform one sweep with sub-banding.                                */
    3164. 

  3164.   /*                                                                       */
    3165. 

  3165.   /* <Input>                                                               */
    3166. 

  3166.   /*    flipped :: If set, flip the direction of the outline.              */
    3167. 

  3167.   /*                                                                       */
    3168. 

  3168.   /* <Return>                                                              */
    3169. 

  3169.   /*    Renderer error code.                                               */
    3170. 

  3170.   /*                                                                       */
    3171. 

  3171.   static int
    3172. 

  3172.   Render_Single_Pass( RAS_ARGS Bool  flipped )
    3173. 

  3173.   {
    3174. 

  3174.     Short  i, j, k;
    3175. 

  3175. 

  3176. 

  3177.     while ( ras.band_top >= 0 )
    3178. 

  3178.     {
    3179. 

  3179.       ras.maxY = (Long)ras.band_stack[ras.band_top].y_max * ras.precision;
    3180. 

  3180.       ras.minY = (Long)ras.band_stack[ras.band_top].y_min * ras.precision;
    3181. 

  3181. 

  3182.       ras.top = ras.buff;
    3183. 

  3183. 

  3184.       ras.error = Raster_Err_None;
    3185. 

  3185. 

  3186.       if ( Convert_Glyph( RAS_VARS flipped ) )
    3187. 

  3187.       {
    3188. 

  3188.         if ( ras.error != Raster_Err_Overflow )
    3189. 

  3189.           return FAILURE;
    3190. 

  3190. 

  3191.         ras.error = Raster_Err_None;
    3192. 

  3192. 

  3193.         /* sub-banding */
    3194. 

  3194. 

  3195. #ifdef DEBUG_RASTER
    3196. 

  3196.         ClearBand( RAS_VARS TRUNC( ras.minY ), TRUNC( ras.maxY ) );
    3197. 

  3197. #endif
    3198. 

  3198. 

  3199.         i = ras.band_stack[ras.band_top].y_min;
    3200. 

  3200.         j = ras.band_stack[ras.band_top].y_max;
    3201. 

  3201. 

  3202.         k = (Short)( ( i + j ) / 2 );
    3203. 

  3203. 

  3204.         if ( ras.band_top >= 7 || k < i )
    3205. 

  3205.         {
    3206. 

  3206.           ras.band_top = 0;
    3207. 

  3207.           ras.error    = Raster_Err_Invalid;
    3208. 

  3208. 

  3209.           return ras.error;
    3210. 

  3210.         }
    3211. 

  3211. 

  3212.         ras.band_stack[ras.band_top + 1].y_min = k;
    3213. 

  3213.         ras.band_stack[ras.band_top + 1].y_max = j;
    3214. 

  3214. 

  3215.         ras.band_stack[ras.band_top].y_max = (Short)( k - 1 );
    3216. 

  3216. 

  3217.         ras.band_top++;
    3218. 

  3218.       }
    3219. 

  3219.       else
    3220. 

  3220.       {
    3221. 

  3221.         if ( ras.fProfile )
    3222. 

  3222.           if ( Draw_Sweep( RAS_VAR ) )
    3223. 

  3223.              return ras.error;
    3224. 

  3224.         ras.band_top--;
    3225. 

  3225.       }
    3226. 

  3226.     }
    3227. 

  3227. 

  3228.     return SUCCESS;
    3229. 

  3229.   }
    3230. 

  3230. 

  3231. 

  3232.   /*************************************************************************/
    3233. 

  3233.   /*                                                                       */
    3234. 

  3234.   /* <Function>                                                            */
    3235. 

  3235.   /*    Render_Glyph                                                       */
    3236. 

  3236.   /*                                                                       */
    3237. 

  3237.   /* <Description>                                                         */
    3238. 

  3238.   /*    Render a glyph in a bitmap.  Sub-banding if needed.                */
    3239. 

  3239.   /*                                                                       */
    3240. 

  3240.   /* <Return>                                                              */
    3241. 

  3241.   /*    FreeType error code.  0 means success.                             */
    3242. 

  3242.   /*                                                                       */
    3243. 

  3243.   FT_LOCAL_DEF( FT_Error )
    3244. 

  3244.   Render_Glyph( RAS_ARG )
    3245. 

  3245.   {
    3246. 

  3246.     FT_Error  error;
    3247. 

  3247. 

  3248. 

  3249.     Set_High_Precision( RAS_VARS ras.outline.flags &
    3250. 

  3250.                                  FT_OUTLINE_HIGH_PRECISION );
    3251. 

  3251.     ras.scale_shift = ras.precision_shift;
    3252. 

  3252. 

  3253.     if ( ras.outline.flags & FT_OUTLINE_IGNORE_DROPOUTS )
    3254. 

  3254.       ras.dropOutControl = 2;
    3255. 

  3255.     else
    3256. 

  3256.     {
    3257. 

  3257.       if ( ras.outline.flags & FT_OUTLINE_SMART_DROPOUTS )
    3258. 

  3258.         ras.dropOutControl = 4;
    3259. 

  3259.       else
    3260. 

  3260.         ras.dropOutControl = 0;
    3261. 

  3261. 

  3262.       if ( !( ras.outline.flags & FT_OUTLINE_INCLUDE_STUBS ) )
    3263. 

  3263.         ras.dropOutControl += 1;
    3264. 

  3264.     }
    3265. 

  3265. 

  3266.     ras.second_pass = (FT_Byte)( !( ras.outline.flags &
    3267. 

  3267.                                     FT_OUTLINE_SINGLE_PASS ) );
    3268. 

  3268. 

  3269.     /* Vertical Sweep */
    3270. 

  3270.     ras.Proc_Sweep_Init = Vertical_Sweep_Init;
    3271. 

  3271.     ras.Proc_Sweep_Span = Vertical_Sweep_Span;
    3272. 

  3272.     ras.Proc_Sweep_Drop = Vertical_Sweep_Drop;
    3273. 

  3273.     ras.Proc_Sweep_Step = Vertical_Sweep_Step;
    3274. 

  3274. 

  3275.     ras.band_top            = 0;
    3276. 

  3276.     ras.band_stack[0].y_min = 0;
    3277. 

  3277.     ras.band_stack[0].y_max = (short)( ras.target.rows - 1 );
    3278. 

  3278. 

  3279.     ras.bWidth  = (unsigned short)ras.target.width;
    3280. 

  3280.     ras.bTarget = (Byte*)ras.target.buffer;
    3281. 

  3281. 

  3282.     if ( ( error = Render_Single_Pass( RAS_VARS 0 ) ) != 0 )
    3283. 

  3283.       return error;
    3284. 

  3284. 

  3285.     /* Horizontal Sweep */
    3286. 

  3286.     if ( ras.second_pass && ras.dropOutControl != 2 )
    3287. 

  3287.     {
    3288. 

  3288.       ras.Proc_Sweep_Init = Horizontal_Sweep_Init;
    3289. 

  3289.       ras.Proc_Sweep_Span = Horizontal_Sweep_Span;
    3290. 

  3290.       ras.Proc_Sweep_Drop = Horizontal_Sweep_Drop;
    3291. 

  3291.       ras.Proc_Sweep_Step = Horizontal_Sweep_Step;
    3292. 

  3292. 

  3293.       ras.band_top            = 0;
    3294. 

  3294.       ras.band_stack[0].y_min = 0;
    3295. 

  3295.       ras.band_stack[0].y_max = (short)( ras.target.width - 1 );
    3296. 

  3296. 

  3297.       if ( ( error = Render_Single_Pass( RAS_VARS 1 ) ) != 0 )
    3298. 

  3298.         return error;
    3299. 

  3299.     }
    3300. 

  3300. 

  3301.     return Raster_Err_None;
    3302. 

  3302.   }
    3303. 

  3303. 

  3304. 

  3305. #ifdef FT_RASTER_OPTION_ANTI_ALIASING
    3306. 

  3306. 

  3307.   /*************************************************************************/
    3308. 

  3308.   /*                                                                       */
    3309. 

  3309.   /* <Function>                                                            */
    3310. 

  3310.   /*    Render_Gray_Glyph                                                  */
    3311. 

  3311.   /*                                                                       */
    3312. 

  3312.   /* <Description>                                                         */
    3313. 

  3313.   /*    Render a glyph with grayscaling.  Sub-banding if needed.           */
    3314. 

  3314.   /*                                                                       */
    3315. 

  3315.   /* <Return>                                                              */
    3316. 

  3316.   /*    FreeType error code.  0 means success.                             */
    3317. 

  3317.   /*                                                                       */
    3318. 

  3318.   FT_LOCAL_DEF( FT_Error )
    3319. 

  3319.   Render_Gray_Glyph( RAS_ARG )
    3320. 

  3320.   {
    3321. 

  3321.     Long      pixel_width;
    3322. 

  3322.     FT_Error  error;
    3323. 

  3323. 

  3324. 

  3325.     Set_High_Precision( RAS_VARS ras.outline.flags &
    3326. 

  3326.                                  FT_OUTLINE_HIGH_PRECISION );
    3327. 

  3327.     ras.scale_shift = ras.precision_shift + 1;
    3328. 

  3328. 

  3329.     if ( ras.outline.flags & FT_OUTLINE_IGNORE_DROPOUTS )
    3330. 

  3330.       ras.dropOutControl = 2;
    3331. 

  3331.     else
    3332. 

  3332.     {
    3333. 

  3333.       if ( ras.outline.flags & FT_OUTLINE_SMART_DROPOUTS )
    3334. 

  3334.         ras.dropOutControl = 4;
    3335. 

  3335.       else
    3336. 

  3336.         ras.dropOutControl = 0;
    3337. 

  3337. 

  3338.       if ( !( ras.outline.flags & FT_OUTLINE_INCLUDE_STUBS ) )
    3339. 

  3339.         ras.dropOutControl += 1;
    3340. 

  3340.     }
    3341. 

  3341. 

  3342.     ras.second_pass = !( ras.outline.flags & FT_OUTLINE_SINGLE_PASS );
    3343. 

  3343. 

  3344.     /* Vertical Sweep */
    3345. 

  3345. 

  3346.     ras.band_top            = 0;
    3347. 

  3347.     ras.band_stack[0].y_min = 0;
    3348. 

  3348.     ras.band_stack[0].y_max = 2 * ras.target.rows - 1;
    3349. 

  3349. 

  3350.     ras.bWidth  = ras.gray_width;
    3351. 

  3351.     pixel_width = 2 * ( ( ras.target.width + 3 ) >> 2 );
    3352. 

  3352. 

  3353.     if ( ras.bWidth > pixel_width )
    3354. 

  3354.       ras.bWidth = pixel_width;
    3355. 

  3355. 

  3356.     ras.bWidth  = ras.bWidth * 8;
    3357. 

  3357.     ras.bTarget = (Byte*)ras.gray_lines;
    3358. 

  3358.     ras.gTarget = (Byte*)ras.target.buffer;
    3359. 

  3359. 

  3360.     ras.Proc_Sweep_Init = Vertical_Gray_Sweep_Init;
    3361. 

  3361.     ras.Proc_Sweep_Span = Vertical_Sweep_Span;
    3362. 

  3362.     ras.Proc_Sweep_Drop = Vertical_Sweep_Drop;
    3363. 

  3363.     ras.Proc_Sweep_Step = Vertical_Gray_Sweep_Step;
    3364. 

  3364. 

  3365.     error = Render_Single_Pass( RAS_VARS 0 );
    3366. 

  3366.     if ( error )
    3367. 

  3367.       return error;
    3368. 

  3368. 

  3369.     /* Horizontal Sweep */
    3370. 

  3370.     if ( ras.second_pass && ras.dropOutControl != 2 )
    3371. 

  3371.     {
    3372. 

  3372.       ras.Proc_Sweep_Init = Horizontal_Sweep_Init;
    3373. 

  3373.       ras.Proc_Sweep_Span = Horizontal_Gray_Sweep_Span;
    3374. 

  3374.       ras.Proc_Sweep_Drop = Horizontal_Gray_Sweep_Drop;
    3375. 

  3375.       ras.Proc_Sweep_Step = Horizontal_Sweep_Step;
    3376. 

  3376. 

  3377.       ras.band_top            = 0;
    3378. 

  3378.       ras.band_stack[0].y_min = 0;
    3379. 

  3379.       ras.band_stack[0].y_max = ras.target.width * 2 - 1;
    3380. 

  3380. 

  3381.       error = Render_Single_Pass( RAS_VARS 1 );
    3382. 

  3382.       if ( error )
    3383. 

  3383.         return error;
    3384. 

  3384.     }
    3385. 

  3385. 

  3386.     return Raster_Err_None;
    3387. 

  3387.   }
    3388. 

  3388. 

  3389. #else /* !FT_RASTER_OPTION_ANTI_ALIASING */
    3390. 

  3390. 

  3391.   FT_LOCAL_DEF( FT_Error )
    3392. 

  3392.   Render_Gray_Glyph( RAS_ARG )
    3393. 

  3393.   {
    3394. 

  3394.     FT_UNUSED_RASTER;
    3395. 

  3395. 

  3396.     return Raster_Err_Unsupported;
    3397. 

  3397.   }
    3398. 

  3398. 

  3399. #endif /* !FT_RASTER_OPTION_ANTI_ALIASING */
    3400. 

  3400. 

  3401. 

  3402.   static void
    3403. 

  3403.   ft_black_init( black_PRaster  raster )
    3404. 

  3404.   {
    3405. 

  3405. #ifdef FT_RASTER_OPTION_ANTI_ALIASING
    3406. 

  3406.     FT_UInt  n;
    3407. 

  3407. 

  3408. 

  3409.     /* set default 5-levels gray palette */
    3410. 

  3410.     for ( n = 0; n < 5; n++ )
    3411. 

  3411.       raster->grays[n] = n * 255 / 4;
    3412. 

  3412. 

  3413.     raster->gray_width = RASTER_GRAY_LINES / 2;
    3414. 

  3414. #else
    3415. 

  3415.     FT_UNUSED( raster );
    3416. 

  3416. #endif
    3417. 

  3417.   }
    3418. 

  3418. 

  3419. 

  3420.   /**** RASTER OBJECT CREATION: In standalone mode, we simply use *****/
    3421. 

  3421.   /****                         a static object.                  *****/
    3422. 

  3422. 

  3423. 

  3424. #ifdef _STANDALONE_
    3425. 

  3425. 

  3426. 

  3427.   static int
    3428. 

  3428.   ft_black_new( void*       memory,
    3429. 

  3429.                 FT_Raster  *araster )
    3430. 

  3430.   {
    3431. 

  3431.      static black_TRaster  the_raster;
    3432. 

  3432.      FT_UNUSED( memory );
    3433. 

  3433. 

  3434. 

  3435.      *araster = (FT_Raster)&the_raster;
    3436. 

  3436.      FT_MEM_ZERO( &the_raster, sizeof ( the_raster ) );
    3437. 

  3437.      ft_black_init( &the_raster );
    3438. 

  3438. 

  3439.      return 0;
    3440. 

  3440.   }
    3441. 

  3441. 

  3442. 

  3443.   static void
    3444. 

  3444.   ft_black_done( FT_Raster  raster )
    3445. 

  3445.   {
    3446. 

  3446.     /* nothing */
    3447. 

  3447.     FT_UNUSED( raster );
    3448. 

  3448.   }
    3449. 

  3449. 

  3450. 

  3451. #else /* !_STANDALONE_ */
    3452. 

  3452. 

  3453. 

  3454.   static int
    3455. 

  3455.   ft_black_new( FT_Memory       memory,
    3456. 

  3456.                 black_PRaster  *araster )
    3457. 

  3457.   {
    3458. 

  3458.     FT_Error       error;
    3459. 

  3459.     black_PRaster  raster = NULL;
    3460. 

  3460. 

  3461. 

  3462.     *araster = 0;
    3463. 

  3463.     if ( !FT_NEW( raster ) )
    3464. 

  3464.     {
    3465. 

  3465.       raster->memory = memory;
    3466. 

  3466.       ft_black_init( raster );
    3467. 

  3467. 

  3468.       *araster = raster;
    3469. 

  3469.     }
    3470. 

  3470. 

  3471.     return error;
    3472. 

  3472.   }
    3473. 

  3473. 

  3474. 

  3475.   static void
    3476. 

  3476.   ft_black_done( black_PRaster  raster )
    3477. 

  3477.   {
    3478. 

  3478.     FT_Memory  memory = (FT_Memory)raster->memory;
    3479. 

  3479. 

  3480. 

  3481.     FT_FREE( raster );
    3482. 

  3482.   }
    3483. 

  3483. 

  3484. 

  3485. #endif /* !_STANDALONE_ */
    3486. 

  3486. 

  3487. 

  3488.   static void
    3489. 

  3489.   ft_black_reset( black_PRaster  raster,
    3490. 

  3490.                   char*          pool_base,
    3491. 

  3491.                   long           pool_size )
    3492. 

  3492.   {
    3493. 

  3493.     if ( raster )
    3494. 

  3494.     {
    3495. 

  3495.       if ( pool_base && pool_size >= (long)sizeof ( black_TWorker ) + 2048 )
    3496. 

  3496.       {
    3497. 

  3497.         black_PWorker  worker = (black_PWorker)pool_base;
    3498. 

  3498. 

  3499. 

  3500.         raster->buffer      = pool_base + ( ( sizeof ( *worker ) + 7 ) & ~7 );
    3501. 

  3501.         raster->buffer_size = pool_base + pool_size - (char*)raster->buffer;
    3502. 

  3502.         raster->worker      = worker;
    3503. 

  3503.       }
    3504. 

  3504.       else
    3505. 

  3505.       {
    3506. 

  3506.         raster->buffer      = NULL;
    3507. 

  3507.         raster->buffer_size = 0;
    3508. 

  3508.         raster->worker      = NULL;
    3509. 

  3509.       }
    3510. 

  3510.     }
    3511. 

  3511.   }
    3512. 

  3512. 

  3513. 

  3514.   static void
    3515. 

  3515.   ft_black_set_mode( black_PRaster  raster,
    3516. 

  3516.                      unsigned long  mode,
    3517. 

  3517.                      const char*    palette )
    3518. 

  3518.   {
    3519. 

  3519. #ifdef FT_RASTER_OPTION_ANTI_ALIASING
    3520. 

  3520. 

  3521.     if ( mode == FT_MAKE_TAG( 'p', 'a', 'l', '5' ) )
    3522. 

  3522.     {
    3523. 

  3523.       /* set 5-levels gray palette */
    3524. 

  3524.       raster->grays[0] = palette[0];
    3525. 

  3525.       raster->grays[1] = palette[1];
    3526. 

  3526.       raster->grays[2] = palette[2];
    3527. 

  3527.       raster->grays[3] = palette[3];
    3528. 

  3528.       raster->grays[4] = palette[4];
    3529. 

  3529.     }
    3530. 

  3530. 

  3531. #else
    3532. 

  3532. 

  3533.     FT_UNUSED( raster );
    3534. 

  3534.     FT_UNUSED( mode );
    3535. 

  3535.     FT_UNUSED( palette );
    3536. 

  3536. 

  3537. #endif
    3538. 

  3538.   }
    3539. 

  3539. 

  3540. 

  3541.   static int
    3542. 

  3542.   ft_black_render( black_PRaster            raster,
    3543. 

  3543.                    const FT_Raster_Params*  params )
    3544. 

  3544.   {
    3545. 

  3545.     const FT_Outline*  outline    = (const FT_Outline*)params->source;
    3546. 

  3546.     const FT_Bitmap*   target_map = params->target;
    3547. 

  3547.     black_PWorker      worker;
    3548. 

  3548. 

  3549. 

  3550.     if ( !raster || !raster->buffer || !raster->buffer_size )
    3551. 

  3551.       return Raster_Err_Not_Ini;
    3552. 

  3552. 

  3553.     if ( !outline )
    3554. 

  3554.       return Raster_Err_Invalid;
    3555. 

  3555. 

  3556.     /* return immediately if the outline is empty */
    3557. 

  3557.     if ( outline->n_points == 0 || outline->n_contours <= 0 )
    3558. 

  3558.       return Raster_Err_None;
    3559. 

  3559. 

  3560.     if ( !outline->contours || !outline->points )
    3561. 

  3561.       return Raster_Err_Invalid;
    3562. 

  3562. 

  3563.     if ( outline->n_points !=
    3564. 

  3564.            outline->contours[outline->n_contours - 1] + 1 )
    3565. 

  3565.       return Raster_Err_Invalid;
    3566. 

  3566. 

  3567.     worker = raster->worker;
    3568. 

  3568. 

  3569.     /* this version of the raster does not support direct rendering, sorry */
    3570. 

  3570.     if ( params->flags & FT_RASTER_FLAG_DIRECT )
    3571. 

  3571.       return Raster_Err_Unsupported;
    3572. 

  3572. 

  3573.     if ( !target_map )
    3574. 

  3574.       return Raster_Err_Invalid;
    3575. 

  3575. 

  3576.     /* nothing to do */
    3577. 

  3577.     if ( !target_map->width || !target_map->rows )
    3578. 

  3578.       return Raster_Err_None;
    3579. 

  3579. 

  3580.     if ( !target_map->buffer )
    3581. 

  3581.       return Raster_Err_Invalid;
    3582. 

  3582. 

  3583.     ras.outline = *outline;
    3584. 

  3584.     ras.target  = *target_map;
    3585. 

  3585. 

  3586.     worker->buff       = (PLong) raster->buffer;
    3587. 

  3587.     worker->sizeBuff   = worker->buff +
    3588. 

  3588.                            raster->buffer_size / sizeof ( Long );
    3589. 

  3589. #ifdef FT_RASTER_OPTION_ANTI_ALIASING
    3590. 

  3590.     worker->grays      = raster->grays;
    3591. 

  3591.     worker->gray_width = raster->gray_width;
    3592. 

  3592. 

  3593.     FT_MEM_ZERO( worker->gray_lines, worker->gray_width * 2 );
    3594. 

  3594. #endif
    3595. 

  3595. 

  3596.     return ( params->flags & FT_RASTER_FLAG_AA )
    3597. 

  3597.            ? Render_Gray_Glyph( RAS_VAR )
    3598. 

  3598.            : Render_Glyph( RAS_VAR );
    3599. 

  3599.   }
    3600. 

  3600. 

  3601. 

  3602.   FT_DEFINE_RASTER_FUNCS( ft_standard_raster,
    3603. 

  3603.     FT_GLYPH_FORMAT_OUTLINE,
    3604. 

  3604.     (FT_Raster_New_Func)     ft_black_new,
    3605. 

  3605.     (FT_Raster_Reset_Func)   ft_black_reset,
    3606. 

  3606.     (FT_Raster_Set_Mode_Func)ft_black_set_mode,
    3607. 

  3607.     (FT_Raster_Render_Func)  ft_black_render,
    3608. 

  3608.     (FT_Raster_Done_Func)    ft_black_done
    3609. 

  3609.   )
    3610. 

  3610. 

  3611. 

  3612. /* END */
    3613. 

  3613.