Attachment 72883 Details for Bug 157441

[patch] new patch with correct code range.

freetype-2.1.10-autofit-backport.diff (text/plain), 93.77 KB, created by Zhe Su on 2006-03-15 02:55:51 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Zhe Su

Created: 2006-03-15 02:55:51 UTC

Size: 93.77 KB

patch

obsolete

>diff -urN freetype-2.1.10.old/devel/ftoption.h freetype-2.1.10.autofit-backport/devel/ftoption.h
>--- freetype-2.1.10.old/devel/ftoption.h	2005-04-06 22:44:17.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/devel/ftoption.h	2006-03-14 23:14:28.000000000 +0800
>@@ -547,6 +547,22 @@
>   /*                                                                       */
> #undef T1_CONFIG_OPTION_NO_MM_SUPPORT
> 
>+  /*************************************************************************/
>+  /*************************************************************************/
>+  /****                                                                 ****/
>+  /****    A U T O F I T   M O D U L E    C O N F I G U R A T I O N     ****/
>+  /****                                                                 ****/
>+  /*************************************************************************/
>+  /*************************************************************************/
>+
>+
>+  /*************************************************************************/
>+  /*                                                                       */
>+  /* Compile autofit module with CJK script support.                       */
>+  /*                                                                       */
>+#define AF_CONFIG_OPTION_CJK
>+
>+
>  /* */
> 
> /*
>diff -urN freetype-2.1.10.old/include/freetype/config/ftoption.h freetype-2.1.10.autofit-backport/include/freetype/config/ftoption.h
>--- freetype-2.1.10.old/include/freetype/config/ftoption.h	2006-03-14 23:07:13.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/include/freetype/config/ftoption.h	2006-03-14 23:15:19.000000000 +0800
>@@ -547,6 +547,21 @@
>   /*                                                                       */
> #undef T1_CONFIG_OPTION_NO_MM_SUPPORT
> 
>+  /*************************************************************************/
>+  /*************************************************************************/
>+  /****                                                                 ****/
>+  /****    A U T O F I T   M O D U L E    C O N F I G U R A T I O N     ****/
>+  /****                                                                 ****/
>+  /*************************************************************************/
>+  /*************************************************************************/
>+
>+
>+  /*************************************************************************/
>+  /*                                                                       */
>+  /* Compile autofit module with CJK script support.                       */
>+  /*                                                                       */
>+#define AF_CONFIG_OPTION_CJK
>+
>  /* */
> 
> /*
>diff -urN freetype-2.1.10.old/include/freetype/internal/ftgloadr.h freetype-2.1.10.autofit-backport/include/freetype/internal/ftgloadr.h
>--- freetype-2.1.10.old/include/freetype/internal/ftgloadr.h	2003-12-12 23:38:39.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/include/freetype/internal/ftgloadr.h	2006-03-14 23:19:51.000000000 +0800
>@@ -117,6 +117,23 @@
>                               FT_UInt         n_points,
>                               FT_UInt         n_contours );
> 
>+#define FT_GLYPHLOADER_CHECK_P( _loader, _count )                    \
>+   ( (_count) == 0 || (int)((_loader)->base.outline.n_points    +    \
>+                            (_loader)->current.outline.n_points +    \
>+                            (_count)) <= (int)(_loader)->max_points )
>+
>+#define FT_GLYPHLOADER_CHECK_C( _loader, _count )                     \
>+  ( (_count) == 0 || (int)((_loader)->base.outline.n_contours    +    \
>+                           (_loader)->current.outline.n_contours +    \
>+                           (_count)) <= (int)(_loader)->max_contours )
>+
>+#define FT_GLYPHLOADER_CHECK_POINTS( _loader, _points,_contours )      \
>+  ( ( FT_GLYPHLOADER_CHECK_P( _loader, _points )   &&                  \
>+      FT_GLYPHLOADER_CHECK_C( _loader, _contours ) )                   \
>+    ? 0                                                                \
>+    : FT_GlyphLoader_CheckPoints( (_loader), (_points), (_contours) ) )
>+
>+
>   /* check that there is enough space to add `n_subs' sub-glyphs to */
>   /* a glyph loader                                                 */
>   FT_BASE( FT_Error )
>diff -urN freetype-2.1.10.old/src/autofit/afangles.c freetype-2.1.10.autofit-backport/src/autofit/afangles.c
>--- freetype-2.1.10.old/src/autofit/afangles.c	2005-03-03 23:09:12.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/afangles.c	2006-03-14 23:10:46.000000000 +0800
>@@ -20,6 +20,112 @@
> #include "aftypes.h"
> 
> 
>+#if 1
>+
>+  /* the following table has been automatically generated with */
>+  /* the `mather.py' Python script                             */
>+
>+#define AF_ATAN_BITS  8
>+
>+  static const FT_Byte  af_arctan[1L << AF_ATAN_BITS] =
>+  {
>+     0,  0,  1,  1,  1,  2,  2,  2,
>+     3,  3,  3,  3,  4,  4,  4,  5,
>+     5,  5,  6,  6,  6,  7,  7,  7,
>+     8,  8,  8,  9,  9,  9, 10, 10,
>+    10, 10, 11, 11, 11, 12, 12, 12,
>+    13, 13, 13, 14, 14, 14, 14, 15,
>+    15, 15, 16, 16, 16, 17, 17, 17,
>+    18, 18, 18, 18, 19, 19, 19, 20,
>+    20, 20, 21, 21, 21, 21, 22, 22,
>+    22, 23, 23, 23, 24, 24, 24, 24,
>+    25, 25, 25, 26, 26, 26, 26, 27,
>+    27, 27, 28, 28, 28, 28, 29, 29,
>+    29, 30, 30, 30, 30, 31, 31, 31,
>+    31, 32, 32, 32, 33, 33, 33, 33,
>+    34, 34, 34, 34, 35, 35, 35, 35,
>+    36, 36, 36, 36, 37, 37, 37, 38,
>+    38, 38, 38, 39, 39, 39, 39, 40,
>+    40, 40, 40, 41, 41, 41, 41, 42,
>+    42, 42, 42, 42, 43, 43, 43, 43,
>+    44, 44, 44, 44, 45, 45, 45, 45,
>+    46, 46, 46, 46, 46, 47, 47, 47,
>+    47, 48, 48, 48, 48, 48, 49, 49,
>+    49, 49, 50, 50, 50, 50, 50, 51,
>+    51, 51, 51, 51, 52, 52, 52, 52,
>+    52, 53, 53, 53, 53, 53, 54, 54,
>+    54, 54, 54, 55, 55, 55, 55, 55,
>+    56, 56, 56, 56, 56, 57, 57, 57,
>+    57, 57, 57, 58, 58, 58, 58, 58,
>+    59, 59, 59, 59, 59, 59, 60, 60,
>+    60, 60, 60, 61, 61, 61, 61, 61,
>+    61, 62, 62, 62, 62, 62, 62, 63,
>+    63, 63, 63, 63, 63, 64, 64, 64
>+  };
>+
>+
>+  FT_LOCAL_DEF( AF_Angle )
>+  af_angle_atan( FT_Fixed  dx,
>+                 FT_Fixed  dy )
>+  {
>+    AF_Angle  angle;
>+
>+
>+    /* check trivial cases */
>+    if ( dy == 0 )
>+    {
>+      angle = 0;
>+      if ( dx < 0 )
>+        angle = AF_ANGLE_PI;
>+      return angle;
>+    }
>+    else if ( dx == 0 )
>+    {
>+      angle = AF_ANGLE_PI2;
>+      if ( dy < 0 )
>+        angle = -AF_ANGLE_PI2;
>+      return angle;
>+    }
>+
>+    angle = 0;
>+    if ( dx < 0 )
>+    {
>+      dx = -dx;
>+      dy = -dy;
>+      angle = AF_ANGLE_PI;
>+    }
>+
>+    if ( dy < 0 )
>+    {
>+      FT_Pos  tmp;
>+
>+
>+      tmp = dx;
>+      dx  = -dy;
>+      dy  = tmp;
>+      angle -= AF_ANGLE_PI2;
>+    }
>+
>+    if ( dx == 0 && dy == 0 )
>+      return 0;
>+
>+    if ( dx == dy )
>+      angle += AF_ANGLE_PI4;
>+    else if ( dx > dy )
>+      angle += af_arctan[FT_DivFix( dy, dx ) >> ( 16 - AF_ATAN_BITS )];
>+    else
>+      angle += AF_ANGLE_PI2 -
>+               af_arctan[FT_DivFix( dx, dy ) >> ( 16 - AF_ATAN_BITS )];
>+
>+    if ( angle > AF_ANGLE_PI )
>+      angle -= AF_ANGLE_2PI;
>+
>+    return angle;
>+  }
>+
>+
>+#else /* 0 */
>+
> /*
>  * a python script used to generate the following table
>  *
>@@ -234,6 +340,8 @@
>     return delta;
>   }
> 
>+#endif /* 0 */
>+
> 
>   FT_LOCAL_DEF( void )
>   af_sort_pos( FT_UInt  count,
>diff -urN freetype-2.1.10.old/src/autofit/afcjk.c freetype-2.1.10.autofit-backport/src/autofit/afcjk.c
>--- freetype-2.1.10.old/src/autofit/afcjk.c	1970-01-01 08:00:00.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/afcjk.c	2006-03-15 10:51:45.000000000 +0800
>@@ -0,0 +1,1507 @@
>+/***************************************************************************/
>+/*                                                                         */
>+/*  afcjk.c                                                                */
>+/*                                                                         */
>+/*    Auto-fitter hinting routines for CJK script (body).                  */
>+/*                                                                         */
>+/*  Copyright 2006 by                                                      */
>+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
>+/*                                                                         */
>+/*  This file is part of the FreeType project, and may only be used,       */
>+/*  modified, and distributed under the terms of the FreeType project      */
>+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
>+/*  this file you indicate that you have read the license and              */
>+/*  understand and accept it fully.                                        */
>+/*                                                                         */
>+/***************************************************************************/
>+
>+  /*
>+   *  The algorithm is based on akito's autohint patch, available here:
>+   *
>+   *  http://www.kde.gr.jp/~akito/patch/freetype2/
>+   *
>+   */
>+
>+#include "aftypes.h"
>+#include "aflatin.h"
>+
>+
>+#ifdef AF_CONFIG_OPTION_CJK
>+
>+#include "afcjk.h"
>+#include "aferrors.h"
>+
>+
>+#ifdef AF_USE_WARPER
>+#include "afwarp.h"
>+#endif
>+
>+
>+  /*************************************************************************/
>+  /*************************************************************************/
>+  /*****                                                               *****/
>+  /*****              C J K   G L O B A L   M E T R I C S              *****/
>+  /*****                                                               *****/
>+  /*************************************************************************/
>+  /*************************************************************************/
>+
>+  static FT_Error
>+  af_cjk_metrics_init( AF_LatinMetrics  metrics,
>+                       FT_Face          face )
>+  {
>+    FT_CharMap  oldmap = face->charmap;
>+
>+
>+    metrics->units_per_em = face->units_per_EM;
>+
>+    /* TODO are there blues? */
>+
>+    if ( FT_Select_Charmap( face, FT_ENCODING_UNICODE ) )
>+      face->charmap = NULL;
>+
>+    /* latin's version would suffice */
>+    af_latin_metrics_init_widths( metrics, face, 0x7530 );
>+
>+    FT_Set_Charmap( face, oldmap );
>+
>+    return AF_Err_Ok;
>+  }
>+
>+
>+  static void
>+  af_cjk_metrics_scale_dim( AF_LatinMetrics  metrics,
>+                            AF_Scaler        scaler,
>+                            AF_Dimension     dim )
>+  {
>+    AF_LatinAxis  axis;
>+
>+
>+    axis = &metrics->axis[dim];
>+
>+    if ( dim == AF_DIMENSION_HORZ )
>+    {
>+      axis->scale = scaler->x_scale;
>+      axis->delta = scaler->x_delta;
>+    }
>+    else
>+    {
>+      axis->scale = scaler->y_scale;
>+      axis->delta = scaler->y_delta;
>+    }
>+  }
>+
>+
>+  static void
>+  af_cjk_metrics_scale( AF_LatinMetrics  metrics,
>+                        AF_Scaler        scaler )
>+  {
>+    metrics->root.scaler = *scaler;
>+
>+    af_cjk_metrics_scale_dim( metrics, scaler, AF_DIMENSION_HORZ );
>+    af_cjk_metrics_scale_dim( metrics, scaler, AF_DIMENSION_VERT );
>+  }
>+
>+
>+  /*************************************************************************/
>+  /*************************************************************************/
>+  /*****                                                               *****/
>+  /*****              C J K   G L Y P H   A N A L Y S I S              *****/
>+  /*****                                                               *****/
>+  /*************************************************************************/
>+  /*************************************************************************/
>+
>+  static FT_Error
>+  af_cjk_hints_compute_segments( AF_GlyphHints  hints,
>+                                 AF_Dimension   dim )
>+  {
>+    AF_AxisHints  axis          = &hints->axis[dim];
>+    AF_Segment    segments      = axis->segments;
>+    AF_Segment    segment_limit = segments + axis->num_segments;
>+    FT_Error      error;
>+    AF_Segment    seg;
>+
>+
>+    error = af_latin_hints_compute_segments( hints, dim );
>+    if ( error )
>+      return error;
>+
>+    /* a segment is round if it doesn't have successive */
>+    /* on-curve points.                                 */
>+    for ( seg = segments; seg < segment_limit; seg++ )
>+    {
>+      AF_Point  pt   = seg->first;
>+      AF_Point  last = seg->last;
>+      AF_Flags  f0   = (AF_Flags)(pt->flags & AF_FLAG_CONTROL);
>+      AF_Flags  f1;
>+
>+
>+      seg->flags &= ~AF_EDGE_ROUND;
>+
>+      for ( ; pt != last; f0 = f1 )
>+      {
>+        pt = pt->next;
>+        f1 = (AF_Flags)(pt->flags & AF_FLAG_CONTROL);
>+
>+        if ( !f0 && !f1 )
>+          break;
>+
>+        if ( pt == last )
>+          seg->flags |= AF_EDGE_ROUND;
>+      }
>+    }
>+
>+    return AF_Err_Ok;
>+  }
>+
>+
>+  static void
>+  af_cjk_hints_link_segments( AF_GlyphHints  hints,
>+                              AF_Dimension   dim )
>+  {
>+    AF_AxisHints  axis          = &hints->axis[dim];
>+    AF_Segment    segments      = axis->segments;
>+    AF_Segment    segment_limit = segments + axis->num_segments;
>+    AF_Direction  major_dir     = axis->major_dir;
>+    AF_Segment    seg1, seg2;
>+    FT_UShort     len_threshold;
>+    FT_Pos        dist_threshold;
>+
>+
>+    len_threshold = AF_LATIN_CONSTANT( hints->metrics, 8 );
>+
>+    dist_threshold = ( dim == AF_DIMENSION_HORZ ) ? hints->x_scale
>+                                                  : hints->y_scale;
>+    dist_threshold = FT_DivFix( 64 * 3, dist_threshold );
>+
>+    /* now compare each segment to the others */
>+    for ( seg1 = segments; seg1 < segment_limit; seg1++ )
>+    {
>+      /* the fake segments are for metrics hinting only */
>+      if ( seg1->first == seg1->last )
>+        continue;
>+
>+      if ( seg1->dir != major_dir )
>+        continue;
>+
>+      for ( seg2 = segments; seg2 < segment_limit; seg2++ )
>+        if ( seg2 != seg1 && seg1->dir + seg2->dir == 0 )
>+        {
>+          FT_Pos  dist = seg2->pos - seg1->pos;
>+
>+
>+          if ( dist < 0 )
>+            continue;
>+
>+          {
>+            FT_Pos  min = seg1->min_coord;
>+            FT_Pos  max = seg1->max_coord;
>+            FT_Pos  len;
>+
>+
>+            if ( min < seg2->min_coord )
>+              min = seg2->min_coord;
>+
>+            if ( max > seg2->max_coord )
>+              max = seg2->max_coord;
>+
>+            len = max - min;
>+            if ( len >= len_threshold )
>+            {
>+              if ( dist * 8 < seg1->score * 9                        &&
>+                   ( dist * 8 < seg1->score * 7 || seg1->len < len ) )
>+              {
>+                seg1->score = dist;
>+                seg1->len   = len;
>+                seg1->link  = seg2;
>+              }
>+
>+              if ( dist * 8 < seg2->score * 9                        &&
>+                   ( dist * 8 < seg2->score * 7 || seg2->len < len ) )
>+              {
>+                seg2->score = dist;
>+                seg2->len   = len;
>+                seg2->link  = seg1;
>+              }
>+            }
>+          }
>+        }
>+    }
>+
>+    /*
>+     *  now compute the `serif' segments
>+     *
>+     *  In Hanzi, some strokes are wider on one or both of the ends.
>+     *  We either identify the stems on the ends as serifs or remove
>+     *  the linkage, depending on the length of the stems.
>+     *
>+     */
>+
>+    {
>+      AF_Segment  link1, link2;
>+
>+
>+      for ( seg1 = segments; seg1 < segment_limit; seg1++ )
>+      {
>+        link1 = seg1->link;
>+        if ( !link1 || link1->link != seg1 || link1->pos <= seg1->pos )
>+          continue;
>+
>+        if ( seg1->score >= dist_threshold )
>+          continue;
>+
>+        for ( seg2 = segments; seg2 < segment_limit; seg2++ )
>+        {
>+          if ( seg2->pos > seg1->pos || seg1 == seg2 )
>+            continue;
>+
>+          link2 = seg2->link;
>+          if ( !link2 || link2->link != seg2 || link2->pos < link1->pos )
>+            continue;
>+
>+          if ( seg1->pos == seg2->pos && link1->pos == link2->pos )
>+            continue;
>+
>+          if ( seg2->score <= seg1->score || seg1->score * 4 <= seg2->score )
>+            continue;
>+
>+          /* seg2 < seg1 < link1 < link2 */
>+
>+          if ( seg1->len >= seg2->len * 3 )
>+          {
>+            AF_Segment  seg;
>+
>+
>+            for ( seg = segments; seg < segment_limit; seg++ )
>+            {
>+              AF_Segment  link = seg->link;
>+
>+
>+              if ( link == seg2 )
>+              {
>+                seg->link  = 0;
>+                seg->serif = link1;
>+              }
>+              else if ( link == link2 )
>+              {
>+                seg->link  = 0;
>+                seg->serif = seg1;
>+              }
>+            }
>+          }
>+          else
>+          {
>+            seg1->link = link1->link = 0;
>+
>+            break;
>+          }
>+        }
>+      }
>+    }
>+
>+    for ( seg1 = segments; seg1 < segment_limit; seg1++ )
>+    {
>+      seg2 = seg1->link;
>+
>+      if ( seg2 )
>+      {
>+        seg2->num_linked++;
>+        if ( seg2->link != seg1 )
>+        {
>+          seg1->link = 0;
>+
>+          if ( seg2->score < dist_threshold || seg1->score < seg2->score * 4 )
>+            seg1->serif = seg2->link;
>+          else
>+            seg2->num_linked--;
>+        }
>+      }
>+    }
>+  }
>+
>+
>+  static FT_Error
>+  af_cjk_hints_compute_edges( AF_GlyphHints  hints,
>+                              AF_Dimension   dim )
>+  {
>+    AF_AxisHints  axis   = &hints->axis[dim];
>+    FT_Error      error  = AF_Err_Ok;
>+    FT_Memory     memory = hints->memory;
>+    AF_LatinAxis  laxis  = &((AF_LatinMetrics)hints->metrics)->axis[dim];
>+
>+    AF_Segment    segments      = axis->segments;
>+    AF_Segment    segment_limit = segments + axis->num_segments;
>+    AF_Segment    seg;
>+
>+    AF_Direction  up_dir;
>+    FT_Fixed      scale;
>+    FT_Pos        edge_distance_threshold;
>+
>+
>+    axis->num_edges = 0;
>+
>+    scale = ( dim == AF_DIMENSION_HORZ ) ? hints->x_scale
>+                                         : hints->y_scale;
>+
>+    up_dir = ( dim == AF_DIMENSION_HORZ ) ? AF_DIR_UP
>+                                          : AF_DIR_RIGHT;
>+
>+    /*********************************************************************/
>+    /*                                                                   */
>+    /* We begin by generating a sorted table of edges for the current    */
>+    /* direction.  To do so, we simply scan each segment and try to find */
>+    /* an edge in our table that corresponds to its position.            */
>+    /*                                                                   */
>+    /* If no edge is found, we create and insert a new edge in the       */
>+    /* sorted table.  Otherwise, we simply add the segment to the edge's */
>+    /* list which is then processed in the second step to compute the    */
>+    /* edge's properties.                                                */
>+    /*                                                                   */
>+    /* Note that the edges table is sorted along the segment/edge        */
>+    /* position.                                                         */
>+    /*                                                                   */
>+    /*********************************************************************/
>+
>+    edge_distance_threshold = FT_MulFix( laxis->edge_distance_threshold,
>+                                         scale );
>+    if ( edge_distance_threshold > 64 / 4 )
>+      edge_distance_threshold = FT_DivFix( 64 / 4, scale );
>+    else
>+      edge_distance_threshold = laxis->edge_distance_threshold;
>+
>+    for ( seg = segments; seg < segment_limit; seg++ )
>+    {
>+      AF_Edge  found = 0;
>+      FT_Pos   best  = 0xFFFFU;
>+      FT_Int   ee;
>+
>+
>+      /* look for an edge corresponding to the segment */
>+      for ( ee = 0; ee < axis->num_edges; ee++ )
>+      {
>+        AF_Edge  edge = axis->edges + ee;
>+        FT_Pos   dist;
>+
>+
>+        if ( edge->dir != seg->dir )
>+          continue;
>+
>+        dist = seg->pos - edge->fpos;
>+        if ( dist < 0 )
>+          dist = -dist;
>+
>+        if ( dist < edge_distance_threshold && dist < best )
>+        {
>+          AF_Segment  link = seg->link;
>+
>+
>+          /* check whether all linked segments of the candidate edge */
>+          /* can make a single edge.                                 */
>+          if ( link )
>+          {
>+            AF_Segment  seg1 = edge->first;
>+            AF_Segment  link1;
>+            FT_Pos      dist2 = 0;
>+
>+
>+            do
>+            {
>+              link1 = seg1->link;
>+              if ( link1 )
>+              {
>+                dist2 = AF_SEGMENT_DIST( link, link1 );
>+                if ( dist2 >= edge_distance_threshold )
>+                  break;
>+              }
>+
>+            } while ( ( seg1 = seg1->edge_next ) != edge->first );
>+
>+            if ( dist2 >= edge_distance_threshold )
>+              continue;
>+          }
>+
>+          best  = dist;
>+          found = edge;
>+        }
>+      }
>+
>+      if ( !found )
>+      {
>+        AF_Edge  edge;
>+
>+
>+        /* insert a new edge in the list and */
>+        /* sort according to the position    */
>+        error = af_axis_hints_new_edge( axis, seg->pos, memory, &edge );
>+        if ( error )
>+          goto Exit;
>+
>+        /* add the segment to the new edge's list */
>+        FT_ZERO( edge );
>+
>+        edge->first    = seg;
>+        edge->last     = seg;
>+        edge->fpos     = seg->pos;
>+        edge->opos     = edge->pos = FT_MulFix( seg->pos, scale );
>+        seg->edge_next = seg;
>+        edge->dir      = seg->dir;
>+      }
>+      else
>+      {
>+        /* if an edge was found, simply add the segment to the edge's */
>+        /* list                                                       */
>+        seg->edge_next         = found->first;
>+        found->last->edge_next = seg;
>+        found->last            = seg;
>+      }
>+    }
>+
>+    /*********************************************************************/
>+    /*                                                                   */
>+    /* Good, we now compute each edge's properties according to segments */
>+    /* found on its position.  Basically, these are as follows.          */
>+    /*                                                                   */
>+    /*  - edge's main direction                                          */
>+    /*  - stem edge, serif edge or both (which defaults to stem then)    */
>+    /*  - rounded edge, straight or both (which defaults to straight)    */
>+    /*  - link for edge                                                  */
>+    /*                                                                   */
>+    /*********************************************************************/
>+
>+    /* first of all, set the `edge' field in each segment -- this is     */
>+    /* required in order to compute edge links                           */
>+    /*                                                                   */
>+    /* Note that removing this loop and setting the `edge' field of each */
>+    /* segment directly in the code above slows down execution speed for */
>+    /* some reasons on platforms like the Sun.                           */
>+
>+    {
>+      AF_Edge  edges      = axis->edges;
>+      AF_Edge  edge_limit = edges + axis->num_edges;
>+      AF_Edge  edge;
>+
>+
>+      for ( edge = edges; edge < edge_limit; edge++ )
>+      {
>+        seg = edge->first;
>+        if ( seg )
>+          do
>+          {
>+            seg->edge = edge;
>+            seg       = seg->edge_next;
>+
>+          } while ( seg != edge->first );
>+      }
>+
>+      /* now compute each edge properties */
>+      for ( edge = edges; edge < edge_limit; edge++ )
>+      {
>+        FT_Int  is_round    = 0;  /* does it contain round segments?    */
>+        FT_Int  is_straight = 0;  /* does it contain straight segments? */
>+
>+
>+        seg = edge->first;
>+
>+        do
>+        {
>+          FT_Bool  is_serif;
>+
>+
>+          /* check for roundness of segment */
>+          if ( seg->flags & AF_EDGE_ROUND )
>+            is_round++;
>+          else
>+            is_straight++;
>+
>+          /* check for links -- if seg->serif is set, then seg->link must */
>+          /* be ignored                                                   */
>+          is_serif = (FT_Bool)( seg->serif && seg->serif->edge != edge );
>+
>+          if ( seg->link || is_serif )
>+          {
>+            AF_Edge     edge2;
>+            AF_Segment  seg2;
>+
>+
>+            edge2 = edge->link;
>+            seg2  = seg->link;
>+
>+            if ( is_serif )
>+            {
>+              seg2  = seg->serif;
>+              edge2 = edge->serif;
>+            }
>+
>+            if ( edge2 )
>+            {
>+              FT_Pos  edge_delta;
>+              FT_Pos  seg_delta;
>+
>+
>+              edge_delta = edge->fpos - edge2->fpos;
>+              if ( edge_delta < 0 )
>+                edge_delta = -edge_delta;
>+
>+              seg_delta = AF_SEGMENT_DIST( seg, seg2 );
>+
>+              if ( seg_delta < edge_delta )
>+                edge2 = seg2->edge;
>+            }
>+            else
>+              edge2 = seg2->edge;
>+
>+            if ( is_serif )
>+            {
>+              edge->serif   = edge2;
>+              edge2->flags |= AF_EDGE_SERIF;
>+            }
>+            else
>+              edge->link  = edge2;
>+          }
>+
>+          seg = seg->edge_next;
>+
>+        } while ( seg != edge->first );
>+
>+        /* set the round/straight flags */
>+        edge->flags = AF_EDGE_NORMAL;
>+
>+        if ( is_round > 0 && is_round >= is_straight )
>+          edge->flags |= AF_EDGE_ROUND;
>+
>+        /* get rid of serifs if link is set                 */
>+        /* XXX: This gets rid of many unpleasant artefacts! */
>+        /*      Example: the `c' in cour.pfa at size 13     */
>+
>+        if ( edge->serif && edge->link )
>+          edge->serif = 0;
>+      }
>+    }
>+
>+  Exit:
>+    return error;
>+  }
>+
>+
>+  static FT_Error
>+  af_cjk_hints_detect_features( AF_GlyphHints  hints,
>+                                AF_Dimension   dim )
>+  {
>+    FT_Error  error;
>+
>+
>+    error = af_cjk_hints_compute_segments( hints, dim );
>+    if ( !error )
>+    {
>+      af_cjk_hints_link_segments( hints, dim );
>+
>+      error = af_cjk_hints_compute_edges( hints, dim );
>+    }
>+    return error;
>+  }
>+
>+
>+  static FT_Error
>+  af_cjk_hints_init( AF_GlyphHints    hints,
>+                     AF_LatinMetrics  metrics )
>+  {
>+    FT_Render_Mode  mode;
>+    FT_UInt32       scaler_flags, other_flags;
>+
>+
>+    af_glyph_hints_rescale( hints, (AF_ScriptMetrics)metrics );
>+
>+    /*
>+     *  correct x_scale and y_scale when needed, since they may have
>+     *  been modified af_cjk_scale_dim above
>+     */
>+    hints->x_scale = metrics->axis[AF_DIMENSION_HORZ].scale;
>+    hints->x_delta = metrics->axis[AF_DIMENSION_HORZ].delta;
>+    hints->y_scale = metrics->axis[AF_DIMENSION_VERT].scale;
>+    hints->y_delta = metrics->axis[AF_DIMENSION_VERT].delta;
>+
>+    /* compute flags depending on render mode, etc. */
>+    mode = metrics->root.scaler.render_mode;
>+
>+#ifdef AF_USE_WARPER
>+    if ( mode == FT_RENDER_MODE_LCD || mode == FT_RENDER_MODE_LCD_V )
>+      metrics->root.scaler.render_mode = mode = FT_RENDER_MODE_NORMAL;
>+#endif
>+
>+    scaler_flags = hints->scaler_flags;
>+    other_flags  = 0;
>+
>+    /*
>+     *  We snap the width of vertical stems for the monochrome and
>+     *  horizontal LCD rendering targets only.
>+     */
>+    if ( mode == FT_RENDER_MODE_MONO || mode == FT_RENDER_MODE_LCD )
>+      other_flags |= AF_LATIN_HINTS_HORZ_SNAP;
>+
>+    /*
>+     *  We snap the width of horizontal stems for the monochrome and
>+     *  vertical LCD rendering targets only.
>+     */
>+    if ( mode == FT_RENDER_MODE_MONO || mode == FT_RENDER_MODE_LCD_V )
>+      other_flags |= AF_LATIN_HINTS_VERT_SNAP;
>+
>+    /*
>+     *  We adjust stems to full pixels only if we don't use the `light' mode.
>+     */
>+    if ( mode != FT_RENDER_MODE_LIGHT )
>+      other_flags |= AF_LATIN_HINTS_STEM_ADJUST;
>+
>+    if ( mode == FT_RENDER_MODE_MONO )
>+      other_flags |= AF_LATIN_HINTS_MONO;
>+
>+    scaler_flags |= AF_SCALER_FLAG_NO_ADVANCE;
>+
>+    hints->scaler_flags = scaler_flags;
>+    hints->other_flags  = other_flags;
>+
>+    return 0;
>+  }
>+
>+
>+  /*************************************************************************/
>+  /*************************************************************************/
>+  /*****                                                               *****/
>+  /*****          C J K   G L Y P H   G R I D - F I T T I N G          *****/
>+  /*****                                                               *****/
>+  /*************************************************************************/
>+  /*************************************************************************/
>+
>+  /* snap a given width in scaled coordinates to one of the */
>+  /* current standard widths                                */
>+
>+  static FT_Pos
>+  af_cjk_snap_width( AF_Width  widths,
>+                     FT_Int    count,
>+                     FT_Pos    width )
>+  {
>+    int     n;
>+    FT_Pos  best      = 64 + 32 + 2;
>+    FT_Pos  reference = width;
>+    FT_Pos  scaled;
>+
>+
>+    for ( n = 0; n < count; n++ )
>+    {
>+      FT_Pos  w;
>+      FT_Pos  dist;
>+
>+
>+      w = widths[n].cur;
>+      dist = width - w;
>+      if ( dist < 0 )
>+        dist = -dist;
>+      if ( dist < best )
>+      {
>+        best      = dist;
>+        reference = w;
>+      }
>+    }
>+
>+    scaled = FT_PIX_ROUND( reference );
>+
>+    if ( width >= reference )
>+    {
>+      if ( width < scaled + 48 )
>+        width = reference;
>+    }
>+    else
>+    {
>+      if ( width > scaled - 48 )
>+        width = reference;
>+    }
>+
>+    return width;
>+  }
>+
>+
>+  /* compute the snapped width of a given stem */
>+
>+  static FT_Pos
>+  af_cjk_compute_stem_width( AF_GlyphHints  hints,
>+                             AF_Dimension   dim,
>+                             FT_Pos         width,
>+                             AF_Edge_Flags  base_flags,
>+                             AF_Edge_Flags  stem_flags )
>+  {
>+    AF_LatinMetrics  metrics  = (AF_LatinMetrics) hints->metrics;
>+    AF_LatinAxis     axis     = & metrics->axis[dim];
>+    FT_Pos           dist     = width;
>+    FT_Int           sign     = 0;
>+    FT_Int           vertical = ( dim == AF_DIMENSION_VERT );
>+
>+    FT_UNUSED( base_flags );
>+    FT_UNUSED( stem_flags );
>+
>+
>+    if ( !AF_LATIN_HINTS_DO_STEM_ADJUST( hints ) )
>+      return width;
>+
>+    if ( dist < 0 )
>+    {
>+      dist = -width;
>+      sign = 1;
>+    }
>+
>+    if ( (  vertical && !AF_LATIN_HINTS_DO_VERT_SNAP( hints ) ) ||
>+         ( !vertical && !AF_LATIN_HINTS_DO_HORZ_SNAP( hints ) ) )
>+    {
>+      /* smooth hinting process: very lightly quantize the stem width */
>+
>+      if ( axis->width_count > 0 )
>+      {
>+        if ( FT_ABS( dist - axis->widths[0].cur ) < 40 )
>+        {
>+          dist = axis->widths[0].cur;
>+          if ( dist < 48 )
>+            dist = 48;
>+
>+          goto Done_Width;
>+        }
>+      }
>+
>+      if ( dist < 54 )
>+        dist += ( 54 - dist ) / 2 ;
>+      else if ( dist < 3 * 64 )
>+      {
>+        FT_Pos  delta;
>+
>+
>+        delta  = dist & 63;
>+        dist  &= -64;
>+
>+        if ( delta < 10 )
>+          dist += delta;
>+        else if ( delta < 22 )
>+          dist += 10;
>+        else if ( delta < 42 )
>+          dist += delta;
>+        else if ( delta < 54 )
>+          dist += 54;
>+        else
>+          dist += delta;
>+      }
>+    }
>+    else
>+    {
>+      /* strong hinting process: snap the stem width to integer pixels */
>+
>+      dist = af_cjk_snap_width( axis->widths, axis->width_count, dist );
>+
>+      if ( vertical )
>+      {
>+        /* in the case of vertical hinting, always round */
>+        /* the stem heights to integer pixels            */
>+
>+        if ( dist >= 64 )
>+          dist = ( dist + 16 ) & ~63;
>+        else
>+          dist = 64;
>+      }
>+      else
>+      {
>+        if ( AF_LATIN_HINTS_DO_MONO( hints ) )
>+        {
>+          /* monochrome horizontal hinting: snap widths to integer pixels */
>+          /* with a different threshold                                   */
>+
>+          if ( dist < 64 )
>+            dist = 64;
>+          else
>+            dist = ( dist + 32 ) & ~63;
>+        }
>+        else
>+        {
>+          /* for horizontal anti-aliased hinting, we adopt a more subtle */
>+          /* approach: we strengthen small stems, round stems whose size */
>+          /* is between 1 and 2 pixels to an integer, otherwise nothing  */
>+
>+          if ( dist < 48 )
>+            dist = ( dist + 64 ) >> 1;
>+
>+          else if ( dist < 128 )
>+            dist = ( dist + 22 ) & ~63;
>+          else
>+            /* round otherwise to prevent color fringes in LCD mode */
>+            dist = ( dist + 32 ) & ~63;
>+        }
>+      }
>+    }
>+
>+  Done_Width:
>+    if ( sign )
>+      dist = -dist;
>+
>+    return dist;
>+  }
>+
>+
>+  /* align one stem edge relative to the previous stem edge */
>+
>+  static void
>+  af_cjk_align_linked_edge( AF_GlyphHints  hints,
>+                            AF_Dimension   dim,
>+                            AF_Edge        base_edge,
>+                            AF_Edge        stem_edge )
>+  {
>+    FT_Pos  dist = stem_edge->opos - base_edge->opos;
>+
>+    FT_Pos  fitted_width = af_cjk_compute_stem_width(
>+                             hints, dim, dist,
>+                             (AF_Edge_Flags)base_edge->flags,
>+                             (AF_Edge_Flags)stem_edge->flags );
>+
>+
>+    stem_edge->pos = base_edge->pos + fitted_width;
>+  }
>+
>+
>+  static void
>+  af_cjk_align_serif_edge( AF_GlyphHints  hints,
>+                           AF_Edge        base,
>+                           AF_Edge        serif )
>+  {
>+    FT_UNUSED( hints );
>+
>+    serif->pos = base->pos + ( serif->opos - base->opos );
>+  }
>+
>+
>+  /*************************************************************************/
>+  /*************************************************************************/
>+  /*************************************************************************/
>+  /****                                                                 ****/
>+  /****                    E D G E   H I N T I N G                      ****/
>+  /****                                                                 ****/
>+  /*************************************************************************/
>+  /*************************************************************************/
>+  /*************************************************************************/
>+
>+
>+#define AF_LIGHT_MODE_MAX_HORZ_GAP    9
>+#define AF_LIGHT_MODE_MAX_VERT_GAP   15
>+#define AF_LIGHT_MODE_MAX_DELTA_ABS  14
>+
>+
>+  static FT_Pos
>+  af_hint_normal_stem( AF_GlyphHints  hints,
>+                       AF_Edge        edge,
>+                       AF_Edge        edge2,
>+                       FT_Pos         anchor,
>+                       AF_Dimension   dim )
>+  {
>+    FT_Pos  org_len, cur_len, org_center;
>+    FT_Pos  cur_pos1, cur_pos2;
>+    FT_Pos  d_off1, u_off1, d_off2, u_off2, delta;
>+    FT_Pos  offset;
>+    FT_Pos  threshold = 64;
>+
>+
>+    if ( !AF_LATIN_HINTS_DO_STEM_ADJUST( hints ) )
>+    {
>+      if ( ( edge->flags  & AF_EDGE_ROUND ) &&
>+           ( edge2->flags & AF_EDGE_ROUND ) )
>+      {
>+        if ( dim == AF_DIMENSION_VERT )
>+          threshold = 64 - AF_LIGHT_MODE_MAX_HORZ_GAP;
>+        else
>+          threshold = 64 - AF_LIGHT_MODE_MAX_VERT_GAP;
>+      }
>+      else
>+      {
>+        if ( dim == AF_DIMENSION_VERT )
>+          threshold = 64 - AF_LIGHT_MODE_MAX_HORZ_GAP / 3;
>+        else
>+          threshold = 64 - AF_LIGHT_MODE_MAX_VERT_GAP / 3;
>+      }
>+    }
>+
>+    org_len    = edge2->opos - edge->opos;
>+    cur_len    = af_cjk_compute_stem_width( hints, dim, org_len,
>+                                            (AF_Edge_Flags)edge->flags,
>+                                            (AF_Edge_Flags)edge2->flags );
>+
>+    org_center = ( edge->opos + edge2->opos ) / 2 + anchor;
>+    cur_pos1   = org_center - cur_len / 2;
>+    cur_pos2   = cur_pos1 + cur_len;
>+    d_off1     = cur_pos1 - FT_PIX_FLOOR( cur_pos1 );
>+    d_off2     = cur_pos2 - FT_PIX_FLOOR( cur_pos2 );
>+    u_off1     = 64 - d_off1;
>+    u_off2     = 64 - d_off2;
>+    delta      = 0;
>+
>+
>+    if ( d_off1 == 0 || d_off2 == 0 )
>+      goto Exit;
>+
>+    if ( cur_len <= threshold )
>+    {
>+      if ( d_off2 < cur_len )
>+      {
>+        if ( u_off1 <= d_off2 )
>+          delta =  u_off1;
>+        else
>+          delta = -d_off2;
>+      }
>+
>+      goto Exit;
>+    }
>+
>+    if ( threshold < 64 )
>+    {
>+      if ( d_off1 >= threshold || u_off1 >= threshold ||
>+           d_off2 >= threshold || u_off2 >= threshold )
>+        goto Exit;
>+    }
>+
>+    offset = cur_len % 64;
>+
>+    if ( offset < 32 )
>+    {
>+      if ( u_off1 <= offset || d_off2 <= offset )
>+        goto Exit;
>+    }
>+    else
>+      offset = 64 - threshold;
>+
>+    d_off1 = threshold - u_off1;
>+    u_off1 = u_off1    - offset;
>+    u_off2 = threshold - d_off2;
>+    d_off2 = d_off2    - offset;
>+
>+    if ( d_off1 <= u_off1 )
>+      u_off1 = -d_off1;
>+
>+    if ( d_off2 <= u_off2 )
>+      u_off2 = -d_off2;
>+
>+    if ( FT_ABS( u_off1 ) <= FT_ABS( u_off2 ) )
>+      delta = u_off1;
>+    else
>+      delta = u_off2;
>+
>+  Exit:
>+
>+#if 1
>+    if ( !AF_LATIN_HINTS_DO_STEM_ADJUST( hints ) )
>+    {
>+      if ( delta > AF_LIGHT_MODE_MAX_DELTA_ABS )
>+        delta = AF_LIGHT_MODE_MAX_DELTA_ABS;
>+      else if ( delta < -AF_LIGHT_MODE_MAX_DELTA_ABS )
>+        delta = -AF_LIGHT_MODE_MAX_DELTA_ABS;
>+    }
>+#endif
>+
>+    cur_pos1 += delta;
>+
>+    if ( edge->opos < edge2->opos )
>+    {
>+      edge->pos  = cur_pos1;
>+      edge2->pos = cur_pos1 + cur_len;
>+    }
>+    else
>+    {
>+      edge->pos  = cur_pos1 + cur_len;
>+      edge2->pos = cur_pos1;
>+    }
>+
>+    return delta;
>+  }
>+
>+
>+  static void
>+  af_cjk_hint_edges( AF_GlyphHints  hints,
>+                     AF_Dimension   dim )
>+  {
>+    AF_AxisHints  axis       = &hints->axis[dim];
>+    AF_Edge       edges      = axis->edges;
>+    AF_Edge       edge_limit = edges + axis->num_edges;
>+    FT_Int        n_edges;
>+    AF_Edge       edge;
>+    AF_Edge       anchor   = 0;
>+    FT_Pos        delta    = 0;
>+    FT_Int        skipped  = 0;
>+
>+
>+    /* now we align all stem edges. */
>+    for ( edge = edges; edge < edge_limit; edge++ )
>+    {
>+      AF_Edge  edge2;
>+
>+
>+      if ( edge->flags & AF_EDGE_DONE )
>+        continue;
>+
>+      /* skip all non-stem edges */
>+      edge2 = edge->link;
>+      if ( !edge2 )
>+      {
>+        skipped++;
>+        continue;
>+      }
>+
>+      /* now align the stem */
>+
>+      if ( edge2 < edge )
>+      {
>+        af_cjk_align_linked_edge( hints, dim, edge2, edge );
>+        edge->flags |= AF_EDGE_DONE;
>+        continue;
>+      }
>+
>+      if ( dim != AF_DIMENSION_VERT && !anchor )
>+      {
>+
>+#if 0
>+        if ( fixedpitch )
>+        {
>+          AF_Edge     left  = edge;
>+          AF_Edge     right = edge_limit - 1;
>+          AF_EdgeRec  left1, left2, right1, right2;
>+          FT_Pos      target, center1, center2;
>+          FT_Pos      delta1, delta2, d1, d2;
>+
>+
>+          while ( right > left && !right->link )
>+            right--;
>+
>+          left1  = *left;
>+          left2  = *left->link;
>+          right1 = *right->link;
>+          right2 = *right;
>+
>+          delta  = ( ( ( hinter->pp2.x + 32 ) & -64 ) - hinter->pp2.x ) / 2;
>+          target = left->opos + ( right->opos - left->opos ) / 2 + delta - 16;
>+
>+          delta1  = delta;
>+          delta1 += af_hint_normal_stem( hints, left, left->link,
>+                                         delta1, 0 );
>+
>+          if ( left->link != right )
>+            af_hint_normal_stem( hints, right->link, right, delta1, 0 );
>+
>+          center1 = left->pos + ( right->pos - left->pos ) / 2;
>+
>+          if ( center1 >= target )
>+            delta2 = delta - 32;
>+          else
>+            delta2 = delta + 32;
>+
>+          delta2 += af_hint_normal_stem( hints, &left1, &left2, delta2, 0 );
>+
>+          if ( delta1 != delta2 )
>+          {
>+            if ( left->link != right )
>+              af_hint_normal_stem( hints, &right1, &right2, delta2, 0 );
>+
>+            center2 = left1.pos + ( right2.pos - left1.pos ) / 2;
>+
>+            d1 = center1 - target;
>+            d2 = center2 - target;
>+
>+            if ( FT_ABS( d2 ) < FT_ABS( d1 ) )
>+            {
>+              left->pos       = left1.pos;
>+              left->link->pos = left2.pos;
>+
>+              if ( left->link != right )
>+              {
>+                right->link->pos = right1.pos;
>+                right->pos       = right2.pos;
>+              }
>+
>+              delta1 = delta2;
>+            }
>+          }
>+
>+          delta               = delta1;
>+          right->link->flags |= AF_EDGE_DONE;
>+          right->flags       |= AF_EDGE_DONE;
>+        }
>+        else
>+
>+#endif /* 0 */
>+
>+          delta = af_hint_normal_stem( hints, edge, edge2, 0,
>+                                       AF_DIMENSION_HORZ );
>+      }
>+      else
>+        af_hint_normal_stem( hints, edge, edge2, delta, dim );
>+
>+#if 0
>+      printf( "stem (%d,%d) adjusted (%.1f,%.1f)\n",
>+               edge - edges, edge2 - edges,
>+               ( edge->pos - edge->opos ) / 64.0,
>+               ( edge2->pos - edge2->opos ) / 64.0 );
>+#endif
>+
>+      anchor = edge;
>+      edge->flags  |= AF_EDGE_DONE;
>+      edge2->flags |= AF_EDGE_DONE;
>+    }
>+
>+    /* make sure that lowercase m's maintain their symmetry */
>+
>+    /* In general, lowercase m's have six vertical edges if they are sans */
>+    /* serif, or twelve if they are with serifs.  This implementation is  */
>+    /* based on that assumption, and seems to work very well with most    */
>+    /* faces.  However, if for a certain face this assumption is not      */
>+    /* true, the m is just rendered like before.  In addition, any stem   */
>+    /* correction will only be applied to symmetrical glyphs (even if the */
>+    /* glyph is not an m), so the potential for unwanted distortion is    */
>+    /* relatively low.                                                    */
>+
>+    /* We don't handle horizontal edges since we can't easily assure that */
>+    /* the third (lowest) stem aligns with the base line; it might end up */
>+    /* one pixel higher or lower.                                         */
>+
>+    n_edges = edge_limit - edges;
>+    if ( dim == AF_DIMENSION_HORZ && ( n_edges == 6 || n_edges == 12 ) )
>+    {
>+      AF_Edge  edge1, edge2, edge3;
>+      FT_Pos   dist1, dist2, span;
>+
>+
>+      if ( n_edges == 6 )
>+      {
>+        edge1 = edges;
>+        edge2 = edges + 2;
>+        edge3 = edges + 4;
>+      }
>+      else
>+      {
>+        edge1 = edges + 1;
>+        edge2 = edges + 5;
>+        edge3 = edges + 9;
>+      }
>+
>+      dist1 = edge2->opos - edge1->opos;
>+      dist2 = edge3->opos - edge2->opos;
>+
>+      span = dist1 - dist2;
>+      if ( span < 0 )
>+        span = -span;
>+
>+      if ( edge1->link == edge1 + 1 &&
>+           edge2->link == edge2 + 1 &&
>+           edge3->link == edge3 + 1 && span < 8 )
>+      {
>+        delta = edge3->pos - ( 2 * edge2->pos - edge1->pos );
>+        edge3->pos -= delta;
>+        if ( edge3->link )
>+          edge3->link->pos -= delta;
>+
>+        /* move the serifs along with the stem */
>+        if ( n_edges == 12 )
>+        {
>+          ( edges + 8 )->pos -= delta;
>+          ( edges + 11 )->pos -= delta;
>+        }
>+
>+        edge3->flags |= AF_EDGE_DONE;
>+        if ( edge3->link )
>+          edge3->link->flags |= AF_EDGE_DONE;
>+      }
>+    }
>+
>+    if ( !skipped )
>+      return;
>+
>+    /*
>+     *  now hint the remaining edges (serifs and single) in order
>+     *  to complete our processing
>+     */
>+    for ( edge = edges; edge < edge_limit; edge++ )
>+    {
>+      if ( edge->flags & AF_EDGE_DONE )
>+        continue;
>+
>+      if ( edge->serif )
>+      {
>+        af_cjk_align_serif_edge( hints, edge->serif, edge );
>+        edge->flags |= AF_EDGE_DONE;
>+        skipped--;
>+      }
>+    }
>+
>+    if ( !skipped )
>+      return;
>+
>+    for ( edge = edges; edge < edge_limit; edge++ )
>+    {
>+      AF_Edge  before, after;
>+
>+
>+      if ( edge->flags & AF_EDGE_DONE )
>+        continue;
>+
>+      before = after = edge;
>+
>+      while ( --before >= edges )
>+        if ( before->flags & AF_EDGE_DONE )
>+          break;
>+
>+      while ( ++after < edge_limit )
>+        if ( after->flags & AF_EDGE_DONE )
>+          break;
>+
>+      if ( before >= edges || after < edge_limit )
>+      {
>+        if ( before < edges )
>+          af_cjk_align_serif_edge( hints, after, edge );
>+        else if ( after >= edge_limit )
>+          af_cjk_align_serif_edge( hints, before, edge );
>+        else
>+          edge->pos = before->pos +
>+            FT_MulDiv( edge->fpos - before->fpos,
>+                       after->pos - before->pos,
>+                       after->fpos - before->fpos );
>+      }
>+    }
>+  }
>+
>+
>+  static void
>+  af_cjk_align_edge_points( AF_GlyphHints  hints,
>+                            AF_Dimension   dim )
>+  {
>+    AF_AxisHints  axis       = & hints->axis[dim];
>+    AF_Edge       edges      = axis->edges;
>+    AF_Edge       edge_limit = edges + axis->num_edges;
>+    AF_Edge       edge;
>+    FT_Bool       snapping;
>+
>+
>+    snapping = ( ( dim == AF_DIMENSION_HORZ             &&
>+                   AF_LATIN_HINTS_DO_HORZ_SNAP( hints ) ) ||
>+                 ( dim == AF_DIMENSION_VERT             &&
>+                   AF_LATIN_HINTS_DO_VERT_SNAP( hints ) ) );
>+
>+    for ( edge = edges; edge < edge_limit; edge++ )
>+    {
>+      /* move the points of each segment     */
>+      /* in each edge to the edge's position */
>+      AF_Segment  seg = edge->first;
>+
>+
>+      if ( snapping )
>+      {
>+        do
>+        {
>+          AF_Point  point = seg->first;
>+
>+
>+          for (;;)
>+          {
>+            if ( dim == AF_DIMENSION_HORZ )
>+            {
>+              point->x      = edge->pos;
>+              point->flags |= AF_FLAG_TOUCH_X;
>+            }
>+            else
>+            {
>+              point->y      = edge->pos;
>+              point->flags |= AF_FLAG_TOUCH_Y;
>+            }
>+
>+            if ( point == seg->last )
>+              break;
>+
>+            point = point->next;
>+          }
>+
>+          seg = seg->edge_next;
>+
>+        } while ( seg != edge->first );
>+      }
>+      else
>+      {
>+        FT_Pos  delta = edge->pos - edge->opos;
>+
>+
>+        do
>+        {
>+          AF_Point  point = seg->first;
>+
>+
>+          for (;;)
>+          {
>+            if ( dim == AF_DIMENSION_HORZ )
>+            {
>+              point->x     += delta;
>+              point->flags |= AF_FLAG_TOUCH_X;
>+            }
>+            else
>+            {
>+              point->y     += delta;
>+              point->flags |= AF_FLAG_TOUCH_Y;
>+            }
>+
>+            if ( point == seg->last )
>+              break;
>+
>+            point = point->next;
>+          }
>+
>+          seg = seg->edge_next;
>+
>+        } while ( seg != edge->first );
>+      }
>+    }
>+  }
>+
>+
>+  static FT_Error
>+  af_cjk_hints_apply( AF_GlyphHints    hints,
>+                      FT_Outline*      outline,
>+                      AF_LatinMetrics  metrics )
>+  {
>+    FT_Error  error;
>+    int       dim;
>+
>+    FT_UNUSED( metrics );
>+
>+
>+    error = af_glyph_hints_reload( hints, outline );
>+    if ( error )
>+      goto Exit;
>+
>+    /* analyze glyph outline */
>+    if ( AF_HINTS_DO_HORIZONTAL( hints ) )
>+    {
>+      error = af_cjk_hints_detect_features( hints, AF_DIMENSION_HORZ );
>+      if ( error )
>+        goto Exit;
>+    }
>+
>+    if ( AF_HINTS_DO_VERTICAL( hints ) )
>+    {
>+      error = af_cjk_hints_detect_features( hints, AF_DIMENSION_VERT );
>+      if ( error )
>+        goto Exit;
>+    }
>+
>+    /* grid-fit the outline */
>+    for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )
>+    {
>+      if ( ( dim == AF_DIMENSION_HORZ && AF_HINTS_DO_HORIZONTAL( hints ) ) ||
>+           ( dim == AF_DIMENSION_VERT && AF_HINTS_DO_VERTICAL( hints ) )   )
>+      {
>+
>+#ifdef AF_USE_WARPER
>+        if ( dim == AF_DIMENSION_HORZ                                  &&
>+             metrics->root.scaler.render_mode == FT_RENDER_MODE_NORMAL )
>+        {
>+          AF_WarperRec  warper;
>+          FT_Fixed      scale;
>+          FT_Pos        delta;
>+
>+
>+          af_warper_compute( &warper, hints, dim, &scale, &delta );
>+          af_glyph_hints_scale_dim( hints, dim, scale, delta );
>+          continue;
>+        }
>+#endif /* AF_USE_WARPER */
>+
>+        af_cjk_hint_edges( hints, (AF_Dimension)dim );
>+        af_cjk_align_edge_points( hints, (AF_Dimension)dim );
>+        af_glyph_hints_align_strong_points( hints, (AF_Dimension)dim );
>+        af_glyph_hints_align_weak_points( hints, (AF_Dimension)dim );
>+      }
>+    }
>+
>+#if 0
>+    af_glyph_hints_dump_points( hints );
>+    af_glyph_hints_dump_segments( hints );
>+    af_glyph_hints_dump_edges( hints );
>+#endif
>+
>+    af_glyph_hints_save( hints, outline );
>+
>+  Exit:
>+    return error;
>+  }
>+
>+
>+  /*************************************************************************/
>+  /*************************************************************************/
>+  /*****                                                               *****/
>+  /*****                C J K   S C R I P T   C L A S S                *****/
>+  /*****                                                               *****/
>+  /*************************************************************************/
>+  /*************************************************************************/
>+
>+
>+  static const AF_Script_UniRangeRec  af_cjk_uniranges[] =
>+  {
>+    { 0x2E80,  0x2EFF },  /* CJK Radicals Supplement */
>+    { 0x2F00,  0x2FDF },  /* Kangxi Radicals */
>+    { 0x3000,  0x303F },  /* CJK Symbols and Punctuation */
>+    { 0x3040,  0x309F },  /* Hiragana */
>+    { 0x30A0,  0x30FF },  /* Katakana */
>+    { 0x3100,  0x312F },  /* Bopomofo */
>+    { 0x3130,  0x318F },  /* Hangul Compatibility Jamo */
>+    { 0x31A0,  0x31BF },  /* Bopomofo Extended */
>+    { 0x31C0,  0x31EF },  /* CJK Strokes */
>+    { 0x31F0,  0x31FF },  /* Katakana Phonetic Extensions */
>+    { 0x3200,  0x32FF },  /* Enclosed CJK Letters and Months */
>+    { 0x3300,  0x33FF },  /* CJK Compatibility */
>+    { 0x3400,  0x4DBF },  /* CJK Unified Ideographs Extension A */
>+    { 0x4DC0,  0x4DFF },  /* Yijing Hexagram Symbols */
>+    { 0x4E00,  0x9FFF },  /* CJK Unified Ideographs */
>+    { 0xF900,  0xFAFF },  /* CJK Compatibility Ideographs */
>+    { 0xFE30,  0xFE4F },  /* CJK Compatibility Forms */
>+    { 0xFF00,  0xFFEF },  /* Halfwidth and Fullwidth Forms */
>+    { 0x20000, 0x2A6DF }, /* CJK Unified Ideographs Extension B */
>+    { 0x2F800, 0x2FA1F }, /* CJK Compatibility Ideographs Supplement */
>+    { 0,       0 }
>+  };
>+
>+
>+  FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
>+  af_cjk_script_class =
>+  {
>+    AF_SCRIPT_CJK,
>+    af_cjk_uniranges,
>+
>+    sizeof( AF_LatinMetricsRec ),
>+
>+    (AF_Script_InitMetricsFunc) af_cjk_metrics_init,
>+    (AF_Script_ScaleMetricsFunc)af_cjk_metrics_scale,
>+    (AF_Script_DoneMetricsFunc) NULL,
>+
>+    (AF_Script_InitHintsFunc)   af_cjk_hints_init,
>+    (AF_Script_ApplyHintsFunc)  af_cjk_hints_apply
>+  };
>+
>+#else /* !AF_CONFIG_OPTION_CJK */
>+
>+  static const AF_Script_UniRangeRec  af_cjk_uniranges[] =
>+  {
>+    { 0, 0 }
>+  };
>+
>+
>+  FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec
>+  af_cjk_script_class =
>+  {
>+    AF_SCRIPT_CJK,
>+    af_cjk_uniranges,
>+
>+    sizeof( AF_LatinMetricsRec ),
>+
>+    (AF_Script_InitMetricsFunc) NULL,
>+    (AF_Script_ScaleMetricsFunc)NULL,
>+    (AF_Script_DoneMetricsFunc) NULL,
>+
>+    (AF_Script_InitHintsFunc)   NULL,
>+    (AF_Script_ApplyHintsFunc)  NULL
>+  };
>+
>+#endif /* !AF_CONFIG_OPTION_CJK */
>+
>+
>+/* END */
>diff -urN freetype-2.1.10.old/src/autofit/afcjk.h freetype-2.1.10.autofit-backport/src/autofit/afcjk.h
>--- freetype-2.1.10.old/src/autofit/afcjk.h	1970-01-01 08:00:00.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/afcjk.h	2006-03-14 23:10:46.000000000 +0800
>@@ -0,0 +1,41 @@
>+/***************************************************************************/
>+/*                                                                         */
>+/*  afcjk.h                                                                */
>+/*                                                                         */
>+/*    Auto-fitter hinting routines for CJK script (specification).         */
>+/*                                                                         */
>+/*  Copyright 2006 by                                                      */
>+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
>+/*                                                                         */
>+/*  This file is part of the FreeType project, and may only be used,       */
>+/*  modified, and distributed under the terms of the FreeType project      */
>+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
>+/*  this file you indicate that you have read the license and              */
>+/*  understand and accept it fully.                                        */
>+/*                                                                         */
>+/***************************************************************************/
>+
>+
>+#ifndef __AFCJK_H__
>+#define __AFCJK_H__
>+
>+#include "afhints.h"
>+
>+
>+FT_BEGIN_HEADER
>+
>+
>+  /* the CJK-specific script class */
>+
>+  FT_CALLBACK_TABLE const AF_ScriptClassRec
>+  af_cjk_script_class;
>+
>+
>+/* */
>+
>+FT_END_HEADER
>+
>+#endif /* __AFCJK_H__ */
>+
>+
>+/* END */
>diff -urN freetype-2.1.10.old/src/autofit/afglobal.c freetype-2.1.10.autofit-backport/src/autofit/afglobal.c
>--- freetype-2.1.10.old/src/autofit/afglobal.c	2005-03-26 18:19:36.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/afglobal.c	2006-03-14 23:10:46.000000000 +0800
>@@ -4,7 +4,7 @@
> /*                                                                         */
> /*    Auto-fitter routines to compute global hinting values (body).        */
> /*                                                                         */
>-/*  Copyright 2003, 2004, 2005 by                                          */
>+/*  Copyright 2003, 2004, 2005, 2006 by                                    */
> /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
> /*                                                                         */
> /*  This file is part of the FreeType project, and may only be used,       */
>@@ -19,6 +19,7 @@
> #include "afglobal.h"
> #include "afdummy.h"
> #include "aflatin.h"
>+#include "afcjk.h"
> #include "aferrors.h"
> 
> 
>@@ -27,6 +28,7 @@
>   {
>     &af_dummy_script_class,
>     &af_latin_script_class,
>+    &af_cjk_script_class,
> 
>     NULL  /* do not remove */
>   };
>diff -urN freetype-2.1.10.old/src/autofit/afhints.c freetype-2.1.10.autofit-backport/src/autofit/afhints.c
>--- freetype-2.1.10.old/src/autofit/afhints.c	2005-05-01 23:38:53.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/afhints.c	2006-03-14 23:10:46.000000000 +0800
>@@ -4,7 +4,7 @@
> /*                                                                         */
> /*    Auto-fitter hinting routines (body).                                 */
> /*                                                                         */
>-/*  Copyright 2003, 2004, 2005 by                                          */
>+/*  Copyright 2003, 2004, 2005, 2006 by                                    */
> /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
> /*                                                                         */
> /*  This file is part of the FreeType project, and may only be used,       */
>@@ -265,11 +265,61 @@
> #endif /* AF_DEBUG */
> 
> 
>+
>   /* compute the direction value of a given vector */
>   FT_LOCAL_DEF( AF_Direction )
>   af_direction_compute( FT_Pos  dx,
>                         FT_Pos  dy )
>   {
>+#if 1
>+    AF_Direction  dir = AF_DIR_NONE;
>+
>+
>+    /* atan(1/12) == 4.7 degrees */
>+
>+    if ( dx < 0 )
>+    {
>+      if ( dy < 0 )
>+      {
>+        if ( -dx * 12 < -dy )
>+          dir = AF_DIR_DOWN;
>+
>+        else if ( -dy * 12 < -dx )
>+          dir = AF_DIR_LEFT;
>+      }
>+      else /* dy >= 0 */
>+      {
>+        if ( -dx * 12 < dy )
>+          dir = AF_DIR_UP;
>+
>+        else if ( dy * 12 < -dx )
>+          dir = AF_DIR_LEFT;
>+      }
>+    }
>+    else /* dx >= 0 */
>+    {
>+      if ( dy < 0 )
>+      {
>+        if ( dx * 12 < -dy )
>+          dir = AF_DIR_DOWN;
>+
>+        else if ( -dy * 12 < dx )
>+          dir = AF_DIR_RIGHT;
>+      }
>+      else  /* dy >= 0 */
>+      {
>+        if ( dx * 12 < dy )
>+          dir = AF_DIR_UP;
>+
>+        else if ( dy * 12 < dx )
>+          dir = AF_DIR_RIGHT;
>+      }
>+    }
>+
>+    return dir;
>+
>+#else /* 0 */
>+
>     AF_Direction  dir;
>     FT_Pos        ax = FT_ABS( dx );
>     FT_Pos        ay = FT_ABS( dy );
>@@ -291,6 +341,9 @@
>     }
> 
>     return dir;
>+
>+#endif /* 0 */
>+
>   }
> 
> 
>@@ -349,8 +402,9 @@
> 
>       } while ( angle_in == angle_seg );
> 
>-      first   = start;
>-      diff_in = af_angle_diff( angle_in, angle_seg );
>+      first = start;
>+
>+      AF_ANGLE_DIFF( diff_in, angle_in, angle_seg );
> 
>       /* now, process all segments in the contour */
>       do
>@@ -373,7 +427,7 @@
> 
>         } while ( angle_out == angle_seg );
> 
>-        diff_out = af_angle_diff( angle_seg, angle_out );
>+        AF_ANGLE_DIFF( diff_out, angle_seg, angle_out );
> 
>         if ( ( diff_in ^ diff_out ) < 0 )
>         {
>@@ -455,7 +509,8 @@
>   af_glyph_hints_rescale( AF_GlyphHints     hints,
>                           AF_ScriptMetrics  metrics )
>   {
>-    hints->metrics = metrics;
>+    hints->metrics      = metrics;
>+    hints->scaler_flags = metrics->scaler.flags;
>   }
> 
> 
>@@ -466,7 +521,6 @@
>     FT_Error   error   = AF_Err_Ok;
>     AF_Point   points;
>     FT_UInt    old_max, new_max;
>-    AF_Scaler  scaler  = &hints->metrics->scaler;
>     FT_Fixed   x_scale = hints->x_scale;
>     FT_Fixed   y_scale = hints->y_scale;
>     FT_Pos     x_delta = hints->x_delta;
>@@ -474,7 +528,6 @@
>     FT_Memory  memory  = hints->memory;
> 
> 
>-    hints->scaler_flags = scaler->flags;
>     hints->num_points   = 0;
>     hints->num_contours = 0;
> 
>@@ -657,7 +710,8 @@
> 
>             angle_in  = af_angle_atan( in_x, in_y );
>             angle_out = af_angle_atan( out_x, out_y );
>-            delta     = af_angle_diff( angle_in, angle_out );
>+
>+            AF_ANGLE_DIFF( delta, angle_in, angle_out );
> 
>             if ( delta < 2 && delta > -2 )
>               goto Is_Weak_Point;
>@@ -1087,4 +1141,31 @@
>   }
> 
> 
>+#ifdef AF_USE_WARPER
>+
>+  FT_LOCAL_DEF( void )
>+  af_glyph_hints_scale_dim( AF_GlyphHints  hints,
>+                            AF_Dimension   dim,
>+                            FT_Fixed       scale,
>+                            FT_Pos         delta )
>+  {
>+    AF_Point  points       = hints->points;
>+    AF_Point  points_limit = points + hints->num_points;
>+    AF_Point  point;
>+    
>+
>+    if ( dim == AF_DIMENSION_HORZ )
>+    {
>+      for ( point = points; point < points_limit; point++ )
>+        point->x = FT_MulFix( point->fx, scale ) + delta;
>+    }
>+    else
>+    {
>+      for ( point = points; point < points_limit; point++ )
>+        point->y = FT_MulFix( point->fy, scale ) + delta;
>+    }
>+  }
>+
>+#endif /* AF_USE_WARPER */
>+
> /* END */
>diff -urN freetype-2.1.10.old/src/autofit/afhints.h freetype-2.1.10.autofit-backport/src/autofit/afhints.h
>--- freetype-2.1.10.old/src/autofit/afhints.h	2005-03-04 07:00:06.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/afhints.h	2006-03-14 23:10:46.000000000 +0800
>@@ -4,7 +4,7 @@
> /*                                                                         */
> /*    Auto-fitter hinting routines (specification).                        */
> /*                                                                         */
>-/*  Copyright 2003, 2004, 2005 by                                          */
>+/*  Copyright 2003, 2004, 2005, 2006 by                                    */
> /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
> /*                                                                         */
> /*  This file is part of the FreeType project, and may only be used,       */
>@@ -133,6 +133,7 @@
>     AF_Segment  serif;       /* primary segment for serifs */
>     FT_Pos      num_linked;  /* number of linked segments  */
>     FT_Pos      score;       /* used during stem matching  */
>+    FT_Pos      len;         /* used during stem matching  */
> 
>     AF_Point    first;       /* first point in edge segment             */
>     AF_Point    last;        /* last point in edge segment              */
>@@ -272,11 +273,25 @@
>   af_glyph_hints_align_weak_points( AF_GlyphHints  hints,
>                                     AF_Dimension   dim );
> 
>+#ifdef AF_USE_WARPER
>+  FT_LOCAL( void )
>+  af_glyph_hints_scale_dim( AF_GlyphHints  hints,
>+                            AF_Dimension   dim,
>+                            FT_Fixed       scale,
>+                            FT_Pos         delta );
>+#endif
>+
>   FT_LOCAL( void )
>   af_glyph_hints_done( AF_GlyphHints  hints );
> 
> /* */
> 
>+#define AF_SEGMENT_LEN( seg )          ( (seg)->max_coord - (seg)->min_coord )
>+
>+#define AF_SEGMENT_DIST( seg1, seg2 )  ( ( (seg1)->pos > (seg2)->pos )   \
>+                                           ? (seg1)->pos - (seg2)->pos   \
>+                                           : (seg2)->pos - (seg1)->pos )
>+
> 
> FT_END_HEADER
> 
>diff -urN freetype-2.1.10.old/src/autofit/aflatin.c freetype-2.1.10.autofit-backport/src/autofit/aflatin.c
>--- freetype-2.1.10.old/src/autofit/aflatin.c	2005-05-06 13:45:43.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/aflatin.c	2006-03-14 23:10:46.000000000 +0800
>@@ -4,7 +4,7 @@
> /*                                                                         */
> /*    Auto-fitter hinting routines for latin script (body).                */
> /*                                                                         */
>-/*  Copyright 2003, 2004, 2005 by                                          */
>+/*  Copyright 2003, 2004, 2005, 2006 by                                    */
> /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
> /*                                                                         */
> /*  This file is part of the FreeType project, and may only be used,       */
>@@ -20,6 +20,11 @@
> #include "aferrors.h"
> 
> 
>+#ifdef AF_USE_WARPER
>+#include "afwarp.h"
>+#endif
>+
>+
>   /*************************************************************************/
>   /*************************************************************************/
>   /*****                                                               *****/
>@@ -28,9 +33,10 @@
>   /*************************************************************************/
>   /*************************************************************************/
> 
>-  static void
>+  FT_LOCAL_DEF( void )
>   af_latin_metrics_init_widths( AF_LatinMetrics  metrics,
>-                                FT_Face          face )
>+                                FT_Face          face,
>+                                FT_ULong         charcode )
>   {
>     /* scan the array of segments in each direction */
>     AF_GlyphHintsRec  hints[1];
>@@ -41,16 +47,15 @@
>     metrics->axis[AF_DIMENSION_HORZ].width_count = 0;
>     metrics->axis[AF_DIMENSION_VERT].width_count = 0;
> 
>-    /* For now, compute the standard width and height from the `o'. */
>     {
>       FT_Error             error;
>       FT_UInt              glyph_index;
>       int                  dim;
>-      AF_ScriptMetricsRec  dummy[1];
>-      AF_Scaler            scaler = &dummy->scaler;
>+      AF_LatinMetricsRec   dummy[1];
>+      AF_Scaler            scaler = &dummy->root.scaler;
> 
> 
>-      glyph_index = FT_Get_Char_Index( face, 'o' );
>+      glyph_index = FT_Get_Char_Index( face, charcode );
>       if ( glyph_index == 0 )
>         goto Exit;
> 
>@@ -60,13 +65,14 @@
> 
>       FT_ZERO( dummy );
> 
>+      dummy->units_per_em = metrics->units_per_em;
>       scaler->x_scale     = scaler->y_scale = 0x10000L;
>       scaler->x_delta     = scaler->y_delta = 0;
>       scaler->face        = face;
>       scaler->render_mode = FT_RENDER_MODE_NORMAL;
>       scaler->flags       = 0;
> 
>-      af_glyph_hints_rescale( hints, dummy );
>+      af_glyph_hints_rescale( hints, (AF_ScriptMetrics)dummy );
> 
>       error = af_glyph_hints_reload( hints, &face->glyph->outline );
>       if ( error )
>@@ -77,9 +83,7 @@
>         AF_LatinAxis  axis    = &metrics->axis[dim];
>         AF_AxisHints  axhints = &hints->axis[dim];
>         AF_Segment    seg, limit, link;
>-
>-        FT_UInt       num_widths              = 0;
>-        FT_Pos        edge_distance_threshold = 32000;
>+        FT_UInt       num_widths = 0;
> 
> 
>         error = af_latin_hints_compute_segments( hints,
>@@ -114,22 +118,24 @@
> 
>         af_sort_widths( num_widths, axis->widths );
>         axis->width_count = num_widths;
>+      }
>+
>+  Exit:
>+      for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )
>+      {
>+        AF_LatinAxis  axis = &metrics->axis[dim];
>+        FT_Pos        stdw;
> 
>-        /* we will now try to find the smallest width */
>-        if ( num_widths > 0 && axis->widths[0].org < edge_distance_threshold )
>-          edge_distance_threshold = axis->widths[0].org;
>-
>-        /* Now, compute the edge distance threshold as a fraction of the */
>-        /* smallest width in the font.  Set it in `hinter->glyph' too!   */
>-        if ( edge_distance_threshold == 32000 )
>-          edge_distance_threshold = 50;
> 
>-        /* let's try 20% */
>-        axis->edge_distance_threshold = edge_distance_threshold / 5;
>+        stdw = ( axis->width_count > 0 )
>+                 ? axis->widths[0].org
>+                 : AF_LATIN_CONSTANT( metrics, 50 );
>+
>+        /* let's try 20% of the smallest width */
>+        axis->edge_distance_threshold = stdw / 5;
>       }
>     }
> 
>-  Exit:
>     af_glyph_hints_done( hints );
>   }
> 
>@@ -404,7 +410,8 @@
> 
>     if ( !error )
>     {
>-      af_latin_metrics_init_widths( metrics, face );
>+      /* For now, compute the standard width and height from the `o'. */
>+      af_latin_metrics_init_widths( metrics, face, 'o' );
>       af_latin_metrics_init_blues( metrics, face );
>     }
> 
>@@ -559,6 +566,8 @@
>   af_latin_metrics_scale( AF_LatinMetrics  metrics,
>                           AF_Scaler        scaler )
>   {
>+    metrics->root.scaler.render_mode = scaler->render_mode;
>+
>     af_latin_metrics_scale_dim( metrics, scaler, AF_DIMENSION_HORZ );
>     af_latin_metrics_scale_dim( metrics, scaler, AF_DIMENSION_VERT );
>   }
>@@ -739,6 +748,7 @@
>           segment->last     = point;
>           segment->contour  = contour;
>           segment->score    = 32000;
>+          segment->len      = 0;
>           segment->link     = NULL;
>           on_edge           = 1;
> 
>@@ -805,6 +815,7 @@
>         segment->last  = min_point;
>         segment->pos   = min_pos;
>         segment->score = 32000;
>+        segment->len   = 0;
>         segment->link  = NULL;
> 
>         segment = NULL;
>@@ -824,6 +835,7 @@
>         segment->last  = max_point;
>         segment->pos   = max_pos;
>         segment->score = 32000;
>+        segment->len   = 0;
>         segment->link  = NULL;
> 
>         segment = NULL;
>@@ -844,9 +856,16 @@
>     AF_Segment    segments      = axis->segments;
>     AF_Segment    segment_limit = segments + axis->num_segments;
>     AF_Direction  major_dir     = axis->major_dir;
>+    FT_UShort     len_threshold, len_score;
>     AF_Segment    seg1, seg2;
> 
>-  
>+
>+    len_threshold = AF_LATIN_CONSTANT( hints->metrics, 8 );
>+    if ( len_threshold == 0 )
>+      len_threshold = 1;
>+
>+    len_score = AF_LATIN_CONSTANT( hints->metrics, 3000 );
>+
>     /* now compare each segment to the others */
>     for ( seg1 = segments; seg1 < segment_limit; seg1++ )
>     {
>@@ -879,9 +898,9 @@
>               max = seg2->max_coord;
> 
>             len = max - min;
>-            if ( len >= 8 )
>+            if ( len >= len_threshold )
>             {
>-              score = dist + 3000 / len;
>+              score = dist + len_score / len;
> 
>               if ( score < seg1->score )
>               {
>@@ -1292,6 +1311,7 @@
>                        AF_LatinMetrics  metrics )
>   {
>     FT_Render_Mode  mode;
>+    FT_UInt32       scaler_flags, other_flags;
> 
> 
>     af_glyph_hints_rescale( hints, (AF_ScriptMetrics)metrics );
>@@ -1305,32 +1325,50 @@
>     hints->y_scale = metrics->axis[AF_DIMENSION_VERT].scale;
>     hints->y_delta = metrics->axis[AF_DIMENSION_VERT].delta;
> 
>-    /* compute flags depending on render mode, etc... */
>-
>+    /* compute flags depending on render mode, etc. */
>     mode = metrics->root.scaler.render_mode;
> 
>+#ifdef AF_USE_WARPER
>+    if ( mode == FT_RENDER_MODE_LCD || mode == FT_RENDER_MODE_LCD_V )
>+    {
>+      metrics->root.scaler.render_mode = mode = FT_RENDER_MODE_NORMAL;
>+    }
>+#endif
>+
>+    scaler_flags = hints->scaler_flags;
>+    other_flags  = 0;
>+
>     /*
>      *  We snap the width of vertical stems for the monochrome and
>      *  horizontal LCD rendering targets only.
>      */
>     if ( mode == FT_RENDER_MODE_MONO || mode == FT_RENDER_MODE_LCD )
>-      hints->other_flags |= AF_LATIN_HINTS_HORZ_SNAP;
>+      other_flags |= AF_LATIN_HINTS_HORZ_SNAP;
> 
>     /*
>      *  We snap the width of horizontal stems for the monochrome and
>      *  vertical LCD rendering targets only.
>      */
>     if ( mode == FT_RENDER_MODE_MONO || mode == FT_RENDER_MODE_LCD_V )
>-      hints->other_flags |= AF_LATIN_HINTS_VERT_SNAP;
>+      other_flags |= AF_LATIN_HINTS_VERT_SNAP;
> 
>     /*
>      *  We adjust stems to full pixels only if we don't use the `light' mode.
>      */
>     if ( mode != FT_RENDER_MODE_LIGHT )
>-      hints->other_flags |= AF_LATIN_HINTS_STEM_ADJUST;
>+      other_flags |= AF_LATIN_HINTS_STEM_ADJUST;
> 
>     if ( mode == FT_RENDER_MODE_MONO )
>-      hints->other_flags |= AF_LATIN_HINTS_MONO;
>+      other_flags |= AF_LATIN_HINTS_MONO;
>+
>+    /*
>+     *  In `light' hinting mode we disable horizontal hinting completely.
>+     */
>+    if ( mode == FT_RENDER_MODE_LIGHT )
>+      scaler_flags |= AF_SCALER_FLAG_NO_HORIZONTAL;
>+
>+    hints->scaler_flags = scaler_flags;
>+    hints->other_flags  = other_flags;
> 
>     return 0;
>   }
>@@ -1405,7 +1443,7 @@
>     AF_LatinAxis     axis     = & metrics->axis[dim];
>     FT_Pos           dist     = width;
>     FT_Int           sign     = 0;
>-    FT_Int           vertical = AF_HINTS_DO_VERTICAL( hints );
>+    FT_Int           vertical = ( dim == AF_DIMENSION_VERT );
> 
> 
>     if ( !AF_LATIN_HINTS_DO_STEM_ADJUST( hints ) )
>@@ -1926,6 +1964,20 @@
>       if ( ( dim == AF_DIMENSION_HORZ && AF_HINTS_DO_HORIZONTAL( hints ) ) ||
>            ( dim == AF_DIMENSION_VERT && AF_HINTS_DO_VERTICAL( hints ) )   )
>       {
>+#ifdef AF_USE_WARPER
>+        if ( dim == AF_DIMENSION_HORZ &&
>+             metrics->root.scaler.render_mode == FT_RENDER_MODE_NORMAL )
>+        {
>+          AF_WarperRec  warper;
>+          FT_Fixed      scale;
>+          FT_Pos        delta;
>+
>+
>+          af_warper_compute( &warper, hints, dim, &scale, &delta );
>+          af_glyph_hints_scale_dim( hints, dim, scale, delta );
>+          continue;
>+        }
>+#endif
>         af_latin_hint_edges( hints, (AF_Dimension)dim );
>         af_glyph_hints_align_edge_points( hints, (AF_Dimension)dim );
>         af_glyph_hints_align_strong_points( hints, (AF_Dimension)dim );
>diff -urN freetype-2.1.10.old/src/autofit/aflatin.h freetype-2.1.10.autofit-backport/src/autofit/aflatin.h
>--- freetype-2.1.10.old/src/autofit/aflatin.h	2005-03-04 00:10:40.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/aflatin.h	2006-03-14 23:10:46.000000000 +0800
>@@ -4,7 +4,7 @@
> /*                                                                         */
> /*    Auto-fitter hinting routines for latin script (specification).       */
> /*                                                                         */
>-/*  Copyright 2003, 2004, 2005 by                                          */
>+/*  Copyright 2003, 2004, 2005, 2006 by                                    */
> /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
> /*                                                                         */
> /*  This file is part of the FreeType project, and may only be used,       */
>@@ -31,6 +31,11 @@
>   af_latin_script_class;
> 
> 
>+/* constants are given with units_per_em == 2048 in mind */
>+#define AF_LATIN_CONSTANT( metrics, c ) \
>+  ( ( (c) * (FT_Long)( (AF_LatinMetrics)(metrics) )->units_per_em ) / 2048 )
>+
>+
>   /*************************************************************************/
>   /*************************************************************************/
>   /*****                                                               *****/
>@@ -126,6 +131,10 @@
>   af_latin_metrics_scale( AF_LatinMetrics  metrics,
>                           AF_Scaler        scaler );
> 
>+  FT_LOCAL( void )
>+  af_latin_metrics_init_widths( AF_LatinMetrics  metrics,
>+                                FT_Face          face,
>+                                FT_ULong         charcode );
> 
> 
>   /*************************************************************************/
>diff -urN freetype-2.1.10.old/src/autofit/afloader.c freetype-2.1.10.autofit-backport/src/autofit/afloader.c
>--- freetype-2.1.10.old/src/autofit/afloader.c	2005-03-23 21:35:18.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/afloader.c	2006-03-14 23:10:46.000000000 +0800
>@@ -4,7 +4,7 @@
> /*                                                                         */
> /*    Auto-fitter glyph loading routines (body).                           */
> /*                                                                         */
>-/*  Copyright 2003, 2004, 2005 by                                          */
>+/*  Copyright 2003, 2004, 2005, 2006 by                                    */
> /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
> /*                                                                         */
> /*  This file is part of the FreeType project, and may only be used,       */
>@@ -138,9 +138,9 @@
> 
>       /* copy the outline points in the loader's current               */
>       /* extra points which is used to keep original glyph coordinates */
>-      error = FT_GlyphLoader_CheckPoints( gloader,
>-                                          slot->outline.n_points + 4,
>-                                          slot->outline.n_contours );
>+      error = FT_GLYPHLOADER_CHECK_POINTS( gloader,
>+                                           slot->outline.n_points + 4,
>+                                           slot->outline.n_contours );
>       if ( error )
>         goto Exit;
> 
>@@ -184,6 +184,7 @@
>       /* we now need to hint the metrics according to the change in */
>       /* width/positioning that occured during the hinting process  */
>       {
>+#ifndef AF_USE_WARPER
>         FT_Pos        old_advance, old_rsb, old_lsb, new_lsb;
>         FT_Pos        pp1x_uh, pp2x_uh;
>         AF_AxisHints  axis  = &hints->axis[AF_DIMENSION_HORZ];
>@@ -192,7 +193,7 @@
>                               axis->num_edges - 1; /* rightmost edge */
> 
> 
>-        if ( axis->num_edges > 1 )
>+        if ( axis->num_edges > 1 && AF_HINTS_DO_ADVANCE( hints ) )
>         {
>           old_advance = loader->pp2.x;
>           old_rsb     = old_advance - edge2->opos;
>@@ -228,6 +229,7 @@
> 
>         }
>         else
>+#endif /* !AF_USE_WARPER */
>         {
>           loader->pp1.x = FT_PIX_ROUND( loader->pp1.x );
>           loader->pp2.x = FT_PIX_ROUND( loader->pp2.x );
>@@ -376,12 +378,21 @@
>   Hint_Metrics:
>     if ( depth == 0 )
>     {
>-      FT_BBox  bbox;
>+      FT_BBox    bbox;
>+      FT_Vector  vvector;
> 
> 
>+      vvector.x = slot->metrics.vertBearingX - slot->metrics.horiBearingX;
>+      vvector.y = slot->metrics.vertBearingY - slot->metrics.horiBearingY;
>+      vvector.x = FT_MulFix( vvector.x, metrics->scaler.x_scale );
>+      vvector.y = FT_MulFix( vvector.y, metrics->scaler.y_scale );
>+
>       /* transform the hinted outline if needed */
>       if ( loader->transformed )
>+      {
>         FT_Outline_Transform( &gloader->base.outline, &loader->trans_matrix );
>+        FT_Vector_Transform( &vvector, &loader->trans_matrix );
>+      }
> 
>       /* we must translate our final outline by -pp1.x and compute */
>       /* the new metrics                                           */
>@@ -400,6 +411,9 @@
>       slot->metrics.horiBearingX = bbox.xMin;
>       slot->metrics.horiBearingY = bbox.yMax;
> 
>+      slot->metrics.vertBearingX = FT_PIX_FLOOR( bbox.xMin + vvector.x );
>+      slot->metrics.vertBearingY = FT_PIX_FLOOR( bbox.yMax + vvector.y );
>+
>       /* for mono-width fonts (like Andale, Courier, etc.) we need */
>       /* to keep the original rounded advance width                */
> #if 0
>@@ -416,7 +430,11 @@
>                                                metrics->scaler.x_scale );
> #endif
> 
>+      slot->metrics.vertAdvance = FT_MulFix( slot->metrics.vertAdvance,
>+                                              metrics->scaler.y_scale );
>+
>       slot->metrics.horiAdvance = FT_PIX_ROUND( slot->metrics.horiAdvance );
>+      slot->metrics.vertAdvance = FT_PIX_ROUND( slot->metrics.vertAdvance );
> 
>       /* now copy outline into glyph slot */
>       FT_GlyphLoader_Rewind( internal->loader );
>diff -urN freetype-2.1.10.old/src/autofit/aftypes.h freetype-2.1.10.autofit-backport/src/autofit/aftypes.h
>--- freetype-2.1.10.old/src/autofit/aftypes.h	2005-03-04 00:27:16.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/aftypes.h	2006-03-14 23:10:46.000000000 +0800
>@@ -4,7 +4,7 @@
> /*                                                                         */
> /*    Auto-fitter types (specification only).                              */
> /*                                                                         */
>-/*  Copyright 2003, 2004, 2005 by                                          */
>+/*  Copyright 2003, 2004, 2005, 2006 by                                    */
> /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
> /*                                                                         */
> /*  This file is part of the FreeType project, and may only be used,       */
>@@ -16,20 +16,20 @@
> /***************************************************************************/
> 
> 
>-/***************************************************************************
>- *
>- *  The auto-fitter is a complete rewrite of the old auto-hinter.
>- *  Its main feature is the ability to differentiate between different
>- *  scripts in order to apply language-specific rules.
>- *
>- *  The code has also been compartimentized into several entities that
>- *  should make algorithmic experimentation easier than with the old
>- *  code.
>- *
>- *  Finally, we get rid of the Catharon license, since this code is
>- *  released under the FreeType one.
>- *
>- ***************************************************************************/
>+  /*************************************************************************
>+   *
>+   *  The auto-fitter is a complete rewrite of the old auto-hinter.
>+   *  Its main feature is the ability to differentiate between different
>+   *  scripts in order to apply language-specific rules.
>+   *
>+   *  The code has also been compartimentized into several entities that
>+   *  should make algorithmic experimentation easier than with the old
>+   *  code.
>+   *
>+   *  Finally, we get rid of the Catharon license, since this code is
>+   *  released under the FreeType one.
>+   *
>+   *************************************************************************/
> 
> 
> #ifndef __AFTYPES_H__
>@@ -53,6 +53,7 @@
>   /*************************************************************************/
>   /*************************************************************************/
> 
>+#define xxAF_USE_WARPER  /* only define to use warp hinting */
> #define xxAF_DEBUG
> 
> #ifdef AF_DEBUG
>@@ -125,6 +126,7 @@
>                  FT_Pos  dy );
> 
> 
>+#if 0
>   /*
>    *  compute `angle2 - angle1'; the result is always within
>    *  the range [-AF_ANGLE_PI .. AF_ANGLE_PI - 1]
>@@ -132,6 +134,23 @@
>   FT_LOCAL( AF_Angle )
>   af_angle_diff( AF_Angle  angle1,
>                  AF_Angle  angle2 );
>+#endif /* 0 */
>+
>+
>+#define AF_ANGLE_DIFF( result, angle1, angle2 ) \
>+  FT_BEGIN_STMNT                                \
>+    AF_Angle  _delta = (angle2) - (angle1);     \
>+                                                \
>+                                                \
>+    _delta %= AF_ANGLE_2PI;                     \
>+    if ( _delta < 0 )                           \
>+      _delta += AF_ANGLE_2PI;                   \
>+                                                \
>+    if ( _delta > AF_ANGLE_PI )                 \
>+      _delta -= AF_ANGLE_2PI;                   \
>+                                                \
>+    result = _delta;                            \
>+  FT_END_STMNT
> 
> 
>   /*************************************************************************/
>@@ -240,6 +259,7 @@
>   {
>     AF_SCRIPT_NONE  = 0,
>     AF_SCRIPT_LATIN = 1,
>+    AF_SCRIPT_CJK   = 2,
>     /* add new scripts here.  Don't forget to update the list in */
>     /* `afglobal.c'.                                             */
> 
>diff -urN freetype-2.1.10.old/src/autofit/afwarp.c freetype-2.1.10.autofit-backport/src/autofit/afwarp.c
>--- freetype-2.1.10.old/src/autofit/afwarp.c	1970-01-01 08:00:00.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/afwarp.c	2006-03-14 23:10:46.000000000 +0800
>@@ -0,0 +1,313 @@
>+/***************************************************************************/
>+/*                                                                         */
>+/*  afwarp.c                                                               */
>+/*                                                                         */
>+/*    Auto-fitter warping algorithm (body).                                */
>+/*                                                                         */
>+/*  Copyright 2006 by                                                      */
>+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
>+/*                                                                         */
>+/*  This file is part of the FreeType project, and may only be used,       */
>+/*  modified, and distributed under the terms of the FreeType project      */
>+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
>+/*  this file you indicate that you have read the license and              */
>+/*  understand and accept it fully.                                        */
>+/*                                                                         */
>+/***************************************************************************/
>+
>+
>+#include "afwarp.h"
>+
>+#ifdef AF_USE_WARPER
>+
>+#if 1
>+  static const AF_WarpScore
>+  af_warper_weights[64] =
>+  {
>+    35, 20, 20, 20, 15, 12, 10,  5,  2,  1,  0,  0,  0,  0,  0,  0,
>+     0,  0,  0,  0,  0,  0, -1, -2, -5, -8,-10,-10,-20,-20,-30,-30,
>+
>+   -30,-30,-20,-20,-10,-10, -8, -5, -2, -1,  0,  0,  0,  0,  0,  0,
>+     0,  0,  0,  0,  0,  0,  0,  1,  2,  5, 10, 12, 15, 20, 20, 20,
>+  };
>+#else
>+  static const AF_WarpScore
>+  af_warper_weights[64] =
>+  {
>+    30, 20, 10,  5,  4,  4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,
>+     0,  0,  0,  0,  0,  0,  0, -1, -2, -2, -5, -5,-10,-10,-15,-20,
>+
>+   -20,-15,-15,-10,-10, -5, -5, -2, -2, -1,  0,  0,  0,  0,  0,  0,
>+     0,  0,  0,  0,  0,  0,  0,  0,  1,  2,  3,  4,  4,  5, 10, 20,
>+  };
>+#endif
>+
>+
>+  static void
>+  af_warper_compute_line_best( AF_Warper     warper,
>+                               FT_Fixed      scale,
>+                               FT_Pos        delta,
>+                               FT_Pos        xx1,
>+                               FT_Pos        xx2,
>+                               AF_WarpScore  base_distort,
>+                               AF_Segment    segments,
>+                               FT_UInt       num_segments )
>+  {
>+    FT_Int        idx_min, idx_max, idx0;
>+    FT_UInt       nn;
>+    AF_WarpScore  scores[64];
>+
>+
>+    for ( nn = 0; nn < 64; nn++ )
>+      scores[nn] = 0;
>+
>+    idx0 = xx1 - warper->t1;
>+
>+    /* compute minimum and maximum indices */
>+    {
>+      FT_Pos  xx1min = warper->x1min;
>+      FT_Pos  xx1max = warper->x1max;
>+      FT_Pos  w      = xx2 - xx1;
>+
>+
>+      if ( xx1min + w < warper->x2min )
>+        xx1min = warper->x2min - ( xx2 - xx1 );
>+
>+      xx1max = warper->x1max;
>+      if ( xx1max + w > warper->x2max )
>+        xx1max = warper->x2max - ( xx2 - xx1 );
>+
>+      idx_min = xx1min - warper->t1;
>+      idx_max = xx1max - warper->t1;
>+
>+      if ( idx_min > idx_max )
>+      {
>+        AF_LOG(( "invalid indices:\n"
>+                 "  min=%d max=%d, xx1=%ld xx2=%ld,\n"
>+                 "  x1min=%ld x1max=%ld, x2min=%ld x2max=%ld\n",
>+                 idx_min, idx_max, xx1, xx2,
>+                 warper->x1min, warper->x1max,
>+                 warper->x2min, warper->x2max ));
>+        return;
>+      }
>+    }
>+
>+    for ( nn = 0; nn < num_segments; nn++ )
>+    {
>+      FT_Pos  len = segments[nn].max_coord - segments[nn].min_coord;
>+      FT_Pos  y0  = FT_MulFix( segments[nn].pos, scale ) + delta;
>+      FT_Pos  y   = y0 + ( idx_min - idx0 );
>+
>+      FT_Int  idx;
>+
>+
>+      for ( idx = idx_min; idx <= idx_max; idx++, y++ )
>+        scores[idx] += af_warper_weights[y & 63] * len;
>+    }
>+
>+    /* find best score */
>+    {
>+      FT_Int  idx;
>+
>+
>+      for ( idx = idx_min; idx <= idx_max; idx++ )
>+      {
>+        AF_WarpScore  score = scores[idx];
>+        AF_WarpScore  distort = base_distort + ( idx - idx0 );
>+
>+
>+        if ( score > warper->best_score           ||
>+             ( score == warper->best_score    &&
>+               distort < warper->best_distort )   )
>+        {
>+          warper->best_score   = score;
>+          warper->best_distort = distort;
>+          warper->best_scale   = scale;
>+          warper->best_delta   = delta + ( idx - idx0 );
>+        }
>+      }
>+    }
>+  }
>+
>+
>+  FT_LOCAL_DEF( void )
>+  af_warper_compute( AF_Warper      warper,
>+                     AF_GlyphHints  hints,
>+                     AF_Dimension   dim,
>+                     FT_Fixed      *a_scale,
>+                     FT_Pos        *a_delta )
>+  {
>+    AF_AxisHints  axis;
>+    AF_Point      points;
>+
>+    FT_Fixed      org_scale;
>+    FT_Pos        org_delta;
>+
>+    FT_UInt       nn, num_points, num_segments;
>+    FT_Int        X1, X2;
>+    FT_Int        w;
>+
>+    AF_WarpScore  base_distort;
>+    AF_Segment    segments;
>+
>+
>+    /* get original scaling transformation */
>+    if ( dim == AF_DIMENSION_VERT )
>+    {
>+      org_scale = hints->y_scale;
>+      org_delta = hints->y_delta;
>+    }
>+    else
>+    {
>+      org_scale = hints->x_scale;
>+      org_delta = hints->x_delta;
>+    }
>+
>+    warper->best_scale   = org_scale;
>+    warper->best_delta   = org_delta;
>+    warper->best_score   = 0;
>+    warper->best_distort = 0;
>+
>+    axis         = &hints->axis[dim];
>+    segments     = axis->segments;
>+    num_segments = axis->num_segments;
>+    points       = hints->points;
>+    num_points   = hints->num_points;
>+
>+    *a_scale = org_scale;
>+    *a_delta = org_delta;
>+
>+    /* get X1 and X2, minimum and maximum in original coordinates */
>+    if ( axis->num_segments < 1 )
>+      return;
>+
>+#if 1
>+    X1 = X2 = points[0].fx;
>+    for ( nn = 1; nn < num_points; nn++ )
>+    {
>+      FT_Int  X = points[nn].fx;
>+
>+
>+      if ( X < X1 )
>+        X1 = X;
>+      if ( X > X2 )
>+        X2 = X;
>+    }
>+#else
>+    X1 = X2 = segments[0].pos;
>+    for ( nn = 1; nn < num_segments; nn++ )
>+    {
>+      FT_Int  X = segments[nn].pos;
>+
>+
>+      if ( X < X1 )
>+        X1 = X;
>+      if ( X > X2 )
>+        X2 = X;
>+    }
>+#endif
>+
>+    if ( X1 >= X2 )
>+      return;
>+
>+    warper->x1 = FT_MulFix( X1, org_scale ) + org_delta;
>+    warper->x2 = FT_MulFix( X2, org_scale ) + org_delta;
>+
>+    warper->t1 = AF_WARPER_FLOOR( warper->x1 );
>+    warper->t2 = AF_WARPER_CEIL( warper->x2 );
>+
>+    warper->x1min = warper->x1 & ~31;
>+    warper->x1max = warper->x1min + 32;
>+    warper->x2min = warper->x2 & ~31;
>+    warper->x2max = warper->x2min + 32;
>+
>+    if ( warper->x1max > warper->x2 )
>+      warper->x1max = warper->x2;
>+
>+    if ( warper->x2min < warper->x1 )
>+      warper->x2min = warper->x1;
>+
>+    warper->w0 = warper->x2 - warper->x1;
>+
>+    if ( warper->w0 <= 64 )
>+    {
>+      warper->x1max = warper->x1;
>+      warper->x2min = warper->x2;
>+    }
>+
>+    warper->wmin = warper->x2min - warper->x1max;
>+    warper->wmax = warper->x2max - warper->x1min;
>+
>+    if ( warper->wmin < warper->w0 - 32 )
>+      warper->wmin = warper->w0 - 32;
>+
>+    if ( warper->wmax > warper->w0 + 32 )
>+      warper->wmax = warper->w0 + 32;
>+
>+    if ( warper->wmin < warper->w0 * 3 / 4 )
>+      warper->wmin = warper->w0 * 3 / 4;
>+
>+    if ( warper->wmax > warper->w0 * 5 / 4 )
>+      warper->wmax = warper->w0 * 5 / 4;
>+
>+    /* warper->wmin = warper->wmax = warper->w0; */
>+
>+    for ( w = warper->wmin; w <= warper->wmax; w++ )
>+    {
>+      FT_Fixed  new_scale;
>+      FT_Pos    new_delta;
>+      FT_Pos    xx1, xx2;
>+
>+
>+      xx1 = warper->x1;
>+      xx2 = warper->x2;
>+      if ( w >= warper->w0 )
>+      {
>+        xx1 -= w - warper->w0;
>+        if ( xx1 < warper->x1min )
>+        {
>+          xx2 += warper->x1min - xx1;
>+          xx1  = warper->x1min;
>+        }
>+      }
>+      else
>+      {
>+        xx1 -= w - warper->w0;
>+        if ( xx1 > warper->x1max )
>+        {
>+          xx2 -= xx1 - warper->x1max;
>+          xx1  = warper->x1max;
>+        }
>+      }
>+
>+      if ( xx1 < warper->x1 )
>+        base_distort = warper->x1 - xx1;
>+      else
>+        base_distort = xx1 - warper->x1;
>+
>+      if ( xx2 < warper->x2 )
>+        base_distort += warper->x2 - xx2;
>+      else
>+        base_distort += xx2 - warper->x2;
>+
>+      base_distort *= 10;
>+
>+      new_scale = org_scale + FT_DivFix( w - warper->w0, X2 - X1 );
>+      new_delta = xx1 - FT_MulFix( X1, new_scale );
>+
>+      af_warper_compute_line_best( warper, new_scale, new_delta, xx1, xx2,
>+                                   base_distort,
>+                                   segments, num_segments );
>+    }
>+
>+    *a_scale = warper->best_scale;
>+    *a_delta = warper->best_delta;
>+  }
>+
>+#else /* !AF_USE_WARPER */
>+
>+char  af_warper_dummy = 0;  /* make compiler happy */
>+
>+#endif /* !AF_USE_WARPER */
>+
>+/* END */
>diff -urN freetype-2.1.10.old/src/autofit/afwarp.h freetype-2.1.10.autofit-backport/src/autofit/afwarp.h
>--- freetype-2.1.10.old/src/autofit/afwarp.h	1970-01-01 08:00:00.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/afwarp.h	2006-03-14 23:10:46.000000000 +0800
>@@ -0,0 +1,65 @@
>+/***************************************************************************/
>+/*                                                                         */
>+/*  afwarp.h                                                               */
>+/*                                                                         */
>+/*    Auto-fitter warping algorithm (specification).                       */
>+/*                                                                         */
>+/*  Copyright 2006 by                                                      */
>+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
>+/*                                                                         */
>+/*  This file is part of the FreeType project, and may only be used,       */
>+/*  modified, and distributed under the terms of the FreeType project      */
>+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
>+/*  this file you indicate that you have read the license and              */
>+/*  understand and accept it fully.                                        */
>+/*                                                                         */
>+/***************************************************************************/
>+
>+
>+#ifndef __AFWARP_H__
>+#define __AFWARP_H__
>+
>+#include "afhints.h"
>+
>+FT_BEGIN_HEADER
>+
>+#define AF_WARPER_SCALE
>+
>+#define AF_WARPER_FLOOR( x )  ( (x) & ~63 )
>+#define AF_WARPER_CEIL( x )   AF_WARPER_FLOOR( (x) + 63 )
>+
>+
>+  typedef FT_Int32  AF_WarpScore;
>+
>+  typedef struct  AF_WarperRec_
>+  {
>+    FT_Int        X1, X2;
>+    FT_Pos        x1, x2;
>+    FT_Pos        t1, t2;
>+    FT_Pos        x1min, x1max;
>+    FT_Pos        x2min, x2max;
>+    FT_Pos        w0, wmin, wmax;
>+
>+    FT_Fixed      best_scale;
>+    FT_Pos        best_delta;
>+    AF_WarpScore  best_score;
>+    AF_WarpScore  best_distort;
>+
>+  } AF_WarperRec, *AF_Warper;
>+
>+
>+  FT_LOCAL( void )
>+  af_warper_compute( AF_Warper      warper,
>+                     AF_GlyphHints  hints,
>+                     AF_Dimension   dim,
>+                     FT_Fixed      *a_scale,
>+                     FT_Fixed      *a_delta );
>+
>+
>+FT_END_HEADER
>+
>+
>+#endif /* __AFWARP_H__ */
>+
>+
>+/* END */
>diff -urN freetype-2.1.10.old/src/autofit/autofit.c freetype-2.1.10.autofit-backport/src/autofit/autofit.c
>--- freetype-2.1.10.old/src/autofit/autofit.c	2005-03-04 00:27:58.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/autofit.c	2006-03-14 23:10:46.000000000 +0800
>@@ -4,7 +4,7 @@
> /*                                                                         */
> /*    Auto-fitter module (body).                                           */
> /*                                                                         */
>-/*  Copyright 2003, 2004, 2005 by                                          */
>+/*  Copyright 2003, 2004, 2005, 2006 by                                    */
> /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
> /*                                                                         */
> /*  This file is part of the FreeType project, and may only be used,       */
>@@ -23,8 +23,12 @@
> #include "afhints.c"
> #include "afdummy.c"
> #include "aflatin.c"
>+#include "afcjk.c"
> #include "afloader.c"
> #include "afmodule.c"
> 
>+#ifdef AF_USE_WARPER
>+#include "afwarp.c"
>+#endif
> 
> /* END */
>diff -urN freetype-2.1.10.old/src/autofit/Jamfile freetype-2.1.10.autofit-backport/src/autofit/Jamfile
>--- freetype-2.1.10.old/src/autofit/Jamfile	2005-06-05 06:49:41.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/Jamfile	2006-03-14 23:29:36.000000000 +0800
>@@ -1,6 +1,6 @@
> # FreeType 2 src/autofit Jamfile
> #
>-# Copyright 2003, 2004, 2005 by
>+# Copyright 2003, 2004, 2005, 2006 by
> # David Turner, Robert Wilhelm, and Werner Lemberg.
> #
> # This file is part of the FreeType project, and may only be used, modified,
>@@ -16,7 +16,7 @@
> 
>   if $(FT2_MULTI)
>   {
>-    _sources = afangles afglobal afhints aflatin afloader afmodule afdummy ;
>+    _sources = afangles afglobal afhints aflatin afloader afmodule afdummy afwarp afcjk;
>   }
>   else
>   {
>diff -urN freetype-2.1.10.old/src/autofit/rules.mk freetype-2.1.10.autofit-backport/src/autofit/rules.mk
>--- freetype-2.1.10.old/src/autofit/rules.mk	2005-03-23 21:22:23.000000000 +0800
>+++ freetype-2.1.10.autofit-backport/src/autofit/rules.mk	2006-03-14 23:10:47.000000000 +0800
>@@ -3,7 +3,7 @@
> #
> 
> 
>-# Copyright 2003, 2004, 2005 by
>+# Copyright 2003, 2004, 2005, 2006 by
> # David Turner, Robert Wilhelm, and Werner Lemberg.
> #
> # This file is part of the FreeType project, and may only be used, modified,
>@@ -30,8 +30,10 @@
>                  $(AUTOF_DIR)/afglobal.c \
>                  $(AUTOF_DIR)/afhints.c  \
>                  $(AUTOF_DIR)/aflatin.c  \
>+                 $(AUTOF_DIR)/afcjk.c    \
>                  $(AUTOF_DIR)/afloader.c \
>-                 $(AUTOF_DIR)/afmodule.c
>+                 $(AUTOF_DIR)/afmodule.c \
>+                 $(AUTOF_DIR)/afwarp.c
> 
> # AUTOF driver headers
> #

Actions: View | Diff

Attachments on bug 157441: 72418 | 72726 | 72728 | 72808 | 72830 | 72831 | 72883 | 76171 | 76172 | 76174 | 76176 | 76177 | 76181