开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
ftgrays.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：54k
源码类别：

其他游戏

开发平台：

Visual C++

ftgrays.c：源码内容
  1. /***************************************************************************/
  2. /*                                                                         */
  3. /*  ftgrays.c                                                              */
  4. /*                                                                         */
  5. /*    A new `perfect' anti-aliasing renderer (body).                       */
  6. /*                                                                         */
  7. /*  Copyright 2000-2001, 2002, 2003, 2005, 2006, 2007 by                   */
  8. /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  9. /*                                                                         */
  10. /*  This file is part of the FreeType project, and may only be used,       */
  11. /*  modified, and distributed under the terms of the FreeType project      */
  12. /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13. /*  this file you indicate that you have read the license and              */
  14. /*  understand and accept it fully.                                        */
  15. /*                                                                         */
  16. /***************************************************************************/
  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 `ftgrays.h' and `ftimage.h' into the current            */
  23.   /* compilation directory.  Typically, you could do something like        */
  24.   /*                                                                       */
  25.   /* - copy `src/smooth/ftgrays.c' (this file) to your current directory   */
  26.   /*                                                                       */
  27.   /* - copy `include/freetype/ftimage.h' and `src/smooth/ftgrays.h' to the */
  28.   /*   same directory                                                      */
  29.   /*                                                                       */
  30.   /* - compile `ftgrays' with the _STANDALONE_ macro defined, as in        */
  31.   /*                                                                       */
  32.   /*     cc -c -D_STANDALONE_ ftgrays.c                                    */
  33.   /*                                                                       */
  34.   /* The renderer can be initialized with a call to                        */
  35.   /* `ft_gray_raster.raster_new'; an anti-aliased bitmap can be generated  */
  36.   /* with a call to `ft_gray_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.   /*************************************************************************/
  43.   /*************************************************************************/
  44.   /*                                                                       */
  45.   /* This is a new anti-aliasing scan-converter for FreeType 2.  The       */
  46.   /* algorithm used here is _very_ different from the one in the standard  */
  47.   /* `ftraster' module.  Actually, `ftgrays' computes the _exact_          */
  48.   /* coverage of the outline on each pixel cell.                           */
  49.   /*                                                                       */
  50.   /* It is based on ideas that I initially found in Raph Levien's          */
  51.   /* excellent LibArt graphics library (see http://www.levien.com/libart   */
  52.   /* for more information, though the web pages do not tell anything       */
  53.   /* about the renderer; you'll have to dive into the source code to       */
  54.   /* understand how it works).                                             */
  55.   /*                                                                       */
  56.   /* Note, however, that this is a _very_ different implementation         */
  57.   /* compared to Raph's.  Coverage information is stored in a very         */
  58.   /* different way, and I don't use sorted vector paths.  Also, it doesn't */
  59.   /* use floating point values.                                            */
  60.   /*                                                                       */
  61.   /* This renderer has the following advantages:                           */
  62.   /*                                                                       */
  63.   /* - It doesn't need an intermediate bitmap.  Instead, one can supply a  */
  64.   /*   callback function that will be called by the renderer to draw gray  */
  65.   /*   spans on any target surface.  You can thus do direct composition on */
  66.   /*   any kind of bitmap, provided that you give the renderer the right   */
  67.   /*   callback.                                                           */
  68.   /*                                                                       */
  69.   /* - A perfect anti-aliaser, i.e., it computes the _exact_ coverage on   */
  70.   /*   each pixel cell.                                                    */
  71.   /*                                                                       */
  72.   /* - It performs a single pass on the outline (the `standard' FT2        */
  73.   /*   renderer makes two passes).                                         */
  74.   /*                                                                       */
  75.   /* - It can easily be modified to render to _any_ number of gray levels  */
  76.   /*   cheaply.                                                            */
  77.   /*                                                                       */
  78.   /* - For small (< 20) pixel sizes, it is faster than the standard        */
  79.   /*   renderer.                                                           */
  80.   /*                                                                       */
  81.   /*************************************************************************/
  84.   /*************************************************************************/
  85.   /*                                                                       */
  86.   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  87.   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  88.   /* messages during execution.                                            */
  89.   /*                                                                       */
  90. #undef  FT_COMPONENT
  91. #define FT_COMPONENT  trace_smooth
  96. #ifdef _STANDALONE_
  98. #include <string.h>             /* for ft_memcpy() */
  99. #include <setjmp.h>
  100. #include <limits.h>
  101. #define FT_UINT_MAX  UINT_MAX
  103. #define ft_memset   memset
  105. #define ft_setjmp   setjmp
  106. #define ft_longjmp  longjmp
  107. #define ft_jmp_buf  jmp_buf
  110. #define ErrRaster_Invalid_Mode      -2
  111. #define ErrRaster_Invalid_Outline   -1
  112. #define ErrRaster_Invalid_Argument  -3
  113. #define ErrRaster_Memory_Overflow   -4
  115. #define FT_BEGIN_HEADER
  116. #define FT_END_HEADER
  118. #include "ftimage.h"
  119. #include "ftgrays.h"
  121.   /* This macro is used to indicate that a function parameter is unused. */
  122.   /* Its purpose is simply to reduce compiler warnings.  Note also that  */
  123.   /* simply defining it as `(void)x' doesn't avoid warnings with certain */
  124.   /* ANSI compilers (e.g. LCC).                                          */
  125. #define FT_UNUSED( x )  (x) = (x)
  127.   /* Disable the tracing mechanism for simplicity -- developers can      */
  128.   /* activate it easily by redefining these two macros.                  */
  129. #ifndef FT_ERROR
  130. #define FT_ERROR( x )  do ; while ( 0 )     /* nothing */
  131. #endif
  133. #ifndef FT_TRACE
  134. #define FT_TRACE( x )  do ; while ( 0 )     /* nothing */
  135. #endif
  137. #else /* !_STANDALONE_ */
  139. #include <ft2build.h>
  140. #include "ftgrays.h"
  141. #include FT_INTERNAL_OBJECTS_H
  142. #include FT_INTERNAL_DEBUG_H
  143. #include FT_OUTLINE_H
  145. #include "ftsmerrs.h"
  147. #define ErrRaster_Invalid_Mode     Smooth_Err_Cannot_Render_Glyph
  148. #define ErrRaster_Invalid_Outline  Smooth_Err_Invalid_Outline
  149. #define ErrRaster_Memory_Overflow  Smooth_Err_Out_Of_Memory
  150. #define ErrRaster_Invalid_Argument Smooth_Err_Bad_Argument
  152. #endif /* !_STANDALONE_ */
  155. #ifndef FT_MEM_SET
  156. #define FT_MEM_SET( d, s, c )  ft_memset( d, s, c )
  157. #endif
  159. #ifndef FT_MEM_ZERO
  160. #define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
  161. #endif
  163.   /* define this to dump debugging information */
  164. #define xxxDEBUG_GRAYS
  167.   /* as usual, for the speed hungry :-) */
  169. #ifndef FT_STATIC_RASTER
  172. #define RAS_ARG   PWorker  worker
  173. #define RAS_ARG_  PWorker  worker,
  175. #define RAS_VAR   worker
  176. #define RAS_VAR_  worker,
  178. #define ras       (*worker)
  181. #else /* FT_STATIC_RASTER */
  184. #define RAS_ARG   /* empty */
  185. #define RAS_ARG_  /* empty */
  186. #define RAS_VAR   /* empty */
  187. #define RAS_VAR_  /* empty */
  189.   static TWorker  ras;
  192. #endif /* FT_STATIC_RASTER */
  195.   /* must be at least 6 bits! */
  196. #define PIXEL_BITS  8
  198. #define ONE_PIXEL       ( 1L << PIXEL_BITS )
  199. #define PIXEL_MASK      ( -1L << PIXEL_BITS )
  200. #define TRUNC( x )      ( (TCoord)( (x) >> PIXEL_BITS ) )
  201. #define SUBPIXELS( x )  ( (TPos)(x) << PIXEL_BITS )
  202. #define FLOOR( x )      ( (x) & -ONE_PIXEL )
  203. #define CEILING( x )    ( ( (x) + ONE_PIXEL - 1 ) & -ONE_PIXEL )
  204. #define ROUND( x )      ( ( (x) + ONE_PIXEL / 2 ) & -ONE_PIXEL )
  206. #if PIXEL_BITS >= 6
  207. #define UPSCALE( x )    ( (x) << ( PIXEL_BITS - 6 ) )
  208. #define DOWNSCALE( x )  ( (x) >> ( PIXEL_BITS - 6 ) )
  209. #else
  210. #define UPSCALE( x )    ( (x) >> ( 6 - PIXEL_BITS ) )
  211. #define DOWNSCALE( x )  ( (x) << ( 6 - PIXEL_BITS ) )
  212. #endif
  215.   /*************************************************************************/
  216.   /*                                                                       */
  217.   /*   TYPE DEFINITIONS                                                    */
  218.   /*                                                                       */
  220.   /* don't change the following types to FT_Int or FT_Pos, since we might */
  221.   /* need to define them to "float" or "double" when experimenting with   */
  222.   /* new algorithms                                                       */
  224.   typedef int   TCoord;   /* integer scanline/pixel coordinate */
  225.   typedef long  TPos;     /* sub-pixel coordinate              */
  227.   /* determine the type used to store cell areas.  This normally takes at */
  228.   /* least PIXEL_BITS*2 + 1 bits.  On 16-bit systems, we need to use      */
  229.   /* `long' instead of `int', otherwise bad things happen                 */
  231. #if PIXEL_BITS <= 7
  233.   typedef int  TArea;
  235. #else /* PIXEL_BITS >= 8 */
  237.   /* approximately determine the size of integers using an ANSI-C header */
  238. #if FT_UINT_MAX == 0xFFFFU
  239.   typedef long  TArea;
  240. #else
  241.   typedef int   TArea;
  242. #endif
  244. #endif /* PIXEL_BITS >= 8 */
  247.   /* maximal number of gray spans in a call to the span callback */
  248. #define FT_MAX_GRAY_SPANS  32
  251.   typedef struct TCell_*  PCell;
  253.   typedef struct  TCell_
  254.   {
  255.     int    x;
  256.     int    cover;
  257.     TArea  area;
  258.     PCell  next;
  260.   } TCell;
  263.   typedef struct  TWorker_
  264.   {
  265.     TCoord  ex, ey;
  266.     TPos    min_ex, max_ex;
  267.     TPos    min_ey, max_ey;
  268.     TPos    count_ex, count_ey;
  270.     TArea   area;
  271.     int     cover;
  272.     int     invalid;
  274.     PCell   cells;
  275.     int     max_cells;
  276.     int     num_cells;
  278.     TCoord  cx, cy;
  279.     TPos    x,  y;
  281.     TPos    last_ey;
  283.     FT_Vector   bez_stack[32 * 3 + 1];
  284.     int         lev_stack[32];
  286.     FT_Outline  outline;
  287.     FT_Bitmap   target;
  288.     FT_BBox     clip_box;
  290.     FT_Span     gray_spans[FT_MAX_GRAY_SPANS];
  291.     int         num_gray_spans;
  293.     FT_Raster_Span_Func  render_span;
  294.     void*                render_span_data;
  295.     int                  span_y;
  297.     int  band_size;
  298.     int  band_shoot;
  299.     int  conic_level;
  300.     int  cubic_level;
  302.     ft_jmp_buf  jump_buffer;
  304.     void*       buffer;
  305.     long        buffer_size;
  307.     PCell*     ycells;
  308.     int        ycount;
  310.   } TWorker, *PWorker;
  313.   typedef struct TRaster_
  314.   {
  315.     void*    buffer;
  316.     long     buffer_size;
  317.     int      band_size;
  318.     void*    memory;
  319.     PWorker  worker;
  321.   } TRaster, *PRaster;
  325.   /*************************************************************************/
  326.   /*                                                                       */
  327.   /* Initialize the cells table.                                           */
  328.   /*                                                                       */
  329.   static void
  330.   gray_init_cells( RAS_ARG_ void*  buffer,
  331.                    long            byte_size )
  332.   {
  333.     ras.buffer      = buffer;
  334.     ras.buffer_size = byte_size;
  336.     ras.ycells      = (PCell*) buffer;
  337.     ras.cells       = NULL;
  338.     ras.max_cells   = 0;
  339.     ras.num_cells   = 0;
  340.     ras.area        = 0;
  341.     ras.cover       = 0;
  342.     ras.invalid     = 1;
  343.   }
  346.   /*************************************************************************/
  347.   /*                                                                       */
  348.   /* Compute the outline bounding box.                                     */
  349.   /*                                                                       */
  350.   static void
  351.   gray_compute_cbox( RAS_ARG )
  352.   {
  353.     FT_Outline*  outline = &ras.outline;
  354.     FT_Vector*   vec     = outline->points;
  355.     FT_Vector*   limit   = vec + outline->n_points;
  358.     if ( outline->n_points <= 0 )
  359.     {
  360.       ras.min_ex = ras.max_ex = 0;
  361.       ras.min_ey = ras.max_ey = 0;
  362.       return;
  363.     }
  365.     ras.min_ex = ras.max_ex = vec->x;
  366.     ras.min_ey = ras.max_ey = vec->y;
  368.     vec++;
  370.     for ( ; vec < limit; vec++ )
  371.     {
  372.       TPos  x = vec->x;
  373.       TPos  y = vec->y;
  376.       if ( x < ras.min_ex ) ras.min_ex = x;
  377.       if ( x > ras.max_ex ) ras.max_ex = x;
  378.       if ( y < ras.min_ey ) ras.min_ey = y;
  379.       if ( y > ras.max_ey ) ras.max_ey = y;
  380.     }
  382.     /* truncate the bounding box to integer pixels */
  383.     ras.min_ex = ras.min_ex >> 6;
  384.     ras.min_ey = ras.min_ey >> 6;
  385.     ras.max_ex = ( ras.max_ex + 63 ) >> 6;
  386.     ras.max_ey = ( ras.max_ey + 63 ) >> 6;
  387.   }
  390.   /*************************************************************************/
  391.   /*                                                                       */
  392.   /* Record the current cell in the table.                                 */
  393.   /*                                                                       */
  394.   static PCell
  395.   gray_find_cell( RAS_ARG )
  396.   {
  397.     PCell  *pcell, cell;
  398.     int     x = ras.ex;
  401.     if ( x > ras.max_ex )
  402.       x = ras.max_ex;
  404.     pcell = &ras.ycells[ras.ey];
  405.     for (;;)
  406.     {
  407.       cell = *pcell;
  408.       if ( cell == NULL || cell->x > x )
  409.         break;
  411.       if ( cell->x == x )
  412.         goto Exit;
  414.       pcell = &cell->next;
  415.     }
  417.     if ( ras.num_cells >= ras.max_cells )
  418.       ft_longjmp( ras.jump_buffer, 1 );
  420.     cell        = ras.cells + ras.num_cells++;
  421.     cell->x     = x;
  422.     cell->area  = 0;
  423.     cell->cover = 0;
  425.     cell->next  = *pcell;
  426.     *pcell      = cell;
  428.   Exit:
  429.     return cell;
  430.   }
  433.   static void
  434.   gray_record_cell( RAS_ARG )
  435.   {
  436.     if ( !ras.invalid && ( ras.area | ras.cover ) )
  437.     {
  438.       PCell  cell = gray_find_cell( RAS_VAR );
  441.       cell->area  += ras.area;
  442.       cell->cover += ras.cover;
  443.     }
  444.   }
  447.   /*************************************************************************/
  448.   /*                                                                       */
  449.   /* Set the current cell to a new position.                               */
  450.   /*                                                                       */
  451.   static void
  452.   gray_set_cell( RAS_ARG_ TCoord  ex,
  453.                           TCoord  ey )
  454.   {
  455.     /* Move the cell pointer to a new position.  We set the `invalid'      */
  456.     /* flag to indicate that the cell isn't part of those we're interested */
  457.     /* in during the render phase.  This means that:                       */
  458.     /*                                                                     */
  459.     /* . the new vertical position must be within min_ey..max_ey-1.        */
  460.     /* . the new horizontal position must be strictly less than max_ex     */
  461.     /*                                                                     */
  462.     /* Note that if a cell is to the left of the clipping region, it is    */
  463.     /* actually set to the (min_ex-1) horizontal position.                 */
  465.     /* All cells that are on the left of the clipping region go to the */
  466.     /* min_ex - 1 horizontal position.                                 */
  467.     ey -= ras.min_ey;
  469.     if ( ex > ras.max_ex )
  470.       ex = ras.max_ex;
  472.     ex -= ras.min_ex;
  473.     if ( ex < 0 )
  474.       ex = -1;
  476.     /* are we moving to a different cell ? */
  477.     if ( ex != ras.ex || ey != ras.ey )
  478.     {
  479.       /* record the current one if it is valid */
  480.       if ( !ras.invalid )
  481.         gray_record_cell( RAS_VAR );
  483.       ras.area  = 0;
  484.       ras.cover = 0;
  485.     }
  487.     ras.ex      = ex;
  488.     ras.ey      = ey;
  489.     ras.invalid = ( (unsigned)ey >= (unsigned)ras.count_ey ||
  490.                               ex >= ras.count_ex           );
  491.   }
  494.   /*************************************************************************/
  495.   /*                                                                       */
  496.   /* Start a new contour at a given cell.                                  */
  497.   /*                                                                       */
  498.   static void
  499.   gray_start_cell( RAS_ARG_ TCoord  ex,
  500.                             TCoord  ey )
  501.   {
  502.     if ( ex > ras.max_ex )
  503.       ex = (TCoord)( ras.max_ex );
  505.     if ( ex < ras.min_ex )
  506.       ex = (TCoord)( ras.min_ex - 1 );
  508.     ras.area    = 0;
  509.     ras.cover   = 0;
  510.     ras.ex      = ex - ras.min_ex;
  511.     ras.ey      = ey - ras.min_ey;
  512.     ras.last_ey = SUBPIXELS( ey );
  513.     ras.invalid = 0;
  515.     gray_set_cell( RAS_VAR_ ex, ey );
  516.   }
  519.   /*************************************************************************/
  520.   /*                                                                       */
  521.   /* Render a scanline as one or more cells.                               */
  522.   /*                                                                       */
  523.   static void
  524.   gray_render_scanline( RAS_ARG_ TCoord  ey,
  525.                                  TPos    x1,
  526.                                  TCoord  y1,
  527.                                  TPos    x2,
  528.                                  TCoord  y2 )
  529.   {
  530.     TCoord  ex1, ex2, fx1, fx2, delta;
  531.     long    p, first, dx;
  532.     int     incr, lift, mod, rem;
  535.     dx = x2 - x1;
  537.     ex1 = TRUNC( x1 );
  538.     ex2 = TRUNC( x2 );
  539.     fx1 = (TCoord)( x1 - SUBPIXELS( ex1 ) );
  540.     fx2 = (TCoord)( x2 - SUBPIXELS( ex2 ) );
  542.     /* trivial case.  Happens often */
  543.     if ( y1 == y2 )
  544.     {
  545.       gray_set_cell( RAS_VAR_ ex2, ey );
  546.       return;
  547.     }
  549.     /* everything is located in a single cell.  That is easy! */
  550.     /*                                                        */
  551.     if ( ex1 == ex2 )
  552.     {
  553.       delta      = y2 - y1;
  554.       ras.area  += (TArea)( fx1 + fx2 ) * delta;
  555.       ras.cover += delta;
  556.       return;
  557.     }
  559.     /* ok, we'll have to render a run of adjacent cells on the same */
  560.     /* scanline...                                                  */
  561.     /*                                                              */
  562.     p     = ( ONE_PIXEL - fx1 ) * ( y2 - y1 );
  563.     first = ONE_PIXEL;
  564.     incr  = 1;
  566.     if ( dx < 0 )
  567.     {
  568.       p     = fx1 * ( y2 - y1 );
  569.       first = 0;
  570.       incr  = -1;
  571.       dx    = -dx;
  572.     }
  574.     delta = (TCoord)( p / dx );
  575.     mod   = (TCoord)( p % dx );
  576.     if ( mod < 0 )
  577.     {
  578.       delta--;
  579.       mod += (TCoord)dx;
  580.     }
  582.     ras.area  += (TArea)( fx1 + first ) * delta;
  583.     ras.cover += delta;
  585.     ex1 += incr;
  586.     gray_set_cell( RAS_VAR_ ex1, ey );
  587.     y1  += delta;
  589.     if ( ex1 != ex2 )
  590.     {
  591.       p    = ONE_PIXEL * ( y2 - y1 + delta );
  592.       lift = (TCoord)( p / dx );
  593.       rem  = (TCoord)( p % dx );
  594.       if ( rem < 0 )
  595.       {
  596.         lift--;
  597.         rem += (TCoord)dx;
  598.       }
  600.       mod -= (int)dx;
  602.       while ( ex1 != ex2 )
  603.       {
  604.         delta = lift;
  605.         mod  += rem;
  606.         if ( mod >= 0 )
  607.         {
  608.           mod -= (TCoord)dx;
  609.           delta++;
  610.         }
  612.         ras.area  += (TArea)ONE_PIXEL * delta;
  613.         ras.cover += delta;
  614.         y1        += delta;
  615.         ex1       += incr;
  616.         gray_set_cell( RAS_VAR_ ex1, ey );
  617.       }
  618.     }
  620.     delta      = y2 - y1;
  621.     ras.area  += (TArea)( fx2 + ONE_PIXEL - first ) * delta;
  622.     ras.cover += delta;
  623.   }
  626.   /*************************************************************************/
  627.   /*                                                                       */
  628.   /* Render a given line as a series of scanlines.                         */
  629.   /*                                                                       */
  630.   static void
  631.   gray_render_line( RAS_ARG_ TPos  to_x,
  632.                              TPos  to_y )
  633.   {
  634.     TCoord  ey1, ey2, fy1, fy2;
  635.     TPos    dx, dy, x, x2;
  636.     long    p, first;
  637.     int     delta, rem, mod, lift, incr;
  640.     ey1 = TRUNC( ras.last_ey );
  641.     ey2 = TRUNC( to_y );     /* if (ey2 >= ras.max_ey) ey2 = ras.max_ey-1; */
  642.     fy1 = (TCoord)( ras.y - ras.last_ey );
  643.     fy2 = (TCoord)( to_y - SUBPIXELS( ey2 ) );
  645.     dx = to_x - ras.x;
  646.     dy = to_y - ras.y;
  648.     /* XXX: we should do something about the trivial case where dx == 0, */
  649.     /*      as it happens very often!                                    */
  651.     /* perform vertical clipping */
  652.     {
  653.       TCoord  min, max;
  656.       min = ey1;
  657.       max = ey2;
  658.       if ( ey1 > ey2 )
  659.       {
  660.         min = ey2;
  661.         max = ey1;
  662.       }
  663.       if ( min >= ras.max_ey || max < ras.min_ey )
  664.         goto End;
  665.     }
  667.     /* everything is on a single scanline */
  668.     if ( ey1 == ey2 )
  669.     {
  670.       gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, to_x, fy2 );
  671.       goto End;
  672.     }
  674.     /* vertical line - avoid calling gray_render_scanline */
  675.     incr = 1;
  677.     if ( dx == 0 )
  678.     {
  679.       TCoord  ex     = TRUNC( ras.x );
  680.       TCoord  two_fx = (TCoord)( ( ras.x - SUBPIXELS( ex ) ) << 1 );
  681.       TPos    area;
  684.       first = ONE_PIXEL;
  685.       if ( dy < 0 )
  686.       {
  687.         first = 0;
  688.         incr  = -1;
  689.       }
  691.       delta      = (int)( first - fy1 );
  692.       ras.area  += (TArea)two_fx * delta;
  693.       ras.cover += delta;
  694.       ey1       += incr;
  696.       gray_set_cell( &ras, ex, ey1 );
  698.       delta = (int)( first + first - ONE_PIXEL );
  699.       area  = (TArea)two_fx * delta;
  700.       while ( ey1 != ey2 )
  701.       {
  702.         ras.area  += area;
  703.         ras.cover += delta;
  704.         ey1       += incr;
  706.         gray_set_cell( &ras, ex, ey1 );
  707.       }
  709.       delta      = (int)( fy2 - ONE_PIXEL + first );
  710.       ras.area  += (TArea)two_fx * delta;
  711.       ras.cover += delta;
  713.       goto End;
  714.     }
  716.     /* ok, we have to render several scanlines */
  717.     p     = ( ONE_PIXEL - fy1 ) * dx;
  718.     first = ONE_PIXEL;
  719.     incr  = 1;
  721.     if ( dy < 0 )
  722.     {
  723.       p     = fy1 * dx;
  724.       first = 0;
  725.       incr  = -1;
  726.       dy    = -dy;
  727.     }
  729.     delta = (int)( p / dy );
  730.     mod   = (int)( p % dy );
  731.     if ( mod < 0 )
  732.     {
  733.       delta--;
  734.       mod += (TCoord)dy;
  735.     }
  737.     x = ras.x + delta;
  738.     gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, x, (TCoord)first );
  740.     ey1 += incr;
  741.     gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
  743.     if ( ey1 != ey2 )
  744.     {
  745.       p     = ONE_PIXEL * dx;
  746.       lift  = (int)( p / dy );
  747.       rem   = (int)( p % dy );
  748.       if ( rem < 0 )
  749.       {
  750.         lift--;
  751.         rem += (int)dy;
  752.       }
  753.       mod -= (int)dy;
  755.       while ( ey1 != ey2 )
  756.       {
  757.         delta = lift;
  758.         mod  += rem;
  759.         if ( mod >= 0 )
  760.         {
  761.           mod -= (int)dy;
  762.           delta++;
  763.         }
  765.         x2 = x + delta;
  766.         gray_render_scanline( RAS_VAR_ ey1, x,
  767.                                        (TCoord)( ONE_PIXEL - first ), x2,
  768.                                        (TCoord)first );
  769.         x = x2;
  771.         ey1 += incr;
  772.         gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
  773.       }
  774.     }
  776.     gray_render_scanline( RAS_VAR_ ey1, x,
  777.                                    (TCoord)( ONE_PIXEL - first ), to_x,
  778.                                    fy2 );
  780.   End:
  781.     ras.x       = to_x;
  782.     ras.y       = to_y;
  783.     ras.last_ey = SUBPIXELS( ey2 );
  784.   }
  787.   static void
  788.   gray_split_conic( FT_Vector*  base )
  789.   {
  790.     TPos  a, b;
  793.     base[4].x = base[2].x;
  794.     b = base[1].x;
  795.     a = base[3].x = ( base[2].x + b ) / 2;
  796.     b = base[1].x = ( base[0].x + b ) / 2;
  797.     base[2].x = ( a + b ) / 2;
  799.     base[4].y = base[2].y;
  800.     b = base[1].y;
  801.     a = base[3].y = ( base[2].y + b ) / 2;
  802.     b = base[1].y = ( base[0].y + b ) / 2;
  803.     base[2].y = ( a + b ) / 2;
  804.   }
  807.   static void
  808.   gray_render_conic( RAS_ARG_ const FT_Vector*  control,
  809.                               const FT_Vector*  to )
  810.   {
  811.     TPos        dx, dy;
  812.     int         top, level;
  813.     int*        levels;
  814.     FT_Vector*  arc;
  817.     dx = DOWNSCALE( ras.x ) + to->x - ( control->x << 1 );
  818.     if ( dx < 0 )
  819.       dx = -dx;
  820.     dy = DOWNSCALE( ras.y ) + to->y - ( control->y << 1 );
  821.     if ( dy < 0 )
  822.       dy = -dy;
  823.     if ( dx < dy )
  824.       dx = dy;
  826.     level = 1;
  827.     dx = dx / ras.conic_level;
  828.     while ( dx > 0 )
  829.     {
  830.       dx >>= 2;
  831.       level++;
  832.     }
  834.     /* a shortcut to speed things up */
  835.     if ( level <= 1 )
  836.     {
  837.       /* we compute the mid-point directly in order to avoid */
  838.       /* calling gray_split_conic()                          */
  839.       TPos  to_x, to_y, mid_x, mid_y;
  842.       to_x  = UPSCALE( to->x );
  843.       to_y  = UPSCALE( to->y );
  844.       mid_x = ( ras.x + to_x + 2 * UPSCALE( control->x ) ) / 4;
  845.       mid_y = ( ras.y + to_y + 2 * UPSCALE( control->y ) ) / 4;
  847.       gray_render_line( RAS_VAR_ mid_x, mid_y );
  848.       gray_render_line( RAS_VAR_ to_x, to_y );
  850.       return;
  851.     }
  853.     arc       = ras.bez_stack;
  854.     levels    = ras.lev_stack;
  855.     top       = 0;
  856.     levels[0] = level;
  858.     arc[0].x = UPSCALE( to->x );
  859.     arc[0].y = UPSCALE( to->y );
  860.     arc[1].x = UPSCALE( control->x );
  861.     arc[1].y = UPSCALE( control->y );
  862.     arc[2].x = ras.x;
  863.     arc[2].y = ras.y;
  865.     while ( top >= 0 )
  866.     {
  867.       level = levels[top];
  868.       if ( level > 1 )
  869.       {
  870.         /* check that the arc crosses the current band */
  871.         TPos  min, max, y;
  874.         min = max = arc[0].y;
  876.         y = arc[1].y;
  877.         if ( y < min ) min = y;
  878.         if ( y > max ) max = y;
  880.         y = arc[2].y;
  881.         if ( y < min ) min = y;
  882.         if ( y > max ) max = y;
  884.         if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < ras.min_ey )
  885.           goto Draw;
  887.         gray_split_conic( arc );
  888.         arc += 2;
  889.         top++;
  890.         levels[top] = levels[top - 1] = level - 1;
  891.         continue;
  892.       }
  894.     Draw:
  895.       {
  896.         TPos  to_x, to_y, mid_x, mid_y;
  899.         to_x  = arc[0].x;
  900.         to_y  = arc[0].y;
  901.         mid_x = ( ras.x + to_x + 2 * arc[1].x ) / 4;
  902.         mid_y = ( ras.y + to_y + 2 * arc[1].y ) / 4;
  904.         gray_render_line( RAS_VAR_ mid_x, mid_y );
  905.         gray_render_line( RAS_VAR_ to_x, to_y );
  907.         top--;
  908.         arc -= 2;
  909.       }
  910.     }
  912.     return;
  913.   }
  916.   static void
  917.   gray_split_cubic( FT_Vector*  base )
  918.   {
  919.     TPos  a, b, c, d;
  922.     base[6].x = base[3].x;
  923.     c = base[1].x;
  924.     d = base[2].x;
  925.     base[1].x = a = ( base[0].x + c ) / 2;
  926.     base[5].x = b = ( base[3].x + d ) / 2;
  927.     c = ( c + d ) / 2;
  928.     base[2].x = a = ( a + c ) / 2;
  929.     base[4].x = b = ( b + c ) / 2;
  930.     base[3].x = ( a + b ) / 2;
  932.     base[6].y = base[3].y;
  933.     c = base[1].y;
  934.     d = base[2].y;
  935.     base[1].y = a = ( base[0].y + c ) / 2;
  936.     base[5].y = b = ( base[3].y + d ) / 2;
  937.     c = ( c + d ) / 2;
  938.     base[2].y = a = ( a + c ) / 2;
  939.     base[4].y = b = ( b + c ) / 2;
  940.     base[3].y = ( a + b ) / 2;
  941.   }
  944.   static void
  945.   gray_render_cubic( RAS_ARG_ const FT_Vector*  control1,
  946.                               const FT_Vector*  control2,
  947.                               const FT_Vector*  to )
  948.   {
  949.     TPos        dx, dy, da, db;
  950.     int         top, level;
  951.     int*        levels;
  952.     FT_Vector*  arc;
  955.     dx = DOWNSCALE( ras.x ) + to->x - ( control1->x << 1 );
  956.     if ( dx < 0 )
  957.       dx = -dx;
  958.     dy = DOWNSCALE( ras.y ) + to->y - ( control1->y << 1 );
  959.     if ( dy < 0 )
  960.       dy = -dy;
  961.     if ( dx < dy )
  962.       dx = dy;
  963.     da = dx;
  965.     dx = DOWNSCALE( ras.x ) + to->x - 3 * ( control1->x + control2->x );
  966.     if ( dx < 0 )
  967.       dx = -dx;
  968.     dy = DOWNSCALE( ras.y ) + to->y - 3 * ( control1->x + control2->y );
  969.     if ( dy < 0 )
  970.       dy = -dy;
  971.     if ( dx < dy )
  972.       dx = dy;
  973.     db = dx;
  975.     level = 1;
  976.     da    = da / ras.cubic_level;
  977.     db    = db / ras.conic_level;
  978.     while ( da > 0 || db > 0 )
  979.     {
  980.       da >>= 2;
  981.       db >>= 3;
  982.       level++;
  983.     }
  985.     if ( level <= 1 )
  986.     {
  987.       TPos   to_x, to_y, mid_x, mid_y;
  990.       to_x  = UPSCALE( to->x );
  991.       to_y  = UPSCALE( to->y );
  992.       mid_x = ( ras.x + to_x +
  993.                 3 * UPSCALE( control1->x + control2->x ) ) / 8;
  994.       mid_y = ( ras.y + to_y +
  995.                 3 * UPSCALE( control1->y + control2->y ) ) / 8;
  997.       gray_render_line( RAS_VAR_ mid_x, mid_y );
  998.       gray_render_line( RAS_VAR_ to_x, to_y );
  999.       return;
  1000.     }
  1002.     arc      = ras.bez_stack;
  1003.     arc[0].x = UPSCALE( to->x );
  1004.     arc[0].y = UPSCALE( to->y );
  1005.     arc[1].x = UPSCALE( control2->x );
  1006.     arc[1].y = UPSCALE( control2->y );
  1007.     arc[2].x = UPSCALE( control1->x );
  1008.     arc[2].y = UPSCALE( control1->y );
  1009.     arc[3].x = ras.x;
  1010.     arc[3].y = ras.y;
  1012.     levels    = ras.lev_stack;
  1013.     top       = 0;
  1014.     levels[0] = level;
  1016.     while ( top >= 0 )
  1017.     {
  1018.       level = levels[top];
  1019.       if ( level > 1 )
  1020.       {
  1021.         /* check that the arc crosses the current band */
  1022.         TPos  min, max, y;
  1025.         min = max = arc[0].y;
  1026.         y = arc[1].y;
  1027.         if ( y < min ) min = y;
  1028.         if ( y > max ) max = y;
  1029.         y = arc[2].y;
  1030.         if ( y < min ) min = y;
  1031.         if ( y > max ) max = y;
  1032.         y = arc[3].y;
  1033.         if ( y < min ) min = y;
  1034.         if ( y > max ) max = y;
  1035.         if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < 0 )
  1036.           goto Draw;
  1037.         gray_split_cubic( arc );
  1038.         arc += 3;
  1039.         top ++;
  1040.         levels[top] = levels[top - 1] = level - 1;
  1041.         continue;
  1042.       }
  1044.     Draw:
  1045.       {
  1046.         TPos  to_x, to_y, mid_x, mid_y;
  1049.         to_x  = arc[0].x;
  1050.         to_y  = arc[0].y;
  1051.         mid_x = ( ras.x + to_x + 3 * ( arc[1].x + arc[2].x ) ) / 8;
  1052.         mid_y = ( ras.y + to_y + 3 * ( arc[1].y + arc[2].y ) ) / 8;
  1054.         gray_render_line( RAS_VAR_ mid_x, mid_y );
  1055.         gray_render_line( RAS_VAR_ to_x, to_y );
  1056.         top --;
  1057.         arc -= 3;
  1058.       }
  1059.     }
  1061.     return;
  1062.   }
  1066.   static int
  1067.   gray_move_to( const FT_Vector*  to,
  1068.                 PWorker           worker )
  1069.   {
  1070.     TPos  x, y;
  1073.     /* record current cell, if any */
  1074.     gray_record_cell( worker );
  1076.     /* start to a new position */
  1077.     x = UPSCALE( to->x );
  1078.     y = UPSCALE( to->y );
  1080.     gray_start_cell( worker, TRUNC( x ), TRUNC( y ) );
  1082.     worker->x = x;
  1083.     worker->y = y;
  1084.     return 0;
  1085.   }
  1088.   static int
  1089.   gray_line_to( const FT_Vector*  to,
  1090.                 PWorker           worker )
  1091.   {
  1092.     gray_render_line( worker, UPSCALE( to->x ), UPSCALE( to->y ) );
  1093.     return 0;
  1094.   }
  1097.   static int
  1098.   gray_conic_to( const FT_Vector*  control,
  1099.                  const FT_Vector*  to,
  1100.                  PWorker           worker )
  1101.   {
  1102.     gray_render_conic( worker, control, to );
  1103.     return 0;
  1104.   }
  1107.   static int
  1108.   gray_cubic_to( const FT_Vector*  control1,
  1109.                  const FT_Vector*  control2,
  1110.                  const FT_Vector*  to,
  1111.                  PWorker           worker )
  1112.   {
  1113.     gray_render_cubic( worker, control1, control2, to );
  1114.     return 0;
  1115.   }
  1118.   static void
  1119.   gray_render_span( int             y,
  1120.                     int             count,
  1121.                     const FT_Span*  spans,
  1122.                     PWorker         worker )
  1123.   {
  1124.     unsigned char*  p;
  1125.     FT_Bitmap*      map = &worker->target;
  1128.     /* first of all, compute the scanline offset */
  1129.     p = (unsigned char*)map->buffer - y * map->pitch;
  1130.     if ( map->pitch >= 0 )
  1131.       p += ( map->rows - 1 ) * map->pitch;
  1133.     for ( ; count > 0; count--, spans++ )
  1134.     {
  1135.       unsigned char  coverage = spans->coverage;
  1138.       if ( coverage )
  1139.       {
  1140.         /* For small-spans it is faster to do it by ourselves than
  1141.          * calling `memset'.  This is mainly due to the cost of the
  1142.          * function call.
  1143.          */
  1144.         if ( spans->len >= 8 )
  1145.           FT_MEM_SET( p + spans->x, (unsigned char)coverage, spans->len );
  1146.         else
  1147.         {
  1148.           unsigned char*  q = p + spans->x;
  1151.           switch ( spans->len )
  1152.           {
  1153.           case 7: *q++ = (unsigned char)coverage;
  1154.           case 6: *q++ = (unsigned char)coverage;
  1155.           case 5: *q++ = (unsigned char)coverage;
  1156.           case 4: *q++ = (unsigned char)coverage;
  1157.           case 3: *q++ = (unsigned char)coverage;
  1158.           case 2: *q++ = (unsigned char)coverage;
  1159.           case 1: *q   = (unsigned char)coverage;
  1160.           default:
  1161.             ;
  1162.           }
  1163.         }
  1164.       }
  1165.     }
  1166.   }
  1169.   static void
  1170.   gray_hline( RAS_ARG_ TCoord  x,
  1171.                        TCoord  y,
  1172.                        TPos    area,
  1173.                        int     acount )
  1174.   {
  1175.     FT_Span*  span;
  1176.     int       count;
  1177.     int       coverage;
  1180.     /* compute the coverage line's coverage, depending on the    */
  1181.     /* outline fill rule                                         */
  1182.     /*                                                           */
  1183.     /* the coverage percentage is area/(PIXEL_BITS*PIXEL_BITS*2) */
  1184.     /*                                                           */
  1185.     coverage = (int)( area >> ( PIXEL_BITS * 2 + 1 - 8 ) );
  1186.                                                     /* use range 0..256 */
  1187.     if ( coverage < 0 )
  1188.       coverage = -coverage;
  1190.     if ( ras.outline.flags & FT_OUTLINE_EVEN_ODD_FILL )
  1191.     {
  1192.       coverage &= 511;
  1194.       if ( coverage > 256 )
  1195.         coverage = 512 - coverage;
  1196.       else if ( coverage == 256 )
  1197.         coverage = 255;
  1198.     }
  1199.     else
  1200.     {
  1201.       /* normal non-zero winding rule */
  1202.       if ( coverage >= 256 )
  1203.         coverage = 255;
  1204.     }
  1206.     y += (TCoord)ras.min_ey;
  1207.     x += (TCoord)ras.min_ex;
  1209.     /* FT_Span.x is a 16-bit short, so limit our coordinates appropriately */
  1210.     if ( x >= 32768 )
  1211.       x = 32767;
  1213.     if ( coverage )
  1214.     {
  1215.       /* see whether we can add this span to the current list */
  1216.       count = ras.num_gray_spans;
  1217.       span  = ras.gray_spans + count - 1;
  1218.       if ( count > 0                          &&
  1219.            ras.span_y == y                    &&
  1220.            (int)span->x + span->len == (int)x &&
  1221.            span->coverage == coverage         )
  1222.       {
  1223.         span->len = (unsigned short)( span->len + acount );
  1224.         return;
  1225.       }
  1227.       if ( ras.span_y != y || count >= FT_MAX_GRAY_SPANS )
  1228.       {
  1229.         if ( ras.render_span && count > 0 )
  1230.           ras.render_span( ras.span_y, count, ras.gray_spans,
  1231.                            ras.render_span_data );
  1232.         /* ras.render_span( span->y, ras.gray_spans, count ); */
  1234. #ifdef DEBUG_GRAYS
  1236.         if ( ras.span_y >= 0 )
  1237.         {
  1238.           int  n;
  1241.           fprintf( stderr, "y=%3d ", ras.span_y );
  1242.           span = ras.gray_spans;
  1243.           for ( n = 0; n < count; n++, span++ )
  1244.             fprintf( stderr, "[%d..%d]:%02x ",
  1245.                      span->x, span->x + span->len - 1, span->coverage );
  1246.           fprintf( stderr, "n" );
  1247.         }
  1249. #endif /* DEBUG_GRAYS */
  1251.         ras.num_gray_spans = 0;
  1252.         ras.span_y         = y;
  1254.         count = 0;
  1255.         span  = ras.gray_spans;
  1256.       }
  1257.       else
  1258.         span++;
  1260.       /* add a gray span to the current list */
  1261.       span->x        = (short)x;
  1262.       span->len      = (unsigned short)acount;
  1263.       span->coverage = (unsigned char)coverage;
  1265.       ras.num_gray_spans++;
  1266.     }
  1267.   }
  1270. #ifdef DEBUG_GRAYS
  1272.   /* to be called while in the debugger */
  1273.   gray_dump_cells( RAS_ARG )
  1274.   {
  1275.     int  yindex;
  1278.     for ( yindex = 0; yindex < ras.ycount; yindex++ )
  1279.     {
  1280.       PCell  cell;
  1283.       printf( "%3d:", yindex );
  1285.       for ( cell = ras.ycells[yindex]; cell != NULL; cell = cell->next )
  1286.         printf( " (%3d, c:%4d, a:%6d)", cell->x, cell->cover, cell->area );
  1287.       printf( "n" );
  1288.     }
  1289.   }
  1291. #endif /* DEBUG_GRAYS */
  1294.   static void
  1295.   gray_sweep( RAS_ARG_ const FT_Bitmap*  target )
  1296.   {
  1297.     int  yindex;
  1299.     FT_UNUSED( target );
  1302.     if ( ras.num_cells == 0 )
  1303.       return;
  1305.     ras.num_gray_spans = 0;
  1307.     for ( yindex = 0; yindex < ras.ycount; yindex++ )
  1308.     {
  1309.       PCell   cell  = ras.ycells[yindex];
  1310.       TCoord  cover = 0;
  1311.       TCoord  x     = 0;
  1314.       for ( ; cell != NULL; cell = cell->next )
  1315.       {
  1316.         TArea  area;
  1319.         if ( cell->x > x && cover != 0 )
  1320.           gray_hline( RAS_VAR_ x, yindex, cover * ( ONE_PIXEL * 2 ),
  1321.                       cell->x - x );
  1323.         cover += cell->cover;
  1324.         area   = cover * ( ONE_PIXEL * 2 ) - cell->area;
  1326.         if ( area != 0 && cell->x >= 0 )
  1327.           gray_hline( RAS_VAR_ cell->x, yindex, area, 1 );
  1329.         x = cell->x + 1;
  1330.       }
  1332.       if ( cover != 0 )
  1333.         gray_hline( RAS_VAR_ x, yindex, cover * ( ONE_PIXEL * 2 ),
  1334.                     ras.count_ex - x );
  1335.     }
  1337.     if ( ras.render_span && ras.num_gray_spans > 0 )
  1338.       ras.render_span( ras.span_y, ras.num_gray_spans,
  1339.                        ras.gray_spans, ras.render_span_data );
  1340.   }
  1343. #ifdef _STANDALONE_
  1345.   /*************************************************************************/
  1346.   /*                                                                       */
  1347.   /*  The following function should only compile in stand_alone mode,      */
  1348.   /*  i.e., when building this component without the rest of FreeType.     */
  1349.   /*                                                                       */
  1350.   /*************************************************************************/
  1352.   /*************************************************************************/
  1353.   /*                                                                       */
  1354.   /* <Function>                                                            */
  1355.   /*    FT_Outline_Decompose                                               */
  1356.   /*                                                                       */
  1357.   /* <Description>                                                         */
  1358.   /*    Walks over an outline's structure to decompose it into individual  */
  1359.   /*    segments and Bezier arcs.  This function is also able to emit      */
  1360.   /*    `move to' and `close to' operations to indicate the start and end  */
  1361.   /*    of new contours in the outline.                                    */
  1362.   /*                                                                       */
  1363.   /* <Input>                                                               */
  1364.   /*    outline        :: A pointer to the source target.                  */
  1365.   /*                                                                       */
  1366.   /*    func_interface :: A table of `emitters', i.e,. function pointers   */
  1367.   /*                      called during decomposition to indicate path     */
  1368.   /*                      operations.                                      */
  1369.   /*                                                                       */
  1370.   /*    user           :: A typeless pointer which is passed to each       */
  1371.   /*                      emitter during the decomposition.  It can be     */
  1372.   /*                      used to store the state during the               */
  1373.   /*                      decomposition.                                   */
  1374.   /*                                                                       */
  1375.   /* <Return>                                                              */
  1376.   /*    Error code.  0 means success.                                      */
  1377.   /*                                                                       */
  1378.   static
  1379.   int  FT_Outline_Decompose( const FT_Outline*        outline,
  1380.                              const FT_Outline_Funcs*  func_interface,
  1381.                              void*                    user )
  1382.   {
  1383. #undef SCALED
  1384. #if 0
  1385. #define SCALED( x )  ( ( (x) << shift ) - delta )
  1386. #else
  1387. #define SCALED( x )  (x)
  1388. #endif
  1390.     FT_Vector   v_last;
  1391.     FT_Vector   v_control;
  1392.     FT_Vector   v_start;
  1394.     FT_Vector*  point;
  1395.     FT_Vector*  limit;
  1396.     char*       tags;
  1398.     int   n;         /* index of contour in outline     */
  1399.     int   first;     /* index of first point in contour */
  1400.     int   error;
  1401.     char  tag;       /* current point's state           */
  1403. #if 0
  1404.     int   shift = func_interface->shift;
  1405.     TPos  delta = func_interface->delta;
  1406. #endif
  1409.     first = 0;
  1411.     for ( n = 0; n < outline->n_contours; n++ )
  1412.     {
  1413.       int  last;  /* index of last point in contour */
  1416.       last  = outline->contours[n];
  1417.       limit = outline->points + last;
  1419.       v_start = outline->points[first];
  1420.       v_last  = outline->points[last];
  1422.       v_start.x = SCALED( v_start.x );
  1423.       v_start.y = SCALED( v_start.y );
  1425.       v_last.x  = SCALED( v_last.x );
  1426.       v_last.y  = SCALED( v_last.y );
  1428.       v_control = v_start;
  1430.       point = outline->points + first;
  1431.       tags  = outline->tags  + first;
  1432.       tag   = FT_CURVE_TAG( tags[0] );
  1434.       /* A contour cannot start with a cubic control point! */
  1435.       if ( tag == FT_CURVE_TAG_CUBIC )
  1436.         goto Invalid_Outline;
  1438.       /* check first point to determine origin */
  1439.       if ( tag == FT_CURVE_TAG_CONIC )
  1440.       {
  1441.         /* first point is conic control.  Yes, this happens. */
  1442.         if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON )
  1443.         {
  1444.           /* start at last point if it is on the curve */
  1445.           v_start = v_last;
  1446.           limit--;
  1447.         }
  1448.         else
  1449.         {
  1450.           /* if both first and last points are conic,         */
  1451.           /* start at their middle and record its position    */
  1452.           /* for closure                                      */
  1453.           v_start.x = ( v_start.x + v_last.x ) / 2;
  1454.           v_start.y = ( v_start.y + v_last.y ) / 2;
  1456.           v_last = v_start;
  1457.         }
  1458.         point--;
  1459.         tags--;
  1460.       }
  1462.       error = func_interface->move_to( &v_start, user );
  1463.       if ( error )
  1464.         goto Exit;
  1466.       while ( point < limit )
  1467.       {
  1468.         point++;
  1469.         tags++;
  1471.         tag = FT_CURVE_TAG( tags[0] );
  1472.         switch ( tag )
  1473.         {
  1474.         case FT_CURVE_TAG_ON:  /* emit a single line_to */
  1475.           {
  1476.             FT_Vector  vec;
  1479.             vec.x = SCALED( point->x );
  1480.             vec.y = SCALED( point->y );
  1482.             error = func_interface->line_to( &vec, user );
  1483.             if ( error )
  1484.               goto Exit;
  1485.             continue;
  1486.           }
  1488.         case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
  1489.           {
  1490.             v_control.x = SCALED( point->x );
  1491.             v_control.y = SCALED( point->y );
  1493.           Do_Conic:
  1494.             if ( point < limit )
  1495.             {
  1496.               FT_Vector  vec;
  1497.               FT_Vector  v_middle;
  1500.               point++;
  1501.               tags++;
  1502.               tag = FT_CURVE_TAG( tags[0] );
  1504.               vec.x = SCALED( point->x );
  1505.               vec.y = SCALED( point->y );
  1507.               if ( tag == FT_CURVE_TAG_ON )
  1508.               {
  1509.                 error = func_interface->conic_to( &v_control, &vec,
  1510.                                                   user );
  1511.                 if ( error )
  1512.                   goto Exit;
  1513.                 continue;
  1514.               }
  1516.               if ( tag != FT_CURVE_TAG_CONIC )
  1517.                 goto Invalid_Outline;
  1519.               v_middle.x = ( v_control.x + vec.x ) / 2;
  1520.               v_middle.y = ( v_control.y + vec.y ) / 2;
  1522.               error = func_interface->conic_to( &v_control, &v_middle,
  1523.                                                 user );
  1524.               if ( error )
  1525.                 goto Exit;
  1527.               v_control = vec;
  1528.               goto Do_Conic;
  1529.             }
  1531.             error = func_interface->conic_to( &v_control, &v_start,
  1532.                                               user );
  1533.             goto Close;
  1534.           }
  1536.         default:  /* FT_CURVE_TAG_CUBIC */
  1537.           {
  1538.             FT_Vector  vec1, vec2;
  1541.             if ( point + 1 > limit                             ||
  1542.                  FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
  1543.               goto Invalid_Outline;
  1545.             point += 2;
  1546.             tags  += 2;
  1548.             vec1.x = SCALED( point[-2].x );
  1549.             vec1.y = SCALED( point[-2].y );
  1551.             vec2.x = SCALED( point[-1].x );
  1552.             vec2.y = SCALED( point[-1].y );
  1554.             if ( point <= limit )
  1555.             {
  1556.               FT_Vector  vec;
  1559.               vec.x = SCALED( point->x );
  1560.               vec.y = SCALED( point->y );
  1562.               error = func_interface->cubic_to( &vec1, &vec2, &vec, user );
  1563.               if ( error )
  1564.                 goto Exit;
  1565.               continue;
  1566.             }
  1568.             error = func_interface->cubic_to( &vec1, &vec2, &v_start, user );
  1569.             goto Close;
  1570.           }
  1571.         }
  1572.       }
  1574.       /* close the contour with a line segment */
  1575.       error = func_interface->line_to( &v_start, user );
  1577.    Close:
  1578.       if ( error )
  1579.         goto Exit;
  1581.       first = last + 1;
  1582.     }
  1584.     return 0;
  1586.   Exit:
  1587.     return error;
  1589.   Invalid_Outline:
  1590.     return ErrRaster_Invalid_Outline;
  1591.   }
  1593. #endif /* _STANDALONE_ */
  1596.   typedef struct  TBand_
  1597.   {
  1598.     TPos  min, max;
  1600.   } TBand;
  1603.   static int
  1604.   gray_convert_glyph_inner( RAS_ARG )
  1605.   {
  1606.     static
  1607.     const FT_Outline_Funcs  func_interface =
  1608.     {
  1609.       (FT_Outline_MoveTo_Func) gray_move_to,
  1610.       (FT_Outline_LineTo_Func) gray_line_to,
  1611.       (FT_Outline_ConicTo_Func)gray_conic_to,
  1612.       (FT_Outline_CubicTo_Func)gray_cubic_to,
  1613.       0,
  1614.       0
  1615.     };
  1617.     volatile int  error = 0;
  1619.     if ( ft_setjmp( ras.jump_buffer ) == 0 )
  1620.     {
  1621.       error = FT_Outline_Decompose( &ras.outline, &func_interface, &ras );
  1622.       gray_record_cell( RAS_VAR );
  1623.     }
  1624.     else
  1625.     {
  1626.       error = ErrRaster_Memory_Overflow;
  1627.     }
  1629.     return error;
  1630.   }
  1633.   static int
  1634.   gray_convert_glyph( RAS_ARG )
  1635.   {
  1636.     TBand            bands[40];
  1637.     TBand* volatile  band;
  1638.     int volatile     n, num_bands;
  1639.     TPos volatile    min, max, max_y;
  1640.     FT_BBox*         clip;
  1643.     /* Set up state in the raster object */
  1644.     gray_compute_cbox( RAS_VAR );
  1646.     /* clip to target bitmap, exit if nothing to do */
  1647.     clip = &ras.clip_box;
  1649.     if ( ras.max_ex <= clip->xMin || ras.min_ex >= clip->xMax ||
  1650.          ras.max_ey <= clip->yMin || ras.min_ey >= clip->yMax )
  1651.       return 0;
  1653.     if ( ras.min_ex < clip->xMin ) ras.min_ex = clip->xMin;
  1654.     if ( ras.min_ey < clip->yMin ) ras.min_ey = clip->yMin;
  1656.     if ( ras.max_ex > clip->xMax ) ras.max_ex = clip->xMax;
  1657.     if ( ras.max_ey > clip->yMax ) ras.max_ey = clip->yMax;
  1659.     ras.count_ex = ras.max_ex - ras.min_ex;
  1660.     ras.count_ey = ras.max_ey - ras.min_ey;
  1662.     /* simple heuristic used to speed-up the bezier decomposition -- see */
  1663.     /* the code in gray_render_conic() and gray_render_cubic() for more  */
  1664.     /* details                                                           */
  1665.     ras.conic_level = 32;
  1666.     ras.cubic_level = 16;
  1668.     {
  1669.       int level = 0;
  1672.       if ( ras.count_ex > 24 || ras.count_ey > 24 )
  1673.         level++;
  1674.       if ( ras.count_ex > 120 || ras.count_ey > 120 )
  1675.         level++;
  1677.       ras.conic_level <<= level;
  1678.       ras.cubic_level <<= level;
  1679.     }
  1681.     /* setup vertical bands */
  1682.     num_bands = (int)( ( ras.max_ey - ras.min_ey ) / ras.band_size );
  1683.     if ( num_bands == 0 )  num_bands = 1;
  1684.     if ( num_bands >= 39 ) num_bands = 39;
  1686.     ras.band_shoot = 0;
  1688.     min   = ras.min_ey;
  1689.     max_y = ras.max_ey;
  1691.     for ( n = 0; n < num_bands; n++, min = max )
  1692.     {
  1693.       max = min + ras.band_size;
  1694.       if ( n == num_bands - 1 || max > max_y )
  1695.         max = max_y;
  1697.       bands[0].min = min;
  1698.       bands[0].max = max;
  1699.       band         = bands;
  1701.       while ( band >= bands )
  1702.       {
  1703.         TPos  bottom, top, middle;
  1704.         int   error;
  1706.         {
  1707.           PCell  cells_max;
  1708.           int    yindex;
  1709.           long   cell_start, cell_end, cell_mod;
  1712.           ras.ycells = (PCell*)ras.buffer;
  1713.           ras.ycount = band->max - band->min;
  1715.           cell_start = sizeof ( PCell ) * ras.ycount;
  1716.           cell_mod   = cell_start % sizeof ( TCell );
  1717.           if ( cell_mod > 0 )
  1718.             cell_start += sizeof ( TCell ) - cell_mod;
  1720.           cell_end  = ras.buffer_size;
  1721.           cell_end -= cell_end % sizeof( TCell );
  1723.           cells_max = (PCell)( (char*)ras.buffer + cell_end );
  1724.           ras.cells = (PCell)( (char*)ras.buffer + cell_start );
  1725.           if ( ras.cells >= cells_max )
  1726.             goto ReduceBands;
  1728.           ras.max_cells = cells_max - ras.cells;
  1729.           if ( ras.max_cells < 2 )
  1730.             goto ReduceBands;
  1732.           for ( yindex = 0; yindex < ras.ycount; yindex++ )
  1733.             ras.ycells[yindex] = NULL;
  1734.         }
  1736.         ras.num_cells = 0;
  1737.         ras.invalid   = 1;
  1738.         ras.min_ey    = band->min;
  1739.         ras.max_ey    = band->max;
  1740.         ras.count_ey  = band->max - band->min;
  1742.         error = gray_convert_glyph_inner( RAS_VAR );
  1744.         if ( !error )
  1745.         {
  1746.           gray_sweep( RAS_VAR_ &ras.target );
  1747.           band--;
  1748.           continue;
  1749.         }
  1750.         else if ( error != ErrRaster_Memory_Overflow )
  1751.           return 1;
  1753.       ReduceBands:
  1754.         /* render pool overflow; we will reduce the render band by half */
  1755.         bottom = band->min;
  1756.         top    = band->max;
  1757.         middle = bottom + ( ( top - bottom ) >> 1 );
  1759.         /* This is too complex for a single scanline; there must */
  1760.         /* be some problems.                                     */
  1761.         if ( middle == bottom )
  1762.         {
  1763. #ifdef DEBUG_GRAYS
  1764.           fprintf( stderr, "Rotten glyph!n" );
  1765. #endif
  1766.           return 1;
  1767.         }
  1769.         if ( bottom-top >= ras.band_size )
  1770.           ras.band_shoot++;
  1772.         band[1].min = bottom;
  1773.         band[1].max = middle;
  1774.         band[0].min = middle;
  1775.         band[0].max = top;
  1776.         band++;
  1777.       }
  1778.     }
  1780.     if ( ras.band_shoot > 8 && ras.band_size > 16 )
  1781.       ras.band_size = ras.band_size / 2;
  1783.     return 0;
  1784.   }
  1787.   static int
  1788.   gray_raster_render( PRaster                  raster,
  1789.                       const FT_Raster_Params*  params )
  1790.   {
  1791.     const FT_Outline*  outline    = (const FT_Outline*)params->source;
  1792.     const FT_Bitmap*   target_map = params->target;
  1793.     PWorker            worker;
  1796.     if ( !raster || !raster->buffer || !raster->buffer_size )
  1797.       return ErrRaster_Invalid_Argument;
  1799.     /* return immediately if the outline is empty */
  1800.     if ( outline->n_points == 0 || outline->n_contours <= 0 )
  1801.       return 0;
  1803.     if ( !outline || !outline->contours || !outline->points )
  1804.       return ErrRaster_Invalid_Outline;
  1806.     if ( outline->n_points !=
  1807.            outline->contours[outline->n_contours - 1] + 1 )
  1808.       return ErrRaster_Invalid_Outline;
  1810.     worker = raster->worker;
  1812.     /* if direct mode is not set, we must have a target bitmap */
  1813.     if ( ( params->flags & FT_RASTER_FLAG_DIRECT ) == 0 )
  1814.     {
  1815.       if ( !target_map )
  1816.         return ErrRaster_Invalid_Argument;
  1818.       /* nothing to do */
  1819.       if ( !target_map->width || !target_map->rows )
  1820.         return 0;
  1822.       if ( !target_map->buffer )
  1823.         return ErrRaster_Invalid_Argument;
  1824.     }
  1826.     /* this version does not support monochrome rendering */
  1827.     if ( !( params->flags & FT_RASTER_FLAG_AA ) )
  1828.       return ErrRaster_Invalid_Mode;
  1830.     /* compute clipping box */
  1831.     if ( ( params->flags & FT_RASTER_FLAG_DIRECT ) == 0 )
  1832.     {
  1833.       /* compute clip box from target pixmap */
  1834.       ras.clip_box.xMin = 0;
  1835.       ras.clip_box.yMin = 0;
  1836.       ras.clip_box.xMax = target_map->width;
  1837.       ras.clip_box.yMax = target_map->rows;
  1838.     }
  1839.     else if ( params->flags & FT_RASTER_FLAG_CLIP )
  1840.     {
  1841.       ras.clip_box = params->clip_box;
  1842.     }
  1843.     else
  1844.     {
  1845.       ras.clip_box.xMin = -32768L;
  1846.       ras.clip_box.yMin = -32768L;
  1847.       ras.clip_box.xMax =  32767L;
  1848.       ras.clip_box.yMax =  32767L;
  1849.     }
  1851.     gray_init_cells( worker, raster->buffer, raster->buffer_size );
  1853.     ras.outline   = *outline;
  1854.     ras.num_cells = 0;
  1855.     ras.invalid   = 1;
  1856.     ras.band_size = raster->band_size;
  1857.     ras.num_gray_spans = 0;
  1859.     if ( target_map )
  1860.       ras.target = *target_map;
  1862.     ras.render_span      = (FT_Raster_Span_Func)gray_render_span;
  1863.     ras.render_span_data = &ras;
  1865.     if ( params->flags & FT_RASTER_FLAG_DIRECT )
  1866.     {
  1867.       ras.render_span      = (FT_Raster_Span_Func)params->gray_spans;
  1868.       ras.render_span_data = params->user;
  1869.     }
  1871.     return gray_convert_glyph( worker );
  1872.   }
  1875.   /**** RASTER OBJECT CREATION: In standalone mode, we simply use *****/
  1876.   /****                         a static object.                  *****/
  1878. #ifdef _STANDALONE_
  1880.   static int
  1881.   gray_raster_new( void*       memory,
  1882.                    FT_Raster*  araster )
  1883.   {
  1884.     static TRaster  the_raster;
  1886.     FT_UNUSED( memory );
  1889.     *araster = (FT_Raster)&the_raster;
  1890.     FT_MEM_ZERO( &the_raster, sizeof ( the_raster ) );
  1892.     return 0;
  1893.   }
  1896.   static void
  1897.   gray_raster_done( FT_Raster  raster )
  1898.   {
  1899.     /* nothing */
  1900.     FT_UNUSED( raster );
  1901.   }
  1903. #else /* _STANDALONE_ */
  1905.   static int
  1906.   gray_raster_new( FT_Memory   memory,
  1907.                    FT_Raster*  araster )
  1908.   {
  1909.     FT_Error  error;
  1910.     PRaster   raster;
  1913.     *araster = 0;
  1914.     if ( !FT_ALLOC( raster, sizeof ( TRaster ) ) )
  1915.     {
  1916.       raster->memory = memory;
  1917.       *araster = (FT_Raster)raster;
  1918.     }
  1920.     return error;
  1921.   }
  1924.   static void
  1925.   gray_raster_done( FT_Raster  raster )
  1926.   {
  1927.     FT_Memory  memory = (FT_Memory)((PRaster)raster)->memory;
  1930.     FT_FREE( raster );
  1931.   }
  1933. #endif /* _STANDALONE_ */
  1936.   static void
  1937.   gray_raster_reset( FT_Raster  raster,
  1938.                      char*      pool_base,
  1939.                      long       pool_size )
  1940.   {
  1941.     PRaster  rast = (PRaster)raster;
  1944.     if ( raster )
  1945.     {
  1946.       if ( pool_base && pool_size >= (long)sizeof ( TWorker ) + 2048 )
  1947.       {
  1948.         PWorker  worker = (PWorker)pool_base;
  1951.         rast->worker      = worker;
  1952.         rast->buffer      = pool_base +
  1953.                               ( ( sizeof ( TWorker ) + sizeof ( TCell ) - 1 ) &
  1954.                                 ~( sizeof ( TCell ) - 1 ) );
  1955.         rast->buffer_size = (long)( ( pool_base + pool_size ) -
  1956.                                     (char*)rast->buffer ) &
  1957.                                       ~( sizeof ( TCell ) - 1 );
  1958.         rast->band_size   = (int)( rast->buffer_size /
  1959.                                      ( sizeof ( TCell ) * 8 ) );
  1960.       }
  1961.       else
  1962.       {
  1963.         rast->buffer      = NULL;
  1964.         rast->buffer_size = 0;
  1965.         rast->worker      = NULL;
  1966.       }
  1967.     }
  1968.   }
  1971.   const FT_Raster_Funcs  ft_grays_raster =
  1972.   {
  1973.     FT_GLYPH_FORMAT_OUTLINE,
  1975.     (FT_Raster_New_Func)     gray_raster_new,
  1976.     (FT_Raster_Reset_Func)   gray_raster_reset,
  1977.     (FT_Raster_Set_Mode_Func)0,
  1978.     (FT_Raster_Render_Func)  gray_raster_render,
  1979.     (FT_Raster_Done_Func)    gray_raster_done
  1980.   };
  1983. /* END */