source: trunk/poppler/freetype-2.2.1/src/raster/ftraster.c @ 150

Last change on this file since 150 was 150, checked in by Eugene Romanenko, 15 years ago

update freetype to 2.2.1

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