kc3-lang/freetype

diff --git a/demos/Makefile b/demos/Makefile
index c4aed7a..4020c93 100644
--- a/demos/Makefile
+++ b/demos/Makefile
@@ -182,6 +182,9 @@ else
   $(OBJ_)ftlint.$O: $(SRC_DIR_)ftlint.c
 	  $(COMPILE) $T$@ $<
 
+  $(OBJ_)ftgrays.$O: $(SRC_DIR_)ftgrays.c
+	  $(COMPILE) $T$@ $<
+
   $(OBJ_)fttry.$O: $(SRC_DIR_)fttry.c
 	  $(COMPILE) $T$@ $<
 
@@ -243,11 +246,11 @@ else
 	  $(LINK)
 
 
-  $(BIN_)ftview$E: $(OBJ_)ftview.$O $(FTLIB) $(GRAPH_LIB) $(COMMON_OBJ)
-	  $(GRAPH_LINK) 
+  $(BIN_)ftview$E: $(OBJ_)ftview.$O $(FTLIB) $(GRAPH_LIB) $(COMMON_OBJ) $(OBJ_)ftgrays.$O
+	  $(GRAPH_LINK) $(OBJ_)ftgrays.$O
 
-  $(BIN_)fttimer$E: $(OBJ_)fttimer.$O $(FTLIB) $(GRAPH_LIB) $(COMMON_OBJ)
-	  $(GRAPH_LINK)
+  $(BIN_)fttimer$E: $(OBJ_)fttimer.$O $(FTLIB) $(GRAPH_LIB) $(COMMON_OBJ) $(OBJ_)ftgrays.$O
+	  $(GRAPH_LINK) $(OBJ_)ftgrays.$O
 
 endif
 
diff --git a/demos/src/ftgrays.c b/demos/src/ftgrays.c
new file mode 100644
index 0000000..08b3066
--- /dev/null
+++ b/demos/src/ftgrays.c
@@ -0,0 +1,1526 @@
+/*****************************************************************************/
+/*                                                                           */
+/*  ftgrays.c  - a new 'perfect' anti-aliasing renderer for FreeType 2       */
+/*                                                                           */
+/*  (c) 2000 David Turner - <david.turner@freetype.org>                      */
+/*                                                                           */
+/*  Beware, this code is still in heavy beta..                               */
+/*                                                                           */
+/*  This is a new anti-aliasing scan-converter for FreeType 2. The           */
+/*  algorithm used here is _very_ different from the one in the standard     */
+/*  "ftraster.c". Actually, "ftgrays.c" computes the _exact_ coverage of     */
+/*  the outline on each pixel cell.                                          */
+/*                                                                           */
+/*  It is based on ideas that I initially found in Raph Levien's excellent   */
+/*  LibArt graphics library (see www.levien.com/libart for more information, */
+/*  though the web pages do not tell anything about the renderer, you'll     */
+/*  have to dive in the source code to understand how it works..)            */
+/*                                                                           */
+/*  Note however that this is a _very_ different implementation from         */
+/*  Raph's. Coverage information is stored in a very different way,          */
+/*  and I don't use sorted vector paths. Also, it doesn't use floating       */
+/*  point values..                                                           */
+/*                                                                           */
+/*  This renderer has the following advantages:                              */
+/*                                                                           */
+/*     - doesn't need an intermediate bitmap. Instead, one can supply        */
+/*       a callback fuction that will be called by the renderer to           */
+/*       draw gray spans on any target surface.. You can thus do direct      */
+/*       composition on any kind of bitmap, provided that you give the       */
+/*       renderer the right callback..                                       */
+/*                                                                           */
+/*     - perfect anti-aliaser, i.e. computes the _exact_ coverage on         */
+/*       each pixel cell                                                     */
+/*                                                                           */
+/*     - performs a single pass on the outline (the 'standard' FT2           */
+/*       renderer performs two passes).                                      */
+/*                                                                           */
+/*     - can easily be modified to render to _any_ number of gray levels     */
+/*       cheaply..                                                           */
+/*                                                                           */
+/*  It has the following disadvantages (for now):                            */
+/*                                                                           */
+/*     - need more memory than the standard scan-converter to render         */
+/*       a single outline. Note that this may be changed in a near           */
+/*       future (we might be able to pack the data in the TCell structure)   */
+/*                                                                           */
+/*     - apparently, glyphs rendered with this module are a bit more         */
+/*       "fuzzy" than those produced with the standard renderer. I hope      */
+/*       to fix this using a gamma table somewhere..                         */
+/*                                                                           */
+/*                                                                           */
+
+#include <ftimage.h>
+
+#define ErrRaster_Invalid_Outline  -1
+
+#include "ftgrays.h"
+
+#define xxxDEBUG_GRAYS
+
+#ifndef FT_STATIC_RASTER
+
+  #define  RAS_ARG    PRaster  raster
+  #define  RAS_ARG_   PRaster  raster,
+
+  #define  RAS_VAR    raster
+  #define  RAS_VAR_   raster,
+
+  #define  ras (*raster)
+
+#else
+
+  #define  RAS_ARG
+  #define  RAS_ARG_
+  #define  RAS_VAR
+  #define  RAS_VAR_
+
+  static TRaster  ras;
+
+#endif
+
+#define  PIXEL_BITS  6
+#define  ONE_PIXEL   (1L << PIXEL_BITS)
+#define  PIXEL_MASK  (-1L << PIXEL_BITS)
+#define  TRUNC(x)    ((x) >> PIXEL_BITS)
+#define  SUBPIXELS(x) ((x) << PIXEL_BITS)
+#define  FLOOR(x)    ((x) & -ONE_PIXEL)
+#define  CEILING(x)  (((x)+ONE_PIXEL-1) & -ONE_PIXEL)
+#define  ROUND(x)    (((x)+ONE_PIXEL/2) & -ONE_PIXEL)
+
+/****************************************************************************/
+/*                                                                          */
+/*   INITIALIZE THE CELLS TABLE                                             */
+/*                                                                          */
+static
+void  init_cells( RAS_ARG_  void*  buffer, long byte_size )
+{
+  ras.cells     = (PCell)buffer;
+  ras.max_cells = byte_size / sizeof(TCell);
+  ras.num_cells = 0;
+  ras.area      = 0;
+  ras.cover     = 0;
+  ras.invalid   = 1;
+}
+
+
+/****************************************************************************/
+/*                                                                          */
+/*   COMPUTE THE OUTLINE BOUNDING BOX                                       */
+/*                                                                          */
+static
+void  compute_cbox( RAS_ARG_ FT_Outline*  outline )
+{
+  FT_Vector*  vec   = outline->points;
+  FT_Vector*  limit = vec + outline->n_points;
+  
+  if ( outline->n_points <= 0 )
+  {
+    ras.min_ex = ras.max_ex = 0;
+    ras.min_ey = ras.max_ey = 0;
+    return;
+  }
+  
+  ras.min_ex = ras.max_ex = vec->x;
+  ras.min_ey = ras.max_ey = vec->y;
+  vec++;
+  
+  for ( ; vec < limit; vec++ )
+  {
+    TPos  x = vec->x;
+    TPos  y = vec->y;
+    
+    if ( x < ras.min_ex ) ras.min_ex = x;
+    if ( x > ras.max_ex ) ras.max_ex = x;
+    if ( y < ras.min_ey ) ras.min_ey = y;
+    if ( y > ras.max_ey ) ras.max_ey = y;
+  }
+
+  /* truncate the bounding box to integer pixels */  
+  ras.min_ex = TRUNC( ras.min_ex );
+  ras.min_ey = TRUNC( ras.min_ey );
+  ras.max_ex = TRUNC( CEILING( ras.max_ex ) );
+  ras.max_ey = TRUNC( CEILING( ras.max_ey ) );
+}
+
+
+/****************************************************************************/
+/*                                                                          */
+/*   RECORD THE CURRENT CELL IN THE TABLE                                   */
+/*                                                                          */
+static
+int record_cell( RAS_ARG )
+{
+  PCell cell;
+
+  if (!ras.invalid && (ras.area | ras.cover))
+  {    
+    if ( ras.num_cells >= ras.max_cells )
+      return 1;
+
+    cell        = ras.cells + ras.num_cells++;
+    cell->x     = ras.ex - ras.min_ex;
+    cell->y     = ras.ey - ras.min_ey;
+    cell->area  = ras.area;
+    cell->cover = ras.cover;
+  }
+  return 0;
+}
+
+
+/****************************************************************************/
+/*                                                                          */
+/*   SET THE CURRENT CELL TO A NEW POSITION                                 */
+/*                                                                          */
+static
+int   set_cell( RAS_ARG_ TScan ex, TScan ey )
+{
+  int  invalid, record, clean;
+
+  /* move the cell pointer to a new position. We set the "invalid"       */
+  /* flag to indicate that the cell isn't part of those we're interested */
+  /* in during the render phase.. This means that:                       */
+  /*                                                                     */
+  /* the new vertical position must be within min_ey..max_ey-1.          */
+  /* the new horizontal position must be strictly less than max_ey       */
+  /*                                                                     */
+  /* Note that we a cell is to the left of the clipping region, it is    */
+  /* actually set to the (min_ex-1) horizontal position                  */
+  /*                                                                     */
+  record  = 0;
+  clean   = 1;
+  invalid = ( ey < ras.min_ey || ey >= ras.max_ey || ex >= ras.max_ex );
+  if (!invalid)
+  {
+    /* all cells that are on the left of the clipping region go to the */
+    /* min_ex-1 horizontal position..                                  */
+    if (ex < ras.min_ex)
+      ex = ras.min_ex-1;
+
+    /* if our position is new, then record the previous cell */    
+    if (ex != ras.ex || ey != ras.ey)
+      record = 1;
+    else
+      clean = ras.invalid;  /* do not clean if we didn't move from */
+                            /* a valid cell..                      */
+  }
+
+  /* record the previous cell if needed (i.e. if we changed the cell */
+  /* position, of changed the 'invalid' flag..)                      */
+  if ( (ras.invalid != invalid || record) && record_cell( RAS_VAR ) )
+    return 1;
+    
+  if (clean)
+  {
+    ras.area  = 0;
+    ras.cover = 0;
+  }
+
+  ras.invalid = invalid;
+  ras.ex      = ex;
+  ras.ey      = ey;
+  return 0;
+}
+  
+
+
+/****************************************************************************/
+/*                                                                          */
+/*   START A NEW CONTOUR AT A GIVEN CELL                                    */
+/*                                                                          */
+static
+void  start_cell( RAS_ARG_  TScan  ex, TScan  ey )
+{
+  if (ex < ras.min_ex)
+    ex = ras.min_ex-1;
+    
+  ras.area    = 0;
+  ras.cover   = 0;
+  ras.ex      = ex;
+  ras.ey      = ey;
+  ras.last_ey = SUBPIXELS(ey);
+  ras.invalid = 0;
+  
+  (void)set_cell( RAS_VAR_  ex, ey );
+}
+
+
+/****************************************************************************/
+/*                                                                          */
+/*   RENDER A SCANLINE AS ONE OR MORE CELLS                                 */
+/*                                                                          */
+static
+int  render_scanline( RAS_ARG_  TScan  ey, TPos x1, TScan y1,
+                                           TPos x2, TScan y2 )
+{
+  TScan  ex1, ex2, fx1, fx2, delta;
+  long   p, first, dx;
+  int    incr, lift, mod, rem;
+
+  dx = x2-x1;
+    
+  ex1 = TRUNC(x1); /* if (ex1 >= ras.max_ex) ex1 = ras.max_ex-1; */
+  ex2 = TRUNC(x2); /* if (ex2 >= ras.max_ex) ex2 = ras.max_ex-1; */
+  fx1 = x1 - SUBPIXELS(ex1);
+  fx2 = x2 - SUBPIXELS(ex2);
+
+  /* trivial case. Happens often */
+  if (y1 == y2)
+    return set_cell( RAS_VAR_  ex2, ey );
+  
+
+  /* everything is located in a single cell, that is easy ! */
+  /*                                                        */
+  if ( ex1 == ex2 )
+  {
+    delta      = y2-y1;
+    ras.area  += (fx1+fx2)*delta;
+    ras.cover += delta;
+    return 0;
+  }
+  
+  /* ok, we'll have to render a run of adjacent cells on the same */
+  /* scanline..                                                   */
+  /*                                                              */
+  p     = (ONE_PIXEL-fx1)*(y2-y1);
+  first = ONE_PIXEL;
+  incr  = 1;
+  if ( dx < 0 )
+  {
+    p     = fx1*(y2-y1);
+    first = 0;
+    incr  = -1;
+    dx    = -dx;
+  }
+
+  delta = p / dx;
+  mod   = p % dx;
+  if (mod < 0)
+  {
+    delta--;
+    mod += dx;
+  }
+
+  ras.area  += (fx1+first)*delta;
+  ras.cover += delta;
+
+  ex1 += incr;
+  if (set_cell( RAS_VAR_ ex1, ey )) goto Error;
+  y1  += delta;
+
+  if (ex1 != ex2)
+  {
+    p     = ONE_PIXEL*(y2-y1);
+    lift  = p / dx;
+    rem   = p % dx;
+    if (rem < 0)
+    {
+      lift--;
+      rem += dx;
+    }
+  
+    mod -= dx;
+      
+    while (ex1 != ex2)
+    {
+      delta = lift;
+      mod  += rem;
+      if (mod >= 0)
+      {
+        mod -= dx;
+        delta++;
+      }
+      ras.area  += ONE_PIXEL*delta;
+      ras.cover += delta;
+      y1        += delta;
+      ex1       += incr;
+      if (set_cell( RAS_VAR_ ex1, ey )) goto Error;
+    }
+  }
+  
+  delta      = y2-y1;
+  ras.area  += (fx2+ONE_PIXEL-first)*delta;
+  ras.cover += delta;
+  
+  return 0;
+Error:
+  return 1;
+}
+
+/****************************************************************************/
+/*                                                                          */
+/*   RENDER A GIVEN LINE AS A SERIES OF SCANLINES                           */
+/*                                                                          */
+static
+int  render_line( RAS_ARG_ TPos  to_x, TPos  to_y )
+{
+  TScan  ey1, ey2, fy1, fy2;
+  TPos   dx, dy, x, x2;
+  int    p, rem, mod, lift, delta, first, incr;
+
+  ey1 = TRUNC(ras.last_ey);
+  ey2 = TRUNC(to_y); /* if (ey2 >= ras.max_ey) ey2 = ras.max_ey-1; */
+  fy1 = ras.y - ras.last_ey;
+  fy2 = to_y - SUBPIXELS(ey2);
+
+  dx = to_x - ras.x;
+  dy = to_y - ras.y;  
+
+  /* we should do something about the trivial case where dx == 0, */
+  /* as it happens very often !! ... XXXXX                        */
+
+  /* everything is on a single scanline */  
+  if ( ey1 == ey2 )
+  {
+    if (render_scanline( RAS_VAR_ ey1, ras.x, fy1, to_x, fy2 )) goto Error;
+    goto Fin;
+  }
+
+  /* ok, we'll have to render a run of adjacent cells on the same */
+  /* scanline..                                                   */
+  /*                                                              */
+  p     = (ONE_PIXEL-fy1)*dx;
+  first = ONE_PIXEL;
+  incr  = 1;
+  if ( dy < 0 )
+  {
+    p     = fy1*dx;
+    first = 0;
+    incr  = -1;
+    dy    = -dy;
+  }
+
+  delta = p / dy;
+  mod   = p % dy;
+  if (mod < 0)
+  {
+    delta--;
+    mod += dy;
+  }
+
+  x = ras.x + delta;
+  if (render_scanline( RAS_VAR_ ey1, ras.x, fy1, x, first )) goto Error;
+    
+  ey1 += incr;
+  if (set_cell( RAS_VAR_ TRUNC(x), ey1 )) goto Error;
+
+  if (ey1 != ey2)
+  {
+    p     = ONE_PIXEL*dx;
+    lift  = p / dy;
+    rem   = p % dy;
+    if (rem < 0)
+    {
+      lift--;
+      rem += dy;
+    }
+    mod -= dy;
+      
+    while (ey1 != ey2)
+    {
+      delta = lift;
+      mod  += rem;
+      if (mod >= 0)
+      {
+        mod -= dy;
+        delta++;
+      }
+      x2   = x + delta;
+      if (render_scanline( RAS_VAR_ ey1, x, ONE_PIXEL-first, x2, first )) goto Error;
+      x    = x2;
+      ey1 += incr;
+      if (set_cell( RAS_VAR_ TRUNC(x), ey1 )) goto Error;
+    }
+  }
+  
+  if (render_scanline( RAS_VAR_ ey1, x, ONE_PIXEL-first, to_x, fy2 )) goto Error;
+  
+Fin:
+  ras.x       = to_x;
+  ras.y       = to_y;
+  ras.last_ey = SUBPIXELS(ey2);
+  return 0;
+Error:
+  return 1;
+}
+
+
+static
+void  split_conic( FT_Vector*  base )
+{
+  TPos  a, b;
+  
+  base[4].x = base[2].x;
+  b = base[1].x;
+  a = base[3].x = ( base[2].x + b )/2;
+  b = base[1].x = ( base[0].x + b )/2;
+  base[2].x = ( a + b ) / 2;
+
+  base[4].y = base[2].y;
+  b = base[1].y;
+  a = base[3].y = ( base[2].y + b )/2;
+  b = base[1].y = ( base[0].y + b )/2;
+  base[2].y = ( a + b ) / 2;
+}
+
+static
+int  render_conic( RAS_ARG_ FT_Vector* control, FT_Vector* to )
+{
+  TPos        dx, dy;
+  int         top, level;
+  int*        levels;
+  FT_Vector*  arc;
+  
+  dx = ras.x + to->x - (control->x << 1); if (dx < 0) dx = -dx;
+  dy = ras.y + to->y - (control->y << 1); if (dy < 0) dy = -dy;
+  if (dx < dy) dx = dy;
+  
+  level = 1;
+  dx = dx/64;
+  while ( dx > 0 )
+  {
+    dx >>= 1;
+    level++;
+  }
+
+  if (level <= 1)
+    return render_line( RAS_VAR_ to->x, to->y );
+
+  arc      = ras.bez_stack;
+  arc[0]   = *to;
+  arc[1]   = *control;
+  arc[2].x = ras.x;
+  arc[2].y = ras.y;
+
+  levels    = ras.lev_stack;
+  top       = 0;
+  levels[0] = level;
+
+  for (;;)
+  {
+    level = levels[top];
+    if (level > 1)
+    {
+      split_conic(arc);
+      arc += 2;
+      top ++;
+      levels[top] = levels[top-1] = level-1;
+    }
+    else
+    {
+      if (render_line( RAS_VAR_ arc[0].x, arc[0].y )) return 1;
+      top--;
+      arc-=2;
+      if (top < 0)
+        return 0;
+    }
+  }
+}
+
+
+static
+void  split_cubic( FT_Vector*  base )
+{
+  TPos   a, b, c, d;
+
+  base[6].x = base[3].x;
+  c = base[1].x;
+  d = base[2].x;
+  base[1].x = a = ( base[0].x + c ) / 2;
+  base[5].x = b = ( base[3].x + d ) / 2;
+  c = ( c + d ) / 2;
+  base[2].x = a = ( a + c ) / 2;
+  base[4].x = b = ( b + c ) / 2;
+  base[3].x = ( a + b ) / 2;
+
+  base[6].y = base[3].y;
+  c = base[1].y;
+  d = base[2].y;
+  base[1].y = a = ( base[0].y + c ) / 2;
+  base[5].y = b = ( base[3].y + d ) / 2;
+  c = ( c + d ) / 2;
+  base[2].y = a = ( a + c ) / 2;
+  base[4].y = b = ( b + c ) / 2;
+  base[3].y = ( a + b ) / 2;
+}
+
+static
+int  render_cubic( RAS_ARG_ FT_Vector* control1,
+                            FT_Vector* control2,
+                            FT_Vector* to )
+{
+  TPos        dx, dy, da, db;
+  int         top, level;
+  int*        levels;
+  FT_Vector*  arc;
+  
+  dx = ras.x + to->x - (control1->x << 1); if (dx < 0) dx = -dx;
+  dy = ras.y + to->y - (control1->y << 1); if (dy < 0) dy = -dy;
+  if (dx < dy) dx = dy;
+  da = dx;
+  
+  dx = ras.x + to->x - 3*(control1->x + control2->x); if (dx < 0) dx = -dx;
+  dy = ras.y + to->y - 3*(control1->x + control2->y); if (dy < 0) dy = -dy;
+  if (dx < dy) dx = dy;
+  db = dx;
+   
+  level = 1;
+  while ( da > 0 || db > 0 )
+  {
+    da >>= 1;
+    db >>= 2;
+    level++;
+  }
+
+  if (level <= 1)
+    return render_line( RAS_VAR_ to->x, to->y );
+
+  arc      = ras.bez_stack;
+  arc[0]   = *to;
+  arc[1]   = *control2;
+  arc[2]   = *control1;
+  arc[3].x = ras.x;
+  arc[3].y = ras.y;
+
+  levels    = ras.lev_stack;
+  top       = 0;
+  levels[0] = level;
+
+  for (;;)
+  {
+    level = levels[top];
+    if (level > 1)
+    {
+      split_cubic(arc);
+      arc += 3;
+      top ++;
+      levels[top] = levels[top-1] = level-1;
+    }
+    else
+    {
+      if (render_line( RAS_VAR_ arc[0].x, arc[0].y )) return 1;
+      top --;
+      arc -= 3;
+      if (top < 0)
+        return 0;
+    }
+  }
+}
+
+
+/* a macro comparing two cell pointers. returns true if a <= b */
+#define LESS_THAN(a,b)   ( (a)->y<(b)->y || ((a)->y==(b)->y && (a)->x<=(b)->x) )
+#define SWAP_CELLS(a,b,temp)  { temp = *(a); *(a) = *(b); *(b) = temp; }
+#define DEBUG_SORT
+#define SHELL_SORT
+
+#ifdef SHELL_SORT
+/* A simple shell sort algorithm that works directly on our */
+/* cells table..                                            */
+static
+void shell_sort ( PCell cells,
+                  int   count )
+{
+  PCell  i, j, limit = cells + count;
+  TCell  temp;
+  int    gap;
+
+  /* compute initial gap */
+  for (gap = 0; ++gap < count; gap *=3 );
+  while ( gap /= 3 )
+  {
+    for ( i = cells+gap; i < limit; i++ )
+    {
+      for ( j = i-gap; ; j -= gap )
+      {
+        PCell  k = j+gap;
+        
+        if ( LESS_THAN(j,k) )
+          break;
+          
+        SWAP_CELLS(j,k,temp);        
+        
+        if ( j < cells+gap )
+          break;
+      }
+    }
+  }
+  
+}
+#endif
+
+#ifdef QUICK_SORT
+/* this is a non-recursive quicksort that directly process our cells array */
+/* it should be faster than calling the stdlib qsort(), and we can even    */
+/* tailor our insertion threshold...                                       */
+
+#define QSORT_THRESHOLD  4   /* below this size, a sub-array will be sorted */
+                             /* through a normal insertion sort..           */
+
+static
+void  quick_sort( PCell cells,
+                  int   count )
+{
+  PCell  stack[40];  /* should be enough ;-) */
+  PCell* top;        /* top of stack */
+  PCell  base, limit;
+  TCell  temp;
+  
+  limit = cells + count;
+  base  = cells;
+  top   = stack;
+  for (;;)
+  {
+    int   len = limit-base;
+    PCell i, j;
+    
+    if ( len > QSORT_THRESHOLD)
+    {
+      /* we use base+len/2 as the pivot */
+      SWAP_CELLS( base, base+len/2, temp );
+      i = base+1;
+      j = limit-1;
+
+      /* now ensure that *i <= *base <= *j */
+      if (LESS_THAN(j,i))
+        SWAP( i, j, temp );
+        
+      if (LESS_THAN(base,i))
+        SWAP( base, i, temp );
+        
+      if (LESS_THAN(j,base))
+        SWAP( base, j, temp );
+        
+      for (;;)
+      {
+        do i++ while (LESS_THAN(i,base));
+        do j-- while (LESS_THAN(base,j));
+        if (i > j)
+          break;
+          
+        SWAP( i,j );
+      }
+      /* move pivot to correct place */
+      SWAP( base, j, temp );
+      
+      /* now, push the largest sub-array */
+      if ( j - base > limit -i )
+      {
+        top[0] = base;
+        top[1] = j;
+        base   = i;
+      }
+      else
+      {
+        top[0] = i;
+        top[1] = limit;
+        limit  = j;
+      }
+      top += 2;      
+    }
+    else
+    {
+      /* the sub-array is small, perform insertion sort */
+      j = base;
+      i = j+1;
+      for ( ; i < limit; j = i, i++ )
+      {
+        for ( ; LESS_THAN(j+1,j); j-- )
+        {
+          SWAP( j+1, j, temp );
+          if (j == base)
+            break;
+        }
+      }
+    }
+  }
+}
+#endif
+
+
+#ifdef DEBUG_GRAYS
+#ifdef DEBUG_SORT
+static
+int  check_sort( PCell  cells, int count )
+{
+  PCell  p, q;
+  
+  for ( p = cells + count-2; p >= cells; p-- )
+  {
+    q = p+1;
+    if (!LESS_THAN(p,q))
+      return 0;
+  }
+  return 1;
+}
+#endif
+#endif
+
+#if 0
+  static
+  int  FT_Decompose_Outline( FT_Outline*        outline,
+                             FT_Outline_Funcs*  interface,
+                             void*              user )
+  {
+    typedef enum  _phases
+    {
+      phase_point,
+      phase_conic,
+      phase_cubic,
+      phase_cubic2
+
+    } TPhase;
+
+    FT_Vector  v_first;
+    FT_Vector  v_last;
+    FT_Vector  v_control;
+    FT_Vector  v_start;
+
+    FT_Vector* point;
+    FT_Vector* limit;
+    char*      tags;
+
+    int    n;         /* index of contour in outline     */
+    int    first;     /* index of first point in contour */
+    int    error;
+    char   tag;       /* current point's state           */
+
+
+    first = 0;
+
+    for ( n = 0; n < outline->n_contours; n++ )
+    {
+      int  last;  /* index of last point in contour */
+
+      last  = outline->contours[n];
+      limit = outline->points + last;
+
+      v_first = outline->points[first];
+      v_last  = outline->points[last];
+
+      v_start = v_control = v_first;
+
+      point = outline->points + first;
+      tags  = outline->flags  + first;
+      tag   = FT_CURVE_TAG( tags[0] );
+
+      /* A contour cannot start with a cubic control point! */
+      if ( tag == FT_Curve_Tag_Cubic )
+        goto Invalid_Outline;
+
+      /* check first point to determine origin */
+      if ( tag == FT_Curve_Tag_Conic )
+      {
+        /* first point is conic control.  Yes, this happens. */
+        if ( FT_CURVE_TAG( outline->flags[last] ) == FT_Curve_Tag_On )
+        {
+          /* start at last point if it is on the curve */
+          v_start = v_last;
+          limit--;
+        }
+        else
+        {
+          /* if both first and last points are conic,         */
+          /* start at their middle and record its position    */
+          /* for closure                                      */
+          v_start.x = ( v_start.x + v_last.x ) / 2;
+          v_start.y = ( v_start.y + v_last.y ) / 2;
+
+          v_last = v_start;
+        }
+        point--;
+        tags--;
+      }
+
+      error = interface->move_to( &v_start, user );
+      if (error) goto Exit;
+
+      while (point < limit)
+      {
+        point++;
+        tags++;
+  
+        tag = FT_CURVE_TAG( tags[0] );
+        switch (tag)
+        {
+          case FT_Curve_Tag_On:  /* emit a single line_to */
+            {
+              error = interface->line_to( point, user );
+              if (error) goto Exit;
+              continue;
+            }
+
+          
+          case FT_Curve_Tag_Conic:  /* consume conic arcs */
+            {
+              v_control = point[0];
+              
+            Do_Conic:
+              if (point < limit)
+              {
+                FT_Vector  v_middle;
+                
+                point++;
+                tags++;
+                tag = FT_CURVE_TAG( tags[0] );
+                
+                if (tag == FT_Curve_Tag_On)
+                {
+                  error = interface->conic_to( &v_control, point, user );
+                  if (error) goto Exit;
+                  continue;
+                }
+                
+                if (tag != FT_Curve_Tag_Conic)
+                  goto Invalid_Outline;
+  
+                v_middle.x = (v_control.x + point->x)/2;
+                v_middle.y = (v_control.y + point->y)/2;
+  
+                error = interface->conic_to( &v_control, &v_middle, user );
+                if (error) goto Exit;
+                
+                v_control = point[0];
+                goto Do_Conic;
+              }
+              
+              error = interface->conic_to( &v_control, &v_start, user );
+              goto Close;
+            }
+          
+          default:  /* FT_Curve_Tag_Cubic */
+            {
+              if ( point+1 > limit         ||
+                   FT_CURVE_TAG( tags[1] ) != FT_Curve_Tag_Cubic )
+                goto Invalid_Outline;
+                
+              point += 2;
+              tags  += 2;
+              
+              if (point <= limit)
+              {
+                error = interface->cubic_to( point-2, point-1, point, user );
+                if (error) goto Exit;
+                continue;
+              }
+              
+              error = interface->cubic_to( point-2, point-1, &v_start, user );
+              goto Close;
+            }
+        }
+      }
+
+      /* close the contour with a line segment */
+      error = interface->line_to( &v_start, user );
+      
+   Close:
+      if (error) goto Exit;
+      first = last+1;
+    }
+
+    return 0;
+  Exit:
+    return error;
+    
+  Invalid_Outline:
+    return -1;
+  }
+#else
+  static
+  int  FT_Decompose_Outline( FT_Outline*        outline,
+                             FT_Outline_Funcs*  interface,
+                             void*              user )
+  {
+    typedef enum  _phases
+    {
+      phase_point,
+      phase_conic,
+      phase_cubic,
+      phase_cubic2
+
+    } TPhase;
+
+    FT_Vector  v_first;
+    FT_Vector  v_last;
+    FT_Vector  v_control;
+    FT_Vector  v_control2;
+    FT_Vector  v_start;
+
+    FT_Vector* point;
+    char*      flags;
+
+    int    n;         /* index of contour in outline     */
+    int    first;     /* index of first point in contour */
+    int    index;     /* current point's index           */
+
+    int    error;
+
+    char   tag;       /* current point's state           */
+    TPhase phase;
+
+
+    first = 0;
+
+    for ( n = 0; n < outline->n_contours; n++ )
+    {
+      int  last;  /* index of last point in contour */
+
+
+      last = outline->contours[n];
+
+      v_first = outline->points[first];
+      v_last  = outline->points[last];
+
+      v_start = v_control = v_first;
+
+      tag   = FT_CURVE_TAG( outline->flags[first] );
+      index = first;
+
+      /* A contour cannot start with a cubic control point! */
+
+      if ( tag == FT_Curve_Tag_Cubic )
+        return ErrRaster_Invalid_Outline;
+
+
+      /* check first point to determine origin */
+
+      if ( tag == FT_Curve_Tag_Conic )
+      {
+        /* first point is conic control.  Yes, this happens. */
+        if ( FT_CURVE_TAG( outline->flags[last] ) == FT_Curve_Tag_On )
+        {
+          /* start at last point if it is on the curve */
+          v_start = v_last;
+        }
+        else
+        {
+          /* if both first and last points are conic,         */
+          /* start at their middle and record its position    */
+          /* for closure                                      */
+          v_start.x = ( v_start.x + v_last.x ) / 2;
+          v_start.y = ( v_start.y + v_last.y ) / 2;
+
+          v_last = v_start;
+        }
+        phase = phase_conic;
+      }
+      else
+        phase = phase_point;
+
+
+      /* Begin a new contour with MOVE_TO */
+
+      error = interface->move_to( &v_start, user );
+      if ( error )
+        return error;
+
+      point = outline->points + first;
+      flags = outline->flags  + first;
+
+      /* now process each contour point individually */
+
+      while ( index < last )
+      {
+        index++;
+        point++;
+        flags++;
+
+        tag = FT_CURVE_TAG( flags[0] );
+
+        switch ( phase )
+        {
+        case phase_point:     /* the previous point was on the curve */
+
+          switch ( tag )
+          {
+            /* two succesive on points -> emit segment */
+          case FT_Curve_Tag_On:
+            error = interface->line_to( point, user );
+            break;
+
+            /* on point + conic control -> remember control point */
+          case FT_Curve_Tag_Conic:
+            v_control = point[0];
+            phase     = phase_conic;
+            break;
+
+            /* on point + cubic control -> remember first control */
+          default:
+            v_control = point[0];
+            phase     = phase_cubic;
+            break;
+          }
+          break;
+
+        case phase_conic:   /* the previous point was a conic control */
+
+          switch ( tag )
+          {
+            /* conic control + on point -> emit conic arc */
+          case  FT_Curve_Tag_On:
+            error = interface->conic_to( &v_control, point, user );
+            phase = phase_point;
+            break;
+
+            /* two successive conics -> emit conic arc `in between' */
+          case FT_Curve_Tag_Conic:
+            {
+              FT_Vector  v_middle;
+
+
+              v_middle.x = (v_control.x + point->x)/2;
+              v_middle.y = (v_control.y + point->y)/2;
+
+              error = interface->conic_to( &v_control,
+                                           &v_middle, user );
+              v_control = point[0];
+            }
+             break;
+
+          default:
+            error = ErrRaster_Invalid_Outline;
+          }
+          break;
+
+        case phase_cubic:  /* the previous point was a cubic control */
+
+          /* this point _must_ be a cubic control too */
+          if ( tag != FT_Curve_Tag_Cubic )
+            return ErrRaster_Invalid_Outline;
+
+          v_control2 = point[0];
+          phase      = phase_cubic2;
+          break;
+
+
+        case phase_cubic2:  /* the two previous points were cubics */
+
+          /* this point _must_ be an on point */
+          if ( tag != FT_Curve_Tag_On )
+            error = ErrRaster_Invalid_Outline;
+          else
+            error = interface->cubic_to( &v_control, &v_control2,
+                                         point, user );
+          phase = phase_point;
+          break;
+        }
+
+        /* lazy error testing */
+        if ( error )
+          return error;
+      }
+
+      /* end of contour, close curve cleanly */
+      error = 0;
+
+      tag = FT_CURVE_TAG( outline->flags[first] );
+
+      switch ( phase )
+      {
+      case phase_point:
+        if ( tag == FT_Curve_Tag_On )
+          error = interface->line_to( &v_first, user );
+        break;
+
+      case phase_conic:
+        error = interface->conic_to( &v_control, &v_start, user );
+        break;
+
+      case phase_cubic2:
+        if ( tag == FT_Curve_Tag_On )
+          error = interface->cubic_to( &v_control, &v_control2,
+                                       &v_first,   user );
+        else
+          error = ErrRaster_Invalid_Outline;
+        break;
+
+      default:
+        error = ErrRaster_Invalid_Outline;
+        break;
+      }
+
+      if ( error )
+        return error;
+
+      first = last + 1;
+    }
+
+    return 0;
+  }
+
+#endif
+
+  static
+  int  Move_To( FT_Vector*  to,
+                FT_Raster   raster )
+  {
+    /* record current cell, if any */
+    record_cell( (PRaster)raster );
+    
+    /* start to a new position */
+    start_cell( (PRaster)raster, TRUNC(to->x), TRUNC(to->y) );
+    ((PRaster)raster)->x = to->x;
+    ((PRaster)raster)->y = to->y;
+    return 0;
+  }
+  
+
+  static
+  int  Line_To( FT_Vector*  to,
+                FT_Raster   raster )
+  {
+    return render_line( (PRaster)raster, to->x, to->y );
+  }
+
+
+  static
+  int  Conic_To( FT_Vector*  control,
+                 FT_Vector*  to,
+                 FT_Raster   raster )
+  {
+    return render_conic( (PRaster)raster, control, to );
+  }
+
+
+  static
+  int  Cubic_To( FT_Vector*  control1,
+                 FT_Vector*  control2,
+                 FT_Vector*  to,
+                 FT_Raster   raster )
+  {
+    return render_cubic( (PRaster)raster, control1, control2, to );
+  }
+
+
+  static
+  void grays_render_span( int y, int count, FT_GraySpan*  spans, PRaster  raster )
+  {
+    unsigned char *p, *q, *limit;
+    FT_Bitmap*    map = &raster->target;
+    /* first of all, compute the scanline offset */
+    p = (unsigned char*)map->buffer - y*map->pitch;
+    if (map->pitch >= 0)
+      p += (map->rows-1)*map->pitch;
+    
+    for ( ; count > 0; count--, spans++ )
+    {
+      if (spans->coverage)
+      {
+        q     = p + spans->x;
+        limit = q + spans->len;
+        for ( ; q < limit; q++ )
+          q[0] = (spans->coverage+1) >> 1;
+      }
+    }
+  }
+
+#ifdef DEBUG_GRAYS
+#include <stdio.h>
+
+  static
+  void  dump_cells( RAS_ARG )
+  {
+    PCell  cell, limit;
+    int    y = -1;
+    
+    cell = ras.cells;
+    limit = cell + ras.num_cells;
+    for ( ; cell < limit; cell++ )
+    {
+      if ( cell->y != y )
+      {
+        fprintf( stderr, "\n%2d: ", cell->y );
+        y = cell->y;
+      }
+      fprintf( stderr, "[%d %d %d]",
+               cell->x, cell->area, cell->cover );
+    }
+    fprintf(stderr, "\n" );
+  }
+#endif
+  
+#if 0
+  static
+  void  grays_hline( RAS_ARG_  TScan  x, TScan y, TPos  area, int  count )
+  {
+    if (area)
+      fprintf( stderr, "hline( %3d, %3d, %2d, %5.2f )\n",
+               y, x, count, (float)area/(2.0*ONE_PIXEL*ONE_PIXEL) );
+  }
+#else
+  static
+  void  grays_hline( RAS_ARG_  TScan  x, TScan y, TPos  area, int acount )
+  {
+    FT_GraySpan*   span;
+    int            count;
+    int            coverage;
+    
+    /* compute the coverage line's coverage, depending on the    */
+    /* outline fill rule..                                       */
+    /*                                                           */
+    /* The coverage percentage is area/(PIXEL_BITS*PIXEL_BITS*2) */
+    /*                                                           */
+    
+    coverage = area >> (PIXEL_BITS*2+1-8);  /* use range 0..256 */
+    if ( ras.outline.outline_flags & ft_outline_even_odd_fill )
+    {
+      if (coverage < 0)
+        coverage = -coverage;
+      
+      while (coverage >= 512)
+        coverage -= 512;
+        
+      if (coverage > 256)
+        coverage = 0;
+      else if (coverage == 256)
+        coverage = 255;
+    }
+    else
+    {
+      /* normal non-zero winding rule */
+      if (coverage < 0)
+        coverage = -coverage;
+      
+      if (coverage >= 256)
+        coverage = 255;
+    }
+    
+    if (area)
+    {
+      /* see if we can add this span to the current list */
+      count = ras.num_gray_spans;
+      span  = ras.gray_spans + count-1;
+      if (count > 0 && ras.span_y == y && (int)span->x + span->len == (int)x &&
+          span->coverage == coverage)
+      {
+        span->len += acount;
+        return;
+      }
+      
+      if ( ras.span_y != y || count >= FT_MAX_GRAY_SPANS)
+      {
+        if (ras.render_span)
+          ras.render_span( ras.span_y, count, ras.gray_spans, ras.render_span_closure );
+        /* ras.render_span( span->y, ras.gray_spans, count ); */
+      
+#ifdef DEBUG_GRAYS      
+        if (ras.span_y >= 0)
+        {
+        int  n;
+        fprintf( stderr, "y=%3d ", ras.span_y );
+        span = ras.gray_spans;
+        for (n = 0; n < count; n++, span++)
+          fprintf( stderr, "[%d..%d]:%02x ", span->x, span->x + span->len-1, span->coverage );
+        fprintf( stderr, "\n" );
+        }
+#endif
+        
+        ras.num_gray_spans = 0;
+        ras.span_y         = y;
+        
+        count = 0;
+        span  = ras.gray_spans;
+      }
+      else
+        span++;
+      
+      /* add a gray span to the current list */
+      span->x        = (short)x;
+      span->len      = (unsigned char)acount;
+      span->coverage = (unsigned char)coverage;
+      ras.num_gray_spans++;
+    }
+  }
+#endif
+
+  static
+  void  grays_sweep( RAS_ARG_  FT_Bitmap*  target )
+  {
+    TScan  x, y, cover;
+    PCell  start, cur, limit;
+
+    cur   = ras.cells;
+    limit = cur + ras.num_cells;
+
+    cover = 0;
+    ras.span_y = -1;
+    ras.num_gray_spans = 0;
+    
+    for (;;)
+    {
+      start = cur;
+      y     = start->y;
+      x     = start->x;
+    
+      /* accumulate all start cells */
+      for (;;)
+      {
+        ++cur;
+        if (cur >= limit || cur->y != start->y || cur->x != start->x)
+          break;
+        start->area  += cur->area;
+        start->cover += cur->cover;
+      }
+      
+      /* compute next cover */
+      cover += start->cover;
+
+      /* if the start cell has a non-null area, we must draw an */
+      /* individual gray pixel there..                          */
+      if (start->area && x >= 0)
+      {
+        grays_hline( RAS_VAR_ x, y, cover*(ONE_PIXEL*2)-start->area, 1 );
+        x++;
+      }
+      
+      if (x < 0)
+        x = 0;
+        
+      if (cur < limit && start->y == cur->y)
+      {
+        /* draw a gray span between the start cell and the current one */
+        if (cur->x > x)
+          grays_hline( RAS_VAR_ x, y, cover*(ONE_PIXEL*2), cur->x - x );
+      }
+      else
+      {
+        /* draw a gray span until the end of the clipping region */
+        if (cover && x < ras.max_ex)
+          grays_hline( RAS_VAR_ x, y, cover*(ONE_PIXEL*2), ras.max_ex - x );
+        cover = 0;
+      }
+      
+      if (cur >= limit)
+        break;
+    }
+
+    if (ras.render_span && ras.num_gray_spans > 0)
+      ras.render_span( ras.span_y, ras.num_gray_spans,
+                       ras.gray_spans, ras.render_span_closure );
+#ifdef DEBUG_GRAYS
+    {
+      int  n;
+      FT_GraySpan*  span;
+      
+      fprintf( stderr, "y=%3d ", ras.span_y );
+      span = ras.gray_spans;
+      for (n = 0; n < ras.num_gray_spans; n++, span++)
+        fprintf( stderr, "[%d..%d]:%02x ", span->x, span->x+span->len-1,span->coverage );
+      fprintf( stderr, "\n" );
+    }
+#endif
+  }
+  
+  static
+  int  Convert_Glyph( RAS_ARG_ FT_Outline*  outline )
+  {
+    static
+    FT_Outline_Funcs  interface =
+    {
+      (FT_Outline_MoveTo_Func)Move_To,
+      (FT_Outline_LineTo_Func)Line_To,
+      (FT_Outline_ConicTo_Func)Conic_To,
+      (FT_Outline_CubicTo_Func)Cubic_To
+    };
+
+    /* Set up state in the raster object */
+    compute_cbox( RAS_VAR_ outline );
+    if (ras.min_ex < 0) ras.min_ex = 0;
+    if (ras.min_ey < 0) ras.min_ey = 0;
+    
+    if (ras.max_ex > ras.target.width) ras.max_ex = ras.target.width;
+    if (ras.max_ey > ras.target.rows)  ras.max_ey = ras.target.rows;
+    
+    ras.num_cells = 0;
+
+    /* Now decompose curve */
+    if ( FT_Decompose_Outline( outline, &interface, &ras ) )
+      return 1;
+    /* XXX: the error condition is in ras.error */
+
+    /* record the last cell */
+    return record_cell( RAS_VAR );
+  }
+
+
+  extern
+  int  grays_raster_render( TRaster*     raster,
+                            FT_Outline*  outline,
+                            FT_Bitmap*   target_map )
+  {
+    if ( !raster || !raster->cells || !raster->max_cells )
+      return -1;
+
+    /* return immediately if the outline is empty */
+    if ( outline->n_points == 0 || outline->n_contours <= 0 )
+      return 0;
+
+    if ( !outline || !outline->contours || !outline->points )
+      return -1;
+
+    if ( outline->n_points != outline->contours[outline->n_contours - 1] + 1 )
+      return -1;
+
+    if ( !target_map || !target_map->buffer )
+      return -1;
+
+    ras.outline   = *outline;
+    ras.target    = *target_map;
+    ras.num_cells = 0;
+    ras.invalid   = 1;
+
+    if (Convert_Glyph( (PRaster)raster, outline ))
+      return 1;
+      
+    shell_sort( ras.cells, ras.num_cells );
+    
+#ifdef DEBUG_GRAYS    
+    check_sort( ras.cells, ras.num_cells );
+    dump_cells( RAS_VAR );
+#endif
+    ras.render_span         = (FT_GraySpan_Func)grays_render_span;
+    ras.render_span_closure = &ras;
+    
+    grays_sweep( (PRaster)raster, target_map );    
+    return 0;
+  }
+
+
+
+
+
+
+  extern
+  int  grays_raster_init( FT_Raster    raster,
+                          const char*  pool_base,
+                          long         pool_size )
+  {
+/*    static const char  default_palette[5] = { 0, 1, 2, 3, 4 }; */
+
+    /* check the object address */
+    if ( !raster )
+      return -1;
+
+    /* check the render pool - we won't go under 4 Kb */
+    if ( !pool_base || pool_size < 4096 )
+      return -1;
+
+    /* save the pool */
+    init_cells( (PRaster)raster, (char*)pool_base, pool_size );
+
+    return 0;
+  }
+
+
+
+  FT_Raster_Interface  ft_grays_raster =
+  {
+    sizeof( TRaster ),
+    ft_glyph_format_outline,
+
+    (FT_Raster_Init_Proc)     grays_raster_init,
+    (FT_Raster_Set_Mode_Proc) 0,
+    (FT_Raster_Render_Proc)   grays_raster_render
+  };
+
+
diff --git a/demos/src/ftgrays.h b/demos/src/ftgrays.h
new file mode 100644
index 0000000..5e9eb00
--- /dev/null
+++ b/demos/src/ftgrays.h
@@ -0,0 +1,78 @@
+#ifndef FTGRAYS_H
+#define FTGRAYS_H
+
+typedef int   TScan;
+typedef long  TPos;
+typedef float TDist;
+
+#define FT_MAX_GRAY_SPANS  32
+
+typedef struct FT_GraySpan_
+{
+  short          x;
+  short          len;
+  unsigned char  coverage;
+
+} FT_GraySpan;
+
+typedef int (*FT_GraySpan_Func)( int           y,
+                                 int           count,
+                                 FT_GraySpan*  spans,
+                                 void*         user );
+                                        
+
+typedef struct TCell_
+{
+  TScan  x;
+  TScan  y;
+  int    area;
+  int    cover;
+
+} TCell, *PCell;
+
+
+typedef struct TRaster_
+{
+  PCell   cells;
+  int     max_cells;
+  int     num_cells;
+
+  TScan   min_ex, max_ex;
+  TScan   min_ey, max_ey;
+
+  int     area;
+  int     cover;
+  int     invalid;
+
+  TScan   ex, ey;
+  TScan   cx, cy;
+  TPos    x,  y;
+
+  TScan   last_ey;
+
+  FT_Vector   bez_stack[32*3];
+  int         lev_stack[32];
+
+  FT_Outline  outline;
+  FT_Bitmap   target;
+
+  FT_GraySpan gray_spans[ FT_MAX_GRAY_SPANS ];
+  int         num_gray_spans;
+
+  FT_GraySpan_Func  render_span;
+  void*             render_span_closure;
+  int               span_y;
+
+} TRaster, *PRaster;
+
+  extern
+  int  grays_raster_render( TRaster*     raster,
+                            FT_Outline*  outline,
+                            FT_Bitmap*   target_map );
+
+  extern
+  int  grays_raster_init( FT_Raster    raster,
+                          const char*  pool_base,
+                          long         pool_size );
+
+#endif
diff --git a/demos/src/fttimer.c b/demos/src/fttimer.c
index 8aaf6bd..ff9a5a9 100644
--- a/demos/src/fttimer.c
+++ b/demos/src/fttimer.c
@@ -28,6 +28,7 @@
 #include <time.h>    /* for clock() */
 
 #include "graph.h"
+#include "ftgrays.h"
 
 /* SunOS 4.1.* does not define CLOCKS_PER_SEC, so include <sys/param.h> */
 /* to get the HZ macro which is the equivalent.                         */
@@ -66,6 +67,7 @@
   
   int             pixel_size   = CHARSIZE;
   int             repeat_count = 1;
+  int             use_grays    = 0;
 
   FT_Bitmap      Bit;
   grBitmap       bit;
@@ -79,6 +81,11 @@
   short  gray_render; /* smooth fonts with gray levels  */
   short  force_low;
 
+  TRaster  raster;
+  
+#define RASTER_BUFF_SIZE   128000
+  char     raster_buff[ RASTER_BUFF_SIZE ];
+
 
   static void Clear_Buffer();
 
@@ -212,7 +219,10 @@
   FT_Error  ConvertRaster( int  index )
   {
     outlines[index].outline_flags |= ~ft_outline_single_pass;
-    return FT_Get_Outline_Bitmap( library, &outlines[index], &Bit );
+    if (use_grays)
+      return grays_raster_render( &raster, &outlines[index], &Bit );
+    else
+      return FT_Get_Outline_Bitmap( library, &outlines[index], &Bit );
   }
 
 
@@ -226,6 +236,7 @@
       fprintf( stderr, "   -s : character pixel size (default is 600)\n" );
       fprintf( stderr, "   -v : display results..\n" );
       fprintf( stderr, "   -g : render anti-aliased glyphs\n" );
+      fprintf( stderr, "   -a : use smooth anti-aliaser\n" );
       fprintf( stderr, "   -l : force low quality even at small sizes\n" );
       exit(1);
   }
@@ -256,6 +267,10 @@
         gray_render = 1;
         break;
 
+      case 'a':
+        use_grays = 1;
+        break;
+        
       case 'l':
         force_low = 1;
         break;
@@ -318,6 +333,9 @@
     if ( (error = FT_Init_FreeType( &library )) )
       Panic( "Error while initializing engine" );
 
+    error = grays_raster_init( (FT_Raster)&raster, (const char*)raster_buff, RASTER_BUFF_SIZE );
+    if (error) Panic( "Could not initialize smooth anti-aliasing renderer" );
+    
     /* Load face */
 
     error = FT_New_Face( library, filename, 0, &face );
diff --git a/demos/src/ftview.c b/demos/src/ftview.c
index 1390b7f..1a7aed6 100644
--- a/demos/src/ftview.c
+++ b/demos/src/ftview.c
@@ -27,6 +27,8 @@
 #include "graph.h"
 #include "grfont.h"
 
+#include "ftgrays.h"
+
 #define  DIM_X   500
 #define  DIM_Y   400
 
@@ -71,6 +73,12 @@
   int  graph_init = 0;
 
   int  render_mode = 1;
+  int  use_grays   = 1;
+
+  TRaster  raster;
+  
+#define RASTER_BUFF_SIZE   32768
+  char     raster_buff[ RASTER_BUFF_SIZE ];
 
 #define DEBUGxxx
 
@@ -137,7 +145,7 @@
   static
   char   bit_buffer[ MAX_BUFFER ];
   
-  /* Render a single glyph */
+  /* Render a single glyph with the "grays" component */
   static FT_Error  Render_Glyph( int  x_offset,
                                  int  y_offset )
   {
@@ -182,8 +190,11 @@
 
       if (low_prec)
         glyph->outline.outline_flags &= ~ft_outline_high_precision;
-        
-      FT_Get_Outline_Bitmap( library, &glyph->outline, &bit2 );
+      
+      if (use_grays & gray_render)
+        error = grays_raster_render( &raster, &glyph->outline, &bit2 );
+      else
+        error = FT_Get_Outline_Bitmap( library, &glyph->outline, &bit2 );
     }
     else
     {
@@ -207,7 +218,6 @@
     return 0;
   }
 
-
   static FT_Error  Reset_Scale( int  pointSize )
   {
     FT_Error  error;
@@ -258,7 +268,7 @@
 
     i = first_glyph;
 
-    while ( i < num_glyphs )
+     while ( i < num_glyphs )
     {
       if ( !(error = LoadChar( i, hinted )) )
       {
@@ -381,6 +391,7 @@
     grWriteln("  h         : toggle outline hinting" );
     grWriteln("  b         : toggle embedded bitmaps" );
     grWriteln("  l         : toggle low precision rendering" );
+    grWriteln("  g         : toggle between 'smooth' and 'standard' anti-aliaser" );
     grWriteln("  space     : toggle rendering mode" );
     grLn();
     grWriteln("  Up        : increase pointsize by 1 unit" );
@@ -434,6 +445,13 @@
     case grKEY('p'):
       return (int)event->key;
 
+    case grKEY('g'):
+      use_grays = !use_grays;
+      new_header = ( use_grays
+                   ? "now using the smooth anti-aliaser"
+                   : "now using the standard anti-aliaser" );
+      break;
+                   
     case grKEY('l'):
       low_prec = !low_prec;
       new_header = ( low_prec
@@ -579,6 +597,9 @@
     error = FT_Init_FreeType( &library );
     if (error) PanicZ( "Could not initialise FreeType library" );
 
+    error = grays_raster_init( (FT_Raster)&raster, (const char*)raster_buff, RASTER_BUFF_SIZE );
+    if (error) PanicZ( "Could not initialize anti-aliasing renderer" );
+
 /*    FT_Set_Raster_Palette( library, 17, palette_17 ); */
 
   NewFile: