Attachment #20554 for bug #31347

View | Details | Raw Unified | Return to bug 31347
Collapse All | Expand All




  /* cf. AH_BLUE_XXX constants in ahtypes.h */

  static
  const char*  blue_chars_latin[AH_BLUE_MAX] =
  {
    "THEZOCQS",
    "HEZLOCUS",

  };


  typedef struct AH_BlueTable_
  {
    FT_ULong      offset_blue_chars;
    const char**  blue_chars;
    FT_ULong      char_for_widths;

  } AH_BlueTable;


  static const AH_BlueTable  blue_table[AH_CHAR_TYPE_COUNT] =
  {
    { 0,       blue_chars_latin, (FT_ULong)'o' },
    { 0xFEE0L, blue_chars_latin,  0xFF4FL      },
    { 0,       0,                 0            },
    { 0,       0,                 0            }
  };


#ifdef AH_DEBUG
  static const char*  blue_names[AH_CHAR_TYPE_COUNT] =
  {
    "general latinate chars",
    "CJK fullwidth latin chars",
    0,
    0
  };
#endif


  /* simple insertion sort */
  static void
  sort_values( FT_Int   count,

  ah_hinter_compute_blues( AH_Hinter  hinter )
  {
    AH_Blue       blue;
    AH_Globals    globals = hinter->globals->designs;
    FT_Pos        flats [MAX_TEST_CHARACTERS];
    FT_Pos        rounds[MAX_TEST_CHARACTERS];
    FT_Int        num_flats;

    FT_GlyphSlot  glyph;
    FT_Error      error;
    FT_CharMap    charmap;
    FT_ULong      offset;
    FT_Byte       type;
    const char**  blue_chars;


    face  = hinter->face;

    /* we compute the blues simply by loading each character from the */
    /* 'blue_chars[blues]' string, then compute its top-most or       */
    /* bottom-most points (depending on `AH_IS_TOP_BLUE')             */
    type = AH_CHAR_TYPE_LATINATE;

  Compute_Blues:
    globals->has_blues = FALSE;
    globals->baseline  = 0;

    offset     = blue_table[type].offset_blue_chars;
    blue_chars = blue_table[type].blue_chars;

    if ( !blue_chars )
      goto Next_Type;

    AH_LOG(( "blue zones computation for %s\n", blue_names[type] ));
    AH_LOG(( "------------------------------------------------\n" ));

    for ( blue = AH_BLUE_CAPITAL_TOP; blue < AH_BLUE_MAX; blue++ )

        AH_LOG(( "`%c'", *p ));

        /* load the character in the face -- skip unknown or empty ones */
        glyph_index = FT_Get_Char_Index( face, offset + (FT_ULong)*p );
        if ( glyph_index == 0 )
          continue;



          } while ( next != idx );

          /* now, set the `round' flag depending on whether there exists */
          /* a extremum line segment within the current zone.            */
          round = TRUE;

          {
            FT_Int   n = 0, p = prev;
            FT_Bool  is_top = AH_IS_TOP_BLUE( blue );


            while ( ( p = ( p >= last )? first : p + 1 ) != next )
            {
              if ( FT_CURVE_TAG( glyph->outline.tags[p] ) == FT_CURVE_TAG_ON )
              {
                if ( (  is_top && points[p].y < extremum->y ) ||
                     ( !is_top && points[p].y > extremum->y )  )
                  break;

                n++;
              }
            }

            if ( n >= 2 && p == next )
              round = FALSE;
          }

          AH_LOG(( "%c ", round ? 'r' : 'f' ));
        }

      }

      AH_LOG(( "-- ref = %ld, shoot = %ld\n", *blue_ref, *blue_shoot ));

      if ( num_flats > 0 || num_rounds > 0 )
        globals->has_blues = TRUE;
    }

    globals->baseline = globals->blue_refs[AH_BLUE_SMALL_BOTTOM];

    if ( globals->baseline > -10000 )
    {
      for ( blue = AH_BLUE_CAPITAL_TOP; blue < AH_BLUE_MAX; blue++ )
      {
        if ( globals->blue_refs[blue] > -10000 )
        {
          globals->blue_refs[blue]   -= globals->baseline;
          globals->blue_shoots[blue] -= globals->baseline;
        }
      }
    }

  Next_Type:
    if ( ++type < AH_CHAR_TYPE_COUNT )
    {
      globals++;
      goto Compute_Blues;
    }

    /* reset original face charmap */

    AH_Outline  outline = hinter->glyph;
    AH_Segment  segments;
    AH_Segment  limit;
    AH_Globals  globals = hinter->globals->designs;
    FT_Pos*     widths;
    FT_Int      dimension;
    FT_Int*     p_num_widths;
    FT_Error    error = 0;
    FT_Pos      edge_distance_threshold = 32000;
    FT_Byte     type;
    FT_ULong    char_for_widths;


    type = AH_CHAR_TYPE_LATINATE;

  Compute_Widths:
    char_for_widths = blue_table[type].char_for_widths;

    if ( !char_for_widths )
      goto Next_Type;

    globals->num_widths  = 0;
    globals->num_heights = 0;

      FT_UInt  glyph_index;


      glyph_index = FT_Get_Char_Index( hinter->face, char_for_widths );
      if ( glyph_index == 0 )
        goto Next_Type;

      error = FT_Load_Glyph( hinter->face, glyph_index, FT_LOAD_NO_SCALE );
      if ( error )
        goto Next_Type;

      error = ah_outline_load( hinter->glyph, 0x10000L, 0x10000L,
                               hinter->face );
      if ( error )
        goto Next_Type;

      ah_outline_compute_segments( hinter->glyph );
      ah_outline_link_segments( hinter->glyph );

      p_num_widths = &globals->num_widths;
    }

  Next_Type:
    if ( type++ < AH_CHAR_TYPE_COUNT )
    {
      globals++;
      goto Compute_Widths;
    }

    /* 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 )

    /* let's try 20% */
    hinter->glyph->edge_distance_threshold = edge_distance_threshold / 5;

    return 0;
    return error;
  }



  {
    return ah_hinter_compute_widths( hinter ) ||
           ah_hinter_compute_blues ( hinter );
  }


  static const AH_CharType
  ah_types_for_unicode[] =
  {
     /* Latin, Greek, Cyrillic */
    { AH_CHAR_TYPE_LATINATE,        0x21L,   0x52FL  },

     /* Hebrew */
    { AH_CHAR_TYPE_LATINATE,        0x5D0L,  0x600L  },

     /* Latin, Greek */
    { AH_CHAR_TYPE_LATINATE,        0x1E00L, 0x2000L },

     /* CJK fullwidth Latin */
    { AH_CHAR_TYPE_LATIN_FULLWIDTH, 0xFF00L, 0xFF60L }
  };


  static const AH_CharTypeTable
  ah_types_table_unicode =
  {
    sizeof( ah_types_for_unicode ) / sizeof( AH_CharType ),
    (AH_CharType *)ah_types_for_unicode
  };


  FT_LOCAL_DEF( void )
  ah_hinter_compute_char_table( AH_Hinter  hinter )
  {
    FT_Memory          memory     = hinter->memory;
    FT_Face            face       = hinter->face;
    AH_CharTypeTable*  table      = hinter->globals->table;
    FT_ULong           num_glyphs = face->num_glyphs;
    FT_Byte*           types;
    FT_Error           error;
    FT_CharMap         charmap;


    if ( table )
      return;

    if ( num_glyphs <= 0 )
      return;

    if ( FT_NEW_ARRAY( types, num_glyphs ) )
      return;

    FT_MEM_SET( types, AH_CHAR_TYPE_OTHER, num_glyphs );

    charmap = face->charmap;
    if ( FT_Select_Charmap( face, FT_ENCODING_UNICODE ) )
      goto Exit;


    {
      FT_Bool   empty = TRUE;
      FT_ULong  i;


      for ( i = 0; i < ah_types_table_unicode.size; i++ )
      {
        FT_UInt   glyph_index;
        FT_ULong  start = ah_types_table_unicode.types[i].start;
        FT_ULong  last  = ah_types_table_unicode.types[i].last;
        FT_Byte   type  = ah_types_table_unicode.types[i].type;
        FT_ULong  ucs   = FT_Get_Next_Char( face, start - 1, &glyph_index );


        while ( ucs && ucs <= last )
        {
          if ( glyph_index < num_glyphs )
          {
            empty = FALSE;
            types[glyph_index] = type;
          }

          ucs = FT_Get_Next_Char( face, ucs, &glyph_index );
        }
      }

      if ( empty )
        goto Exit;
    }


    {
      FT_Byte*  cur  = types;
      FT_Byte*  last = types + num_glyphs - 1;
      FT_Byte   type = AH_CHAR_TYPE_OTHER;
      FT_ULong  num  = 0;
      FT_ULong  alloc_size;


      while ( ++cur <= last )
      {
        if ( *cur != type )
        {
          type = *cur;

          if ( type < AH_CHAR_TYPE_OTHER )
            num++;
        }
      }

      alloc_size = sizeof( AH_CharTypeTable ) + num * sizeof( AH_CharType );
      if ( FT_ALLOC( table, alloc_size ) )
        goto Exit;

      table->size  = num;
      table->types = (AH_CharType *)( table + 1 );
    }


    {
      FT_Byte*  cur  = types + 1;
      FT_Byte*  last = types + face->num_glyphs - 1;
      FT_Byte   type = AH_CHAR_TYPE_OTHER;
      FT_ULong  num  = 0;
      FT_ULong  i;


      for ( i = 1; cur <= last; i++, cur++ )
      {
        if ( *cur != type )
        {
          if ( type < AH_CHAR_TYPE_OTHER )
            table->types[num - 1].last = i - 1;

          type = *cur;
          if ( type < AH_CHAR_TYPE_OTHER )
          {
            table->types[num].type    = type;
            table->types[num++].start = i;
          }
        }
      }

      if ( type < AH_CHAR_TYPE_OTHER )
        table->types[num - 1].last = i - 1;
    }

    hinter->globals->table = table;

  Exit:
    FT_Set_Charmap( face, charmap );
    FT_FREE( types );
  }


  FT_LOCAL_DEF( FT_Byte )
  ah_hinter_get_char_type( AH_Hinter  hinter,
                           FT_ULong   glyph_index )
  {
    AH_CharTypeTable*  table = hinter->globals->table;


    if ( table && table->size > 0 && glyph_index )
    {
      AH_CharType*  cur;
      AH_CharType*  types = table->types;
      FT_ULong      min   = 0;
      FT_ULong      max   = table->size - 1;
      FT_ULong      mid;


      if ( glyph_index < types[min].start ||
           glyph_index > types[max].last )
        return AH_CHAR_TYPE_OTHER;

      while ( min <= max )
      {
        mid = ( min + max ) / 2;
        cur = types + mid;

        if ( glyph_index < cur->start )
          max = mid - 1;
        else if ( glyph_index > cur->last )
          min = mid + 1;
        else
          return cur->type;
      }
    }

    return AH_CHAR_TYPE_OTHER;
  }



Lines 51-56 Link Here

(-)freetype-2.1.5-orig/src/autohint/ahglobal.h (+8 lines)
51	ah_hinter_compute_globals( AH_Hinter hinter );	51	ah_hinter_compute_globals( AH_Hinter hinter );
52		52
53		53
		54	FT_LOCAL( void )
		55	ah_hinter_compute_char_table( AH_Hinter hinter );
		56
		57
		58	FT_LOCAL( FT_Byte )
		59	ah_hinter_get_char_type( AH_Hinter hinter,
		60	FT_ULong glyph_index );
		61
54	FT_END_HEADER	62	FT_END_HEADER
55		63
56	#endif /* __AHGLOBAL_H__ */	64	#endif /* __AHGLOBAL_H__ */





#include <ft2build.h>
#include "ahglyph.h"
#include "ahangles.h"
#include "ahglobal.h"
#include "aherrors.h"


      printf ( "Table of %s edges:\n",
               !dimension ? "vertical" : "horizontal" );
      printf ( "  [ index |  pos |  dir  | link |"
               " serif | blue | opos  |  pos  |  diff ]\n" );

      for ( edge = edges; edge < edge_limit; edge++ )
      {
        printf ( "  [ %5d | %4d | %5s | %4d | %6d |  %c  | %5.2f | %5.2f | %5.2f ]\n",
                 edge - edges,
                 (int)edge->fpos,
                 edge->dir == AH_DIR_UP

                 edge->serif ? ( edge->serif - edges ) : -1,
                 edge->blue_edge ? 'y' : 'n',
                 edge->opos / 64.0,
                 edge->pos / 64.0,
                 ( edge->pos - edge->opos ) / 64.0 );
      }

      edges      = outline->vert_edges;

    char*       tag         = gloader->current.outline.tags;


#ifdef AH_DEBUG
    ah_dump_segments( outline );
    ah_dump_edges( outline );
    printf( "\n" );
 #endif

    /* we assume that the glyph loader has already been checked for storage */
    for ( ; point < point_limit; point++, vec++, tag++ )
    {


          point->out_dir = ah_compute_direction( ovec.x, ovec.y );

#if 0
#ifndef AH_OPTION_NO_WEAK_INTERPOLATION
          if ( point->flags & ( AH_FLAG_CONIC | AH_FLAG_CUBIC ) )
          {

          else if ( point->in_dir == -point->out_dir )
            goto Is_Weak_Point;
#endif
#endif
        }
      }
    }

  }


#if 0
  /* compute all inflex points in a given glyph */
  static void
  ah_outline_compute_inflections( AH_Outline  outline )

      ;
    }
  }
#endif


  /* compute all strong points in a given glyph */
  static void
  ah_outline_compute_strongs( AH_Outline  outline )
  {
    AH_Point*   contour       = outline->contours;
    AH_Point*   contour_limit = contour + outline->num_contours;


    /* load original coordinates in (u,v) */
    ah_setup_uv( outline, AH_UV_FXY );

    for ( ; contour < contour_limit; contour++ )
    {
      FT_Pos     dx1, dx2, dy1, dy2;
      AH_Point   point = contour[0];
      AH_Point   first = point;
      AH_Point   before;
      AH_Point   after;


      after  = point->next;
      before = point->prev;
      dx1    = point->u - before->u;
      dy1    = point->v - before->v;

      do
      {
        dx2 = after->u - point->u;
        dy2 = after->v - point->v;

        if ( dx1 == 0 || dx2 == 0 || ( dx1 ^ dx2 ) < 0 )
          point->flags |= AH_FLAG_STRONG_X;

        if ( dy1 == 0 || dy2 == 0 || ( dy1 ^ dy2 ) < 0 )
          point->flags |= AH_FLAG_STRONG_Y;

        before = point;
        point  = after;
        after  = after->next;
        dx1    = dx2;
        dy1    = dy2;

      } while ( point != first );
    }
  }


  FT_LOCAL_DEF( void )

              segment->last = point;
              segment->pos  = ( min_pos + max_pos ) >> 1;

#if 0
              /* a segment is round if either its first or last point */
              /* is a control point                                   */
              if ( ( segment->first->flags | point->flags ) &
                     AH_FLAG_CONTROL                        )
                segment->flags |= AH_EDGE_ROUND;
#else
              /* a segment is round if it doesn't have successive */
              /* on-curve points.                                 */
              {
                AH_Point  pt = segment->first;
                AH_Flags  f0 = pt->flags & AH_FLAG_CONTROL;
                AH_Flags  f1;


                for ( ; pt != point; f0 = f1 )
                {
                  pt = pt->next;
                  f1 = pt->flags & AH_FLAG_CONTROL;

                  if ( !f0 && !f1 )
                    break;

                  if ( pt == point )
                    segment->flags |= AH_EDGE_ROUND;
                }
              }
#endif

              /* compute segment size */
              min_pos = max_pos = point->v;

            segment->first    = point;
            segment->last     = point;
            segment->contour  = contour;
            segment->score1   = 0x7FFFFFFFL;
            segment->score2   = 0x7FFFFFFFL;
            segment->length   = 0;
            segment->sign     = 0;
            segment->link     = NULL;
            on_edge           = 1;


          segment->first = min_point;
          segment->last  = min_point;
          segment->pos   = min_pos;
          segment->score1 = 0x7FFFFFFFL;
          segment->score2 = 0x7FFFFFFFL;
          segment->length = 0;
          segment->sign   = 0;
          segment->link  = NULL;

          num_segments++;

          segment->first = max_point;
          segment->last  = max_point;
          segment->pos   = max_pos;
          segment->score1 = 0x7FFFFFFFL;
          segment->score2 = 0x7FFFFFFFL;
          segment->length = 0;
          segment->sign   = 0;
          segment->link  = NULL;

          num_segments++;

    AH_Segment    segment_limit;
    AH_Direction  major_dir;
    int           dimension;
    FT_Pos        score_limit;


    segments      = outline->horz_segments;
    segment_limit = segments + outline->num_hsegments;
    major_dir     = outline->horz_major_dir;
    score_limit   = FT_DivFix( 64*3*9, outline->y_scale );

    for ( dimension = 1; dimension >= 0; dimension-- )
    {

                max = seg2->max_coord;

              len = max - min;
              if ( len >= 4 )
              {
                score = 8*dist;

                if ( score < seg1->score1 &&
                     !( score > seg1->score2 && 4*len < seg1->length ) )
                {
                  seg1->score1 = 9*dist;
                  seg1->score2 = 7*dist;
                  seg1->length = len;
                  seg1->sign   = -1;
                  seg1->link   = seg2;
                }

                if ( score < seg2->score1 &&
                     !( score > seg2->score2 && 4*len < seg2->length ) )
                {
                  seg2->score1 = 9*dist;
                  seg2->score2 = 7*dist;
                  seg2->length = len;
                  seg2->sign   = +1;
                  seg2->link   = seg1;
                }
              }
            }

#endif /* 1 */

      /* now, compute the `serif' segments */
      {
        AH_Segment  seg, link1, link2;
        FT_Pos      pos1, pos2;


        for ( seg1 = segments; seg1 < segment_limit; seg1++ )
        {
          if ( seg1->sign >= 0 || seg1->score1 >= score_limit )
            continue;

          link1 = seg1->link;
          if ( link1->link != seg1 )
            continue;

          pos1 = seg1->pos;
          pos2 = link1->pos;


          for ( seg2 = segments; seg2 < segment_limit; seg2++ )
          {
            if ( seg2->sign >= 0 ||
                 seg2->score1 <= seg1->score1 || seg2->pos > pos1 )
              continue;

            link2 = seg2->link;
            if ( link2->link != seg2 )
              continue;

            if ( link2->pos < pos2              ||
                 seg1->score1*4 <= seg2->score1 )
              continue;

            /* seg2->pos < pos1 < pos2 < seg2->link->pos */

            if ( seg1->length < seg2->length*2 )
            {
              seg1->link = link1->link = 0;
              seg1->sign = link1->sign = 0;
            }
            else
            {
              for ( seg = segments; seg < segment_limit; seg++ )
              {
                AH_Segment  link = seg->link;


                if ( link == seg2 )
                {
                  seg->sign  = 0;
                  seg->link  = 0;
                  seg->serif = link1;
                }
                else if ( link == link2 )
                {
                  seg->sign  = 0;
                  seg->link  = 0;
                  seg->serif = seg1;
                }
              }
            }

            break;
          }
        }
      }


      for ( seg1 = segments; seg1 < segment_limit; seg1++ )
      {
        seg2 = seg1->link;

          seg2->num_linked++;
          if ( seg2->link != seg1 )
          {
            seg1->link = 0;

            if ( seg2->score1 < score_limit    ||
                 seg1->score1 < seg2->score1*4 )
              seg1->serif = seg2->link;
            else
              seg2->num_linked--;
          }
        }
      }

      segments      = outline->vert_segments;
      segment_limit = segments + outline->num_vsegments;
      major_dir     = outline->vert_major_dir;
      score_limit   = FT_DivFix( 64*3*9, outline->x_scale );
    }
  }


          FT_Pos  dist;


          if ( edge->dir != seg->dir )
            continue;

          dist = seg->pos - edge->fpos;
          if ( dist < 0 )
            dist = -dist;

          if ( dist < edge_distance_threshold )
          {
            AH_Segment  link = seg->link;


            /* check if all linked segments of the candidate edge */
            /* can make a single edge.                            */
            if ( link )
            {
              AH_Segment  seg1 = edge->first;
              AH_Segment  link1;


              do
              {
                link1 = seg1->link;
                if ( link1 )
                {
                  dist = link->pos - link1->pos;
                  if ( dist < 0 )
                    dist = -dist;

                  dist = FT_MulFix( dist, scale );
                  if ( dist >= edge_distance_threshold )
                    break;
                }

              } while ( ( seg1 = seg1->edge_next ) != edge->first );

              if ( dist >= edge_distance_threshold )
                continue;
            }

            found = edge;
            break;
          }

          edge->fpos     = seg->pos;
          edge->opos     = edge->pos = FT_MulFix( seg->pos, scale );
          seg->edge_next = seg;
          edge->dir      = seg->dir;
        }
        else
        {

      {
        FT_Int  is_round    = 0;  /* does it contain round segments?    */
        FT_Int  is_straight = 0;  /* does it contain straight segments? */
        FT_Pos  ups         = 0;  /* number of upwards segments         */
        FT_Pos  downs       = 0;  /* number of downwards segments       */


        seg = edge->first;

          else
            is_straight++;

          /* check for segment direction */
          if ( seg->dir == up_dir )
            ups   += seg->max_coord-seg->min_coord;
          else
            downs += seg->max_coord-seg->min_coord;

          /* 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 ( is_round > 0 && is_round >= is_straight )
          edge->flags |= AH_EDGE_ROUND;

        /* set the edge's main direction */
        edge->dir = AH_DIR_NONE;

        if ( ups > downs )
          edge->dir = up_dir;

        else if ( ups < downs )
          edge->dir = -up_dir;

        else if ( ups == downs )
          edge->dir = 0;  /* both up and down! */

        /* gets rid of serifs if link is set                */
        /* XXX: This gets rid of many unpleasant artefacts! */
        /*      Example: the `c' in cour.pfa at size 13     */

    ah_outline_compute_segments   ( outline );
    ah_outline_link_segments      ( outline );
    ah_outline_compute_edges      ( outline );
    ah_outline_compute_strongs    ( outline );
  }



  {
    AH_Edge     edge       = outline->horz_edges;
    AH_Edge     edge_limit = edge + outline->num_hedges;
    AH_Globals  globals    = &face_globals->designs[face_globals->cur_type];
    FT_Fixed    y_scale    = outline->y_scale;

    FT_Bool     blue_active[AH_BLUE_MAX];


    if ( !globals->has_blues )
      return;

    /* compute which blue zones are active, i.e. have their scaled */
    /* size < 3/4 pixels                                           */
    {

      FT_Pos   best_dist;  /* initial threshold */


      if ( edge->serif )
      {
        FT_Pos  dist = edge->serif->pos - edge->pos;


        if ( dist < 0 )
          dist = -dist;

        if ( dist < 128 )
          continue;
      }

      /* compute the initial threshold as a fraction of the EM size */
      best_dist = FT_MulFix( face_globals->face->units_per_EM / 40, y_scale );


    FT_Pos   delta;


    if ( !globals->scaled.has_blues )
      return;

    delta = globals->scaled.blue_refs -
            globals->designs[globals->cur_type].blue_refs;

    for ( ; edge < edge_limit; edge++ )
    {




#include <ft2build.h>
#include "ahhint.h"
#include "ahglyph.h"
#include "ahangles.h"
#include "aherrors.h"
#include FT_OUTLINE_H
#include FT_TRUETYPE_TABLES_H


#define FACE_GLOBALS( face )  ( (AH_Face_Globals)(face)->autohint.data )


    if ( !hinter->do_stem_adjust )
    {
      if ( dist < 48 )
        dist += ( 48 - dist )/2 ;
    }
    else if ( (  vertical && !hinter->do_vert_snapping ) ||
              ( !vertical && !hinter->do_horz_snapping ) )

      /* smooth hinting process: very lightly quantize the stem width */
      /*                                                              */

#if 0
      /* leave the widths of serifs alone */

      if ( ( stem_flags & AH_EDGE_SERIF ) && vertical && ( dist < 3 * 64 ) )

      }
      else if ( dist < 56 )
        dist = 56;
#endif

      {
        FT_Pos  delta;


        if ( (  vertical && globals->num_heights > 0 ) ||
             ( !vertical && globals->num_widths  > 0 ) )

        if ( delta < 40 )
        {
          delta = dist - globals->stds[vertical];

          if ( delta < 0 )
            delta = -delta;

          if ( delta < 40 )
          {
            dist = globals->stds[vertical];
            if ( dist < 48 )
              dist = 48;

            goto Done_Width;
          }
        }

        if ( dist < 54 )
        {
          dist += ( 54 - dist )/2 ;
        }
        else if ( dist < 3 * 64 )
        {
          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
          dist = ( dist + 32 ) & -64;
      }
    }
    else

    serif->pos = base->pos + sign * dist;
  }

 
  static FT_Pos
  ah_hint_normal_stem( AH_Hinter  hinter,
                       AH_Edge    edge,
                       AH_Edge    edge2,
                       FT_Pos     anchor,
                       FT_Int     vertical )
  {
    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 ( !hinter->do_stem_adjust )
    {
      if ( ( edge->flags  & AH_EDGE_ROUND ) &&
           ( edge2->flags & AH_EDGE_ROUND )  )
      {
        if ( vertical )
          threshold = 64 - AH_LIGHT_MODE_MAX_HORZ_GAP;
        else
          threshold = 64 - AH_LIGHT_MODE_MAX_VERT_GAP;
      }
      else
      {
        if ( vertical )
          threshold = 64 - AH_LIGHT_MODE_MAX_HORZ_GAP/3;
        else
          threshold = 64 - AH_LIGHT_MODE_MAX_VERT_GAP/3;
      }
    }

    org_len    = edge2->opos - edge->opos;
    cur_len    = ah_compute_stem_width( hinter, vertical, org_len,
                                        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 - ( cur_pos1 & -64 );
    d_off2     = cur_pos2 - ( cur_pos2 & -64 );
    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 ( ABS( u_off1 ) <= ABS( u_off2 ) )
      delta = u_off1;
    else
      delta = u_off2;

  Exit:
#if 1
    if ( !hinter->do_stem_adjust )
    {
      if ( delta > AH_LIGHT_MODE_MAX_DELTA_ABS )
        delta = AH_LIGHT_MODE_MAX_DELTA_ABS;
      else if ( delta < -AH_LIGHT_MODE_MAX_DELTA_ABS )
        delta = -AH_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;
  }


  /*************************************************************************/
  /*************************************************************************/

    {
      AH_Edge  edge;
      AH_Edge  anchor = 0;
      FT_Pos   delta  = 0;
      int      has_serifs = 0;




      /* we begin by aligning all stems relative to the blue zone */
      /* if needed -- that's only for horizontal edges            */
      if ( dimension && hinter->do_blue_hints )
      {
        for ( edge = edges; edge < edge_limit; edge++ )
        {

            ah_align_linked_edge( hinter, edge1, edge2, dimension );
            edge2->flags |= AH_EDGE_DONE;
          }

          if ( !anchor )
            anchor = edge;
        }
      }

      /* now we will align all stem edges. */
      /* relative order of stems in the glyph                     */
      for ( edge = edges; edge < edge_limit; edge++ )
      {
        AH_EdgeRec*  edge2;

          continue;
        }

#if 0
        if ( !anchor )
        {


          if ( edge > edges && edge->pos < edge[-1].pos )
            edge->pos = edge[-1].pos;
        }
#else /* 1 */

        if ( !dimension && !anchor )
        {
          if ( hinter->globals->is_fixedpitch && !hinter->composite )
          {
            AH_Edge     left  = edge;
            AH_Edge     right = edge_limit - 1;
            AH_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 += ah_hint_normal_stem( hinter, left, left->link,
                                           delta1, 0 );

            if ( left->link != right )
              ah_hint_normal_stem( hinter, right->link, right, delta1, 0 );

            center1 = left->pos + ( right->pos - left->pos )/2;

            if ( center1 >= target )
              delta2 = delta - 32;
            else
              delta2 = delta + 32;

            delta2 += ah_hint_normal_stem( hinter, &left1, &left2, delta2, 0 );

            if ( delta1 != delta2 )
            {
              if ( left->link != right )
                ah_hint_normal_stem( hinter, &right1, &right2, delta2, 0 );

              center2 = left1.pos + ( right2.pos - left1.pos )/2;

              d1 = center1 - target;
              d2 = center2 - target;

              if ( ABS( d2 ) < 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 |= AH_EDGE_DONE;
            right->flags       |= AH_EDGE_DONE;
          }
          else
          {
            delta = ah_hint_normal_stem( hinter, edge, edge2, 0, 0 );
          }

          anchor = edge;
        }
        else
        {
          ah_hint_normal_stem( hinter, edge, edge2,
                               delta, dimension );
          anchor = edge;
        }

        edge->flags  |= AH_EDGE_DONE;
        edge2->flags |= AH_EDGE_DONE;

#endif /* 1 */
      }

      /* make sure that lowercase m's maintain their symmetry */

      /* one pixel higher or lower.                                         */

      n_edges = edge_limit - edges;
      if ( hinter->do_blue_hints &&
           !dimension && ( n_edges == 6 || n_edges == 12 ) )
      {
        AH_EdgeRec  *edge1, *edge2, *edge3;
        FT_Pos       dist1, dist2, span, delta;

        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;

          continue;

        if ( edge->serif )
          ah_align_serif_edge( hinter, edge->serif, edge, dimension );
        else if ( !anchor )
        {
          ah_align_serif_edge( hinter, edge->serif, edge, dimension );
          edge->flags |= AH_EDGE_DONE;
          has_serifs--;
        }
      }

      if ( !has_serifs )
        goto Next_Dimension;

      for ( edge = edges; edge < edge_limit; edge++ )
      {
        AH_Edge  before, after;

        edge->flags |= AH_EDGE_DONE;

        if ( edge->flags & AH_EDGE_DONE )
          continue;

        before = after = edge;

        while ( --before >= edges )
          if ( before->flags & AH_EDGE_DONE )
            break;

        while ( ++after < edge_limit )
          if ( after->flags & AH_EDGE_DONE )
            break;

        if ( before >= edges || after < edge_limit )
        {
          if ( before < edges )
            edge->pos = edge->opos + ( after->pos - after->opos );

          else if ( after >= edge_limit )
            edge->pos = edge->opos + ( before->pos - before->opos );

          else
            edge->pos = before->pos +
                        FT_MulDiv( edge->fpos - before->fpos,
                                   after->pos - before->pos,
                                   after->fpos - before->fpos );
        }
      }

    Next_Dimension:

    AH_Edge     edges;
    AH_Edge     edge_limit;
    FT_Int      dimension;
    FT_Bool     snapping;


    edges      = outline->horz_edges;
    edge_limit = edges + outline->num_hedges;
    snapping   = hinter->do_vert_snapping;

    for ( dimension = 1; dimension >= 0; dimension-- )
    {

      {
        /* move the points of each segment     */
        /* in each edge to the edge's position */
        AH_Segment  seg   = edge->first;
        FT_Pos      delta = edge->pos - edge->opos;


        do

          AH_Point  point = seg->first;


          if ( snapping )
          {
            for (;;)
            {
              if ( dimension )
              {
                point->y      = edge->pos;
                point->flags |= AH_FLAG_TOUCH_Y;
              }
              else
              {
                point->x      = edge->pos;
                point->flags |= AH_FLAG_TOUCH_X;
              }

              if ( point == seg->last )
                break;

              point = point->next;
            }
          }
          else
          {
            for (;;)
            {
              if ( dimension )
              {
                point->y     += delta;
                point->flags |= AH_FLAG_TOUCH_Y;
              }
              else
              {
                point->x     += delta;
                point->flags |= AH_FLAG_TOUCH_X;
              }

              if ( point == seg->last )
                break;

              point = point->next;
            }
          }

          seg = seg->edge_next;


      edges      = outline->vert_edges;
      edge_limit = edges + outline->num_vedges;
      snapping   = hinter->do_horz_snapping;
    }
  }


    AH_Point    points;
    AH_Point    point_limit;
    AH_Flags    touch_flag;
    AH_Flags    strong_flag;


    points      = outline->points;

    edges       = outline->horz_edges;
    edge_limit  = edges + outline->num_hedges;
    touch_flag  = AH_FLAG_TOUCH_Y;
    strong_flag = AH_FLAG_STRONG_Y;

    for ( dimension = 1; dimension >= 0; dimension-- )
    {

#ifndef AH_OPTION_NO_WEAK_INTERPOLATION
          /* if this point is candidate to weak interpolation, we will  */
          /* interpolate it after all strong points have been processed */
          if ( !( point->flags & strong_flag ) )
               !( point->flags & AH_FLAG_INFLECTION )         )
            continue;
#endif


      edges      = outline->vert_edges;
      edge_limit = edges + outline->num_vedges;
      touch_flag = AH_FLAG_TOUCH_X;
      strong_flag = AH_FLAG_STRONG_X;
    }
  }




  FT_LOCAL_DEF( void )
  ah_hinter_align_normal_points( AH_Hinter  hinter )
  {
    ah_hinter_align_edge_points( hinter );

#ifndef AH_OPTION_NO_STRONG_INTERPOLATION
    ah_hinter_align_strong_points( hinter );
#endif

  static void
  ah_hinter_scale_globals( AH_Hinter  hinter,
                           FT_Fixed   x_scale,
                           FT_Fixed   y_scale,
                           FT_Byte    type )
  {
    FT_Int           n;
    AH_Face_Globals  globals = hinter->globals;
    AH_Globals       design  = &globals->designs[type];
    AH_Globals       scaled  = &globals->scaled;
    FT_Pos           baseline = design->baseline;


    globals->x_scale_linear = x_scale;
    globals->y_scale_linear = y_scale;
    globals->cur_type       = type;

    /* copy content */
    *scaled = *design;

#ifdef FT_CONFIG_CHESTER_BLUE_SCALE

   /* try to optimize the y_scale so that the top of non-capital letters
    * is aligned on a pixel boundary whenever possible
    */
    if ( design->has_blues )
    {
      FT_Pos  shoot = design->blue_shoots[AH_BLUE_SMALL_TOP];
      FT_Pos  ref   = design->blue_refs[AH_BLUE_SMALL_TOP];


      baseline = FT_MulFix( baseline, y_scale );

      /* the value of 'shoot' will be -1000 if the font doesn't have */
      /* small latin letters; we simply check the sign here...       */
      if ( shoot > 0 )
      {
        FT_Pos  fitted;


        shoot = FT_MulFix( shoot, y_scale );
        ref   = FT_MulFix( ref,   y_scale );

        if ( shoot < 6*64 )
          fitted = ( shoot + 44 ) & -64;
        else if ( shoot < 8*64 )
          fitted = ( shoot + 38 ) & -64;
        else
          fitted = ( shoot + 32 ) & -64;


        if ( ref <= fitted && fitted < shoot )
          fitted = shoot;
        else if ( fitted < ref )
          shoot = ref;

        if ( fitted > shoot )
        {
          y_scale   = FT_MulDiv( y_scale, fitted, shoot );
          baseline -= ( fitted - shoot )/2;
        }
      }
    }

#endif /* FT_CONFIG_CHESTER_BLUE_SCALE */

    /* scale the standard widths & heights */
    for ( n = 0; n < design->num_widths; n++ )
      scaled->widths[n] = FT_MulFix( design->widths[n], x_scale );

    scaled->stds[0] = ( design->num_widths  > 0 ) ? scaled->widths[0]  : 32000;
    scaled->stds[1] = ( design->num_heights > 0 ) ? scaled->heights[0] : 32000;

    globals->x_scale = x_scale;
    globals->y_scale = y_scale;

    if ( !design->has_blues )
      return;


    scaled->baseline = ( baseline + 32 ) & -64;

    /* scale the blue zones */
    for ( n = 0; n < AH_BLUE_MAX; n++ )
    {
      FT_Pos  delta, delta2;
      FT_Pos  ref, shoot, delta3, delta4;


      delta = design->blue_shoots[n] - design->blue_refs[n];

      if ( delta < 0 )
        delta2 = -delta2;

      if ( n == AH_BLUE_SMALL_BOTTOM )
      {
        scaled->blue_shoots[n] = delta2;
        scaled->blue_refs[n]   = 0;
        continue;
      }

      shoot  = FT_MulFix( design->blue_shoots[n], y_scale );
      ref    = FT_MulFix( design->blue_refs[n],   y_scale );
      delta3 = ( ( shoot + 32 ) & -64 ) - shoot;
      delta4 = ( ( ref   + 32 ) & -64 ) - ref;

      if ( !hinter->do_stem_adjust )
      {
        if ( delta3 >  16 ) delta3 =  16;
        if ( delta3 < -16 ) delta3 = -16;
        if ( delta4 >  16 ) delta4 =  16;
        if ( delta4 < -16 ) delta4 = -16;
      }

      shoot += delta3;
      ref   += delta4;

      if ( ABS( delta3 ) < ABS( delta4 ) )
        ref = shoot - delta2;
      else
        shoot = ref + delta2;

      scaled->blue_refs[n]   = ref;
      scaled->blue_shoots[n] = shoot;
    }
  }



  ah_hinter_align( AH_Hinter  hinter )
  {
    ah_hinter_align_edge_points( hinter );
    ah_hinter_align_normal_points( hinter );
  }



    hinter->globals = face_globals;

    if ( globals )
      face_globals->designs[0] = *globals;
    else
      ah_hinter_compute_globals( hinter );


                                 ah_hinter_done_face_globals;
    face_globals->face       = face;

    ah_hinter_compute_char_table( hinter );

    {
      TT_OS2*  os2 = FT_Get_Sfnt_Table( face, ft_sfnt_os2 );


      if ( os2 && os2->version != 0xFFFFU )
        face_globals->is_fixedpitch = FT_BOOL( os2->panose[3] == 9 );
      else
        face_globals->is_fixedpitch = FT_BOOL( FT_IS_FIXED_WIDTH( face ) != 0 );


      face_globals->has_tt_bytecode_interp = FALSE;

#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
      if ( !strcmp( face->driver->root.clazz->module_name, "truetype" ) ||
           !strcmp( face->driver->root.clazz->module_name, "type42"   ) )
        face_globals->has_tt_bytecode_interp = TRUE;
#endif
    }

  Exit:
    return error;
  }

    FT_Memory  memory = face->memory;


    FT_Done_Size( globals->size_EM );
    FT_FREE( globals->table );
    FT_FREE( globals );
  }


    FT_Error          error;
    AH_Outline        outline  = hinter->glyph;
    AH_Loader         gloader  = hinter->loader;
    FT_Pos            baseline = 0;
    FT_Byte           type     = hinter->globals->cur_type;


    /* load the glyph */
    if ( !hinter->globals->has_tt_bytecode_interp )
    {
      error = FT_Load_Glyph( face, glyph_index, load_flags );
      if ( error )
        goto Exit;
    }

    /* Set `hinter->transformed' after loading with FT_LOAD_NO_RECURSE. */
    hinter->transformed = internal->glyph_transformed;

      FT_Matrix_Invert( &imatrix );
      FT_Vector_Transform( &hinter->trans_delta, &imatrix );
    }
    else
    {
      hinter->trans_delta.x = 0;
      hinter->trans_delta.y = 0;
    }

    /* set linear horizontal metrics */
    slot->linearHoriAdvance = slot->metrics.horiAdvance;

    {
    case FT_GLYPH_FORMAT_OUTLINE:

      if ( hinter->do_blue_hints )
        baseline = hinter->globals->designs[type].baseline;

      /* translate glyph outline if we need to */
      if ( hinter->transformed || baseline != 0 )
      {
        FT_UInt     n     = slot->outline.n_points;
        FT_Vector*  point = slot->outline.points;
        FT_Pos      x_off = hinter->trans_delta.x;
        FT_Pos      y_off = hinter->trans_delta.y - baseline;


        for ( ; n > 0; point++, n-- )
        {
          point->x += x_off;
          point->y += y_off;
        }
      }


      /* perform feature detection */
      ah_outline_detect_features( outline );

      if ( hinter->do_blue_hints )
      {
        ah_outline_compute_blue_edges( outline, hinter->globals );
        ah_outline_scale_blue_edges( outline, hinter->globals );


      /* we now need to hint the metrics according to the change in */
      /* width/positioning that occured during the hinting process  */
      if ( !hinter->globals->is_fixedpitch && !hinter->composite &&
           type <= AH_CHAR_TYPE_HORIZONTAL )
      {
        FT_Pos   old_advance, old_rsb, old_lsb, new_lsb;
        AH_Edge  edge1 = outline->vert_edges;     /* leftmost edge  */

        old_lsb     = edge1->opos;
        new_lsb     = edge1->pos;

        hinter->pp1.x = ( ( new_lsb - old_lsb ) + 32 ) & -64;
        hinter->pp2.x = ( ( edge2->pos + old_rsb ) + 40 ) & -64;

#if 0
        /* try to fix certain bad advance computations */

      FT_BBox  bbox;


      if ( hinter->do_blue_hints )
      {
        if ( hinter->globals->scaled.baseline != 0 )
          FT_Outline_Translate( &gloader->base.outline,
                                0, hinter->globals->scaled.baseline );
      }

      /* transform the hinted outline if needed */
      if ( hinter->transformed )
        FT_Outline_Transform( &gloader->base.outline, &hinter->trans_matrix );

      slot->metrics.horiBearingX = bbox.xMin;
      slot->metrics.horiBearingY = bbox.yMax;

      slot->metrics.horiAdvance = hinter->pp2.x - hinter->pp1.x;
      /* to keep the original rounded advance width                */
      if ( !FT_IS_FIXED_WIDTH( slot->face ) )
        slot->metrics.horiAdvance = hinter->pp2.x - hinter->pp1.x;
      else
        slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,
                                               x_scale );

      slot->metrics.horiAdvance = ( slot->metrics.horiAdvance + 32 ) & -64;

      /* now copy outline into glyph slot */

  }


#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER

#define AH_MAX_COMPOSITE_RECURSE 5

  static FT_Error
  ah_hinter_load_truetype( AH_Hinter  hinter,
                           FT_UInt    glyph_index,
                           FT_Int32   load_flags,
                           int        depth,
                           short    **num_contours,
                           short    **num_points,
                           int       *num_simple_glyphs,
                           int       *size_array )
  {
    FT_Face        face   = hinter->face;
    FT_Memory      memory = hinter->memory;
    FT_GlyphSlot   slot   = face->glyph;
    FT_Error       error  = FT_Err_Ok;


    if ( depth == 0 )
    {
      *num_contours      = 0;
      *num_points        = 0;
      *num_simple_glyphs = 0;
      *size_array        = 0;
    }

    error = FT_Load_Glyph( face, glyph_index, load_flags );

    if ( error )
      return error;

    switch ( slot->format )
    {
    case FT_GLYPH_FORMAT_OUTLINE:
      {
        int  size_cur = *size_array;


        if ( depth == 0 )
          return ah_hinter_load( hinter, 0, load_flags, 0 );

        if ( slot->outline.n_contours == 0 )
          break;

        if ( *num_simple_glyphs >= size_cur )
        {
          if ( FT_RENEW_ARRAY( *num_contours, size_cur, size_cur + 16 ) ||
               FT_RENEW_ARRAY( *num_points,   size_cur, size_cur + 16 ) )
            goto Exit;
          *size_array += 16;
        }

        (*num_contours)[ (*num_simple_glyphs) ] = slot->outline.n_contours;
        (*num_points)[ (*num_simple_glyphs)++ ] = slot->outline.n_points;
        break;
      }

    case FT_GLYPH_FORMAT_COMPOSITE:
      if ( depth + 1 >= AH_MAX_COMPOSITE_RECURSE )
        return AH_Err_Invalid_Composite;

      if ( slot->num_subglyphs > 0 )
      {
        FT_UInt*  indices;
        int       num_subglyphs = slot->num_subglyphs;
        int       i;


        hinter->composite = TRUE;

        if ( FT_NEW_ARRAY( indices, num_subglyphs ) )
          goto Exit;

        for ( i = 0; i < num_subglyphs; i++ )
          indices[i] = slot->subglyphs[i].index;


        for ( i = 0; i < num_subglyphs; i++ )
        {
          error = ah_hinter_load_truetype( hinter,
                                           indices[i],
                                           load_flags,
                                           depth + 1,
                                           num_contours,
                                           num_points,
                                           num_simple_glyphs,
                                           size_array );
          if ( error )
          {
            FT_FREE( indices );
            goto Exit;
          }
        }

        FT_FREE( indices );

        if ( depth == 0 )
        {
          FT_Size      size_EM, size;
          FT_Vector*   points;
          FT_Vector*   limit;
          int          num = *num_simple_glyphs, j;
          short        n_contours, n_points;
          short        *array_c, *array_p;


          if ( num == 0 )
            break;

          size    = face->size;
          size_EM = hinter->globals->size_EM;

          if ( !size_EM )
          {
            error = FT_New_Size( face, &hinter->globals->size_EM );
            if ( error )
              goto Exit;

            size_EM = hinter->globals->size_EM;
            FT_Activate_Size( size_EM );

            error = FT_Set_Pixel_Sizes( face,
                                        face->units_per_EM,
                                        face->units_per_EM );
            if ( error )
            {
              FT_Activate_Size( size );
              goto  Exit;
            }
          }
          else
            FT_Activate_Size( size_EM );


          load_flags &= ~FT_LOAD_NO_RECURSE &
                        ~FT_LOAD_NO_SCALE;
          load_flags |= FT_LOAD_NO_BITMAP   |
                        FT_LOAD_NO_AUTOHINT |
                        FT_LOAD_IGNORE_TRANSFORM;

          error = FT_Load_Glyph( face, glyph_index, load_flags );

          FT_Activate_Size( size );

          if ( error )
            goto Exit;


          array_c    = *num_contours;
          array_p    = *num_points;
          n_contours = 0;
          n_points   = 0;

          for ( i = 0; i < num; i++ )
          {
            n_contours += *array_c++;
            n_points   += *array_p++;
          }

          if ( slot->outline.n_points   != n_points ||
               slot->outline.n_contours != n_contours )
          {
            error = AH_Err_Invalid_Composite;
            goto Exit;
          }


          points = slot->outline.points;
          limit  = points + slot->outline.n_points;

          while ( points < limit )
          {
            points->x >>= 6;
            points->y >>= 6;
            points++;
          }

          slot->metrics.horiAdvance >>= 6;
          slot->metrics.vertAdvance >>= 6;

          array_c = *num_contours;
          array_p = *num_points;

          for ( i = 0; i < num - 1; i++ )
          {
            slot->outline.n_contours = *array_c++;
            slot->outline.n_points   = *array_p++;

            error = ah_hinter_load( hinter, 0, load_flags, 1 );
            if ( error )
              goto Exit;

            n_points = slot->outline.n_points;
            slot->outline.points   += n_points;
            slot->outline.tags     += n_points;
            slot->outline.contours += slot->outline.n_contours;
            n_contours             -= slot->outline.n_contours;

            for ( j = 0; j < n_contours; j++ )
              slot->outline.contours[j] -= n_points;
          }

          slot->outline.n_contours = *array_c;
          slot->outline.n_points   = *array_p;

          error = ah_hinter_load( hinter, 0, load_flags, 0 );
        }
      }
      break;

     default:
      error = AH_Err_Unimplemented_Feature;
    }


  Exit:
    if ( depth == 0 )
    {
      FT_FREE( *num_contours );
      FT_FREE( *num_points   );
    }

    return  error;
  }

#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */


  /* load and hint a given glyph */
  FT_LOCAL_DEF( FT_Error )
  ah_hinter_load_glyph( AH_Hinter     hinter,

    FT_Fixed         y_scale      = size->metrics.y_scale;
    AH_Face_Globals  face_globals = FACE_GLOBALS( face );
    FT_Render_Mode   hint_mode    = FT_LOAD_TARGET_MODE( load_flags );
    FT_Byte          type;


    /* first of all, we need to check that we're using the correct face and */


    }

#ifdef FT_CONFIG_CHESTER_BLUE_SCALE

   /* try to optimize the y_scale so that the top of non-capital letters
    * is aligned on a pixel boundary whenever possible
    */
    {
      AH_Globals  design = &face_globals->design;
      FT_Pos      shoot  = design->blue_shoots[AH_BLUE_SMALL_TOP];


      /* the value of 'shoot' will be -1000 if the font doesn't have */
      /* small latin letters; we simply check the sign here...       */
      if ( shoot > 0 )
      {
        FT_Pos  scaled = FT_MulFix( shoot, y_scale );
        FT_Pos  fitted = ( scaled + 32 ) & -64;


        if ( scaled != fitted )
        {
         /* adjust y_scale
          */
          y_scale = FT_MulDiv( y_scale, fitted, scaled );

         /* adust x_scale
          */
          if ( fitted < scaled )
            x_scale -= x_scale / 50;  /* x_scale*0.98 with integers */
        }
      }
    }

#endif /* FT_CONFIG_CHESTER_BLUE_SCALE */

    /* now, we must check the current character pixel size to see if we */
    /* need to rescale the global metrics                               */
    if ( face_globals->x_scale != x_scale ||
         face_globals->y_scale != y_scale )
      ah_hinter_scale_globals( hinter, x_scale, y_scale );

    ah_loader_rewind( hinter->loader );

    /* reset hinting flags according to load flags and current render target */


    hinter->do_stem_adjust   = FT_BOOL( hint_mode != FT_RENDER_MODE_LIGHT );

    type = ah_hinter_get_char_type( hinter, glyph_index );

    hinter->do_blue_hints = face_globals->designs[type].has_blues;
    hinter->composite     = FALSE;

    /* now, we must check the current character pixel size to see if we */
    /* need to rescale the global metrics                               */
    if ( face_globals->x_scale_linear != x_scale ||
         face_globals->y_scale_linear != y_scale ||
         face_globals->cur_type       != type    )
      ah_hinter_scale_globals( hinter, x_scale, y_scale, type );


    load_flags  |= FT_LOAD_NO_SCALE
                 | FT_LOAD_IGNORE_TRANSFORM ;

#ifndef TT_CONFIG_OPTION_BYTECODE_INTERPRETER

     error = ah_hinter_load( hinter, glyph_index, load_flags, 0 );

#else

    if ( face_globals->has_tt_bytecode_interp )
    {
      short*  num_contours;
      short*  num_points;
      int     num_simple_glyphs;
      int     size_array;


      load_flags |= FT_LOAD_NO_RECURSE;

      error = ah_hinter_load_truetype( hinter,
                                       glyph_index,
                                       load_flags,
                                       0,
                                       &num_contours,
                                       &num_points,
                                       &num_simple_glyphs,
                                       &size_array );
    }
    else
      error = ah_hinter_load( hinter, glyph_index, load_flags, 0 );

#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */

  Exit:
    return error;

        goto Fail;
    }

    *globals      = FACE_GLOBALS( face )->designs[0];
    *global_hints = globals;
    *global_len   = sizeof( *globals );


Lines 138-143 Link Here

(-)freetype-2.1.5-orig/src/autohint/ahtypes.h (-2 / +53 lines)
138	/* weak interpolation */	138	/* weak interpolation */
139	#define AH_FLAG_WEAK_INTERPOLATION 256	139	#define AH_FLAG_WEAK_INTERPOLATION 256
140	#define AH_FLAG_INFLECTION 512	140	#define AH_FLAG_INFLECTION 512
		141	#define AH_FLAG_STRONG_X 1024
		142	#define AH_FLAG_STRONG_Y 2048
141		143
142	typedef FT_Int AH_Flags;	144	typedef FT_Int AH_Flags;
143		145
Lines 264-270 Link Here
264	AH_Segment link; /* link segment */	266	AH_Segment link; /* link segment */
265	AH_Segment serif; /* primary segment for serifs */	267	AH_Segment serif; /* primary segment for serifs */
266	FT_Pos num_linked; /* number of linked segments */	268	FT_Pos num_linked; /* number of linked segments */
267	FT_Pos score;	269	FT_Pos score1;
		270	FT_Pos score2;
		271	FT_Pos length;
		272	FT_Int sign;
268		273
269	AH_Point first; /* first point in edge segment */	274	AH_Point first; /* first point in edge segment */
270	AH_Point last; /* last point in edge segment */	275	AH_Point last; /* last point in edge segment */
Lines 402-407 Link Here
402	typedef FT_Int AH_Hinter_Flags;	407	typedef FT_Int AH_Hinter_Flags;
403		408
404		409
		410	#define AH_LIGHT_MODE_MAX_HORZ_GAP 9
		411	#define AH_LIGHT_MODE_MAX_VERT_GAP 15
		412	#define AH_LIGHT_MODE_MAX_DELTA_ABS 14
		413
		414	enum
		415	{
		416	AH_CHAR_TYPE_LATINATE = 0,
		417	AH_CHAR_TYPE_LATIN_FULLWIDTH,
		418	AH_CHAR_TYPE_HORIZONTAL,
		419	AH_CHAR_TYPE_OTHER,
		420	AH_CHAR_TYPE_COUNT
		421	};
		422
		423
		424	typedef struct AH_CharType_
		425	{
		426	FT_Byte type;
		427	FT_ULong start;
		428	FT_ULong last;
		429
		430	} AH_CharType;
		431
		432
		433	typedef struct AH_CharTypeTable_
		434	{
		435	FT_ULong size;
		436	AH_CharType* types;
		437
		438	} AH_CharTypeTable;
		439
		440
405	/*************************************************************************/	441	/*************************************************************************/
406	/* */	442	/* */
407	/* <Struct> */	443	/* <Struct> */
Lines 440-445 Link Here
440	FT_Pos blue_refs [AH_BLUE_MAX];	476	FT_Pos blue_refs [AH_BLUE_MAX];
441	FT_Pos blue_shoots[AH_BLUE_MAX];	477	FT_Pos blue_shoots[AH_BLUE_MAX];
442		478
		479	FT_Pos baseline;
		480
		481	FT_Bool has_blues;
		482
443	} AH_GlobalsRec, *AH_Globals;	483	} AH_GlobalsRec, *AH_Globals;
444		484
445		485
Lines 470-481 Link Here
470	typedef struct AH_Face_GlobalsRec_	510	typedef struct AH_Face_GlobalsRec_
471	{	511	{
472	FT_Face face;	512	FT_Face face;
473	AH_GlobalsRec design;	513	AH_GlobalsRec designs[AH_CHAR_TYPE_COUNT];
474	AH_GlobalsRec scaled;	514	AH_GlobalsRec scaled;
475	FT_Fixed x_scale;	515	FT_Fixed x_scale;
476	FT_Fixed y_scale;	516	FT_Fixed y_scale;
477	FT_Bool control_overshoot;	517	FT_Bool control_overshoot;
478		518
		519	FT_Fixed x_scale_linear;
		520	FT_Fixed y_scale_linear;
		521
		522	AH_CharTypeTable* table;
		523	FT_Byte cur_type;
		524	FT_Size size_EM;
		525	FT_Bool is_fixedpitch;
		526	FT_Bool has_tt_bytecode_interp;
		527
479	} AH_Face_GlobalsRec, *AH_Face_Globals;	528	} AH_Face_GlobalsRec, *AH_Face_Globals;
480		529
481		530
Lines 494-499 Link Here
494	AH_Loader loader;	543	AH_Loader loader;
495	FT_Vector pp1;	544	FT_Vector pp1;
496	FT_Vector pp2;	545	FT_Vector pp2;
		546	FT_Bool composite;
497		547
498	FT_Bool transformed;	548	FT_Bool transformed;
499	FT_Vector trans_delta;	549	FT_Vector trans_delta;
Lines 504-509 Link Here
504	FT_Bool do_horz_snapping; /* disable X stem size snapping */	554	FT_Bool do_horz_snapping; /* disable X stem size snapping */
505	FT_Bool do_vert_snapping; /* disable Y stem size snapping */	555	FT_Bool do_vert_snapping; /* disable Y stem size snapping */
506	FT_Bool do_stem_adjust; /* disable light stem snapping */	556	FT_Bool do_stem_adjust; /* disable light stem snapping */
		557	FT_Bool do_blue_hints; /* disable blue hinting */
507		558
508	} AH_HinterRec, *AH_Hinter;	559	} AH_HinterRec, *AH_Hinter;
509		560

Lines 22-28 Link Here

(-)freetype-2.1.5-orig/src/autohint/autohint.c (-1 lines)
22	#define FT_MAKE_OPTION_SINGLE_OBJECT	22	#define FT_MAKE_OPTION_SINGLE_OBJECT
23		23
24	#include <ft2build.h>	24	#include <ft2build.h>
25	#include "ahangles.c"
26	#include "ahglyph.c"	25	#include "ahglyph.c"
27	#include "ahglobal.c"	26	#include "ahglobal.c"
28	#include "ahhint.c"	27	#include "ahhint.c"

Return to bug 31347

Lines 30-36 Link Here

(-)freetype-2.1.5-orig/src/autohint/ahglobal.c (-15 / +304 lines)
30	/* cf. AH_BLUE_XXX constants in ahtypes.h */	30	/* cf. AH_BLUE_XXX constants in ahtypes.h */
31		31
32	static	32	static
33	const char* blue_chars[AH_BLUE_MAX] =	33	const char* blue_chars_latin[AH_BLUE_MAX] =
34	{	34	{
35	"THEZOCQS",	35	"THEZOCQS",
36	"HEZLOCUS",	36	"HEZLOCUS",
Lines 43-48 Link Here
43	};	43	};
44		44
45		45
		46	typedef struct AH_BlueTable_
		47	{
		48	FT_ULong offset_blue_chars;
		49	const char** blue_chars;
		50	FT_ULong char_for_widths;
		51
		52	} AH_BlueTable;
		53
		54
		55	static const AH_BlueTable blue_table[AH_CHAR_TYPE_COUNT] =
		56	{
		57	{ 0, blue_chars_latin, (FT_ULong)'o' },
		58	{ 0xFEE0L, blue_chars_latin, 0xFF4FL },
		59	{ 0, 0, 0 },
		60	{ 0, 0, 0 }
		61	};
		62
		63
		64	#ifdef AH_DEBUG
		65	static const char* blue_names[AH_CHAR_TYPE_COUNT] =
		66	{
		67	"general latinate chars",
		68	"CJK fullwidth latin chars",
		69	0,
		70	0
		71	};
		72	#endif
		73
		74
46	/* simple insertion sort */	75	/* simple insertion sort */
47	static void	76	static void
48	sort_values( FT_Int count,	77	sort_values( FT_Int count,
Lines 71-77 Link Here
71	ah_hinter_compute_blues( AH_Hinter hinter )	100	ah_hinter_compute_blues( AH_Hinter hinter )
72	{	101	{
73	AH_Blue blue;	102	AH_Blue blue;
74	AH_Globals globals = &hinter->globals->design;	103	AH_Globals globals = hinter->globals->designs;
75	FT_Pos flats [MAX_TEST_CHARACTERS];	104	FT_Pos flats [MAX_TEST_CHARACTERS];
76	FT_Pos rounds[MAX_TEST_CHARACTERS];	105	FT_Pos rounds[MAX_TEST_CHARACTERS];
77	FT_Int num_flats;	106	FT_Int num_flats;
Lines 81-86 Link Here
81	FT_GlyphSlot glyph;	110	FT_GlyphSlot glyph;
82	FT_Error error;	111	FT_Error error;
83	FT_CharMap charmap;	112	FT_CharMap charmap;
		113	FT_ULong offset;
		114	FT_Byte type;
		115	const char** blue_chars;
84		116
85		117
86	face = hinter->face;	118	face = hinter->face;
Lines 97-104 Link Here
97	/* we compute the blues simply by loading each character from the */	129	/* we compute the blues simply by loading each character from the */
98	/* 'blue_chars[blues]' string, then compute its top-most or */	130	/* 'blue_chars[blues]' string, then compute its top-most or */
99	/* bottom-most points (depending on `AH_IS_TOP_BLUE') */	131	/* bottom-most points (depending on `AH_IS_TOP_BLUE') */
		132	type = AH_CHAR_TYPE_LATINATE;
100		133
101	AH_LOG(( "blue zones computation\n" ));	134	Compute_Blues:
		135	globals->has_blues = FALSE;
		136	globals->baseline = 0;
		137
		138	offset = blue_table[type].offset_blue_chars;
		139	blue_chars = blue_table[type].blue_chars;
		140
		141	if ( !blue_chars )
		142	goto Next_Type;
		143
		144	AH_LOG(( "blue zones computation for %s\n", blue_names[type] ));
102	AH_LOG(( "------------------------------------------------\n" ));	145	AH_LOG(( "------------------------------------------------\n" ));
103		146
104	for ( blue = AH_BLUE_CAPITAL_TOP; blue < AH_BLUE_MAX; blue++ )	147	for ( blue = AH_BLUE_CAPITAL_TOP; blue < AH_BLUE_MAX; blue++ )
Lines 131-137 Link Here
131	AH_LOG(( "`%c'", *p ));	174	AH_LOG(( "`%c'", *p ));
132		175
133	/* load the character in the face -- skip unknown or empty ones */	176	/* load the character in the face -- skip unknown or empty ones */
134	glyph_index = FT_Get_Char_Index( face, (FT_UInt)*p );	177	glyph_index = FT_Get_Char_Index( face, offset + (FT_ULong)*p );
135	if ( glyph_index == 0 )	178	if ( glyph_index == 0 )
136	continue;	179	continue;
137		180
Lines 221-230 Link Here
221		264
222	} while ( next != idx );	265	} while ( next != idx );
223		266
224	/* now, set the `round' flag depending on the segment's kind */	267	/* now, set the `round' flag depending on whether there exists */
225	round = FT_BOOL(	268	/* a extremum line segment within the current zone. */
226	FT_CURVE_TAG( glyph->outline.tags[prev] ) != FT_CURVE_TAG_ON \|\|	269	round = TRUE;
227	FT_CURVE_TAG( glyph->outline.tags[next] ) != FT_CURVE_TAG_ON );	270
		271	{
		272	FT_Int n = 0, p = prev;
		273	FT_Bool is_top = AH_IS_TOP_BLUE( blue );
		274
		275
		276	while ( ( p = ( p >= last )? first : p + 1 ) != next )
		277	{
		278	if ( FT_CURVE_TAG( glyph->outline.tags[p] ) == FT_CURVE_TAG_ON )
		279	{
		280	if ( ( is_top && points[p].y < extremum->y ) \|\|
		281	( !is_top && points[p].y > extremum->y ) )
		282	break;
		283
		284	n++;
		285	}
		286	}
		287
		288	if ( n >= 2 && p == next )
		289	round = FALSE;
		290	}
228		291
229	AH_LOG(( "%c ", round ? 'r' : 'f' ));	292	AH_LOG(( "%c ", round ? 'r' : 'f' ));
230	}	293	}
Lines 281-286 Link Here
281	}	344	}
282		345
283	AH_LOG(( "-- ref = %ld, shoot = %ld\n", blue_ref, blue_shoot ));	346	AH_LOG(( "-- ref = %ld, shoot = %ld\n", blue_ref, blue_shoot ));
		347
		348	if ( num_flats > 0 \|\| num_rounds > 0 )
		349	globals->has_blues = TRUE;
		350	}
		351
		352	globals->baseline = globals->blue_refs[AH_BLUE_SMALL_BOTTOM];
		353
		354	if ( globals->baseline > -10000 )
		355	{
		356	for ( blue = AH_BLUE_CAPITAL_TOP; blue < AH_BLUE_MAX; blue++ )
		357	{
		358	if ( globals->blue_refs[blue] > -10000 )
		359	{
		360	globals->blue_refs[blue] -= globals->baseline;
		361	globals->blue_shoots[blue] -= globals->baseline;
		362	}
		363	}
		364	}
		365
		366	Next_Type:
		367	if ( ++type < AH_CHAR_TYPE_COUNT )
		368	{
		369	globals++;
		370	goto Compute_Blues;
284	}	371	}
285		372
286	/* reset original face charmap */	373	/* reset original face charmap */
Lines 299-311 Link Here
299	AH_Outline outline = hinter->glyph;	386	AH_Outline outline = hinter->glyph;
300	AH_Segment segments;	387	AH_Segment segments;
301	AH_Segment limit;	388	AH_Segment limit;
302	AH_Globals globals = &hinter->globals->design;	389	AH_Globals globals = hinter->globals->designs;
303	FT_Pos* widths;	390	FT_Pos* widths;
304	FT_Int dimension;	391	FT_Int dimension;
305	FT_Int* p_num_widths;	392	FT_Int* p_num_widths;
306	FT_Error error = 0;	393	FT_Error error = 0;
307	FT_Pos edge_distance_threshold = 32000;	394	FT_Pos edge_distance_threshold = 32000;
		395	FT_Byte type;
		396	FT_ULong char_for_widths;
		397
		398
		399	type = AH_CHAR_TYPE_LATINATE;
308		400
		401	Compute_Widths:
		402	char_for_widths = blue_table[type].char_for_widths;
		403
		404	if ( !char_for_widths )
		405	goto Next_Type;
309		406
310	globals->num_widths = 0;	407	globals->num_widths = 0;
311	globals->num_heights = 0;	408	globals->num_heights = 0;
Lines 318-335 Link Here
318	FT_UInt glyph_index;	415	FT_UInt glyph_index;
319		416
320		417
321	glyph_index = FT_Get_Char_Index( hinter->face, 'o' );	418	glyph_index = FT_Get_Char_Index( hinter->face, char_for_widths );
322	if ( glyph_index == 0 )	419	if ( glyph_index == 0 )
323	return 0;	420	goto Next_Type;
324		421
325	error = FT_Load_Glyph( hinter->face, glyph_index, FT_LOAD_NO_SCALE );	422	error = FT_Load_Glyph( hinter->face, glyph_index, FT_LOAD_NO_SCALE );
326	if ( error )	423	if ( error )
327	goto Exit;	424	goto Next_Type;
328		425
329	error = ah_outline_load( hinter->glyph, 0x10000L, 0x10000L,	426	error = ah_outline_load( hinter->glyph, 0x10000L, 0x10000L,
330	hinter->face );	427	hinter->face );
331	if ( error )	428	if ( error )
332	goto Exit;	429	goto Next_Type;
333		430
334	ah_outline_compute_segments( hinter->glyph );	431	ah_outline_compute_segments( hinter->glyph );
335	ah_outline_link_segments( hinter->glyph );	432	ah_outline_link_segments( hinter->glyph );
Lines 378-383 Link Here
378	p_num_widths = &globals->num_widths;	475	p_num_widths = &globals->num_widths;
379	}	476	}
380		477
		478	Next_Type:
		479	if ( type++ < AH_CHAR_TYPE_COUNT )
		480	{
		481	globals++;
		482	goto Compute_Widths;
		483	}
		484
381	/* Now, compute the edge distance threshold as a fraction of the */	485	/* Now, compute the edge distance threshold as a fraction of the */
382	/* smallest width in the font. Set it in `hinter->glyph' too! */	486	/* smallest width in the font. Set it in `hinter->glyph' too! */
383	if ( edge_distance_threshold == 32000 )	487	if ( edge_distance_threshold == 32000 )
Lines 386-393 Link Here
386	/* let's try 20% */	490	/* let's try 20% */
387	hinter->glyph->edge_distance_threshold = edge_distance_threshold / 5;	491	hinter->glyph->edge_distance_threshold = edge_distance_threshold / 5;
388		492
389	Exit:	493	return 0;
390	return error;
391	}	494	}
392		495
393		496
Lines 396-401 Link Here
396	{	499	{
397	return ah_hinter_compute_widths( hinter ) \|\|	500	return ah_hinter_compute_widths( hinter ) \|\|
398	ah_hinter_compute_blues ( hinter );	501	ah_hinter_compute_blues ( hinter );
		502	}
		503
		504
		505	static const AH_CharType
		506	ah_types_for_unicode[] =
		507	{
		508	/* Latin, Greek, Cyrillic */
		509	{ AH_CHAR_TYPE_LATINATE, 0x21L, 0x52FL },
		510
		511	/* Hebrew */
		512	{ AH_CHAR_TYPE_LATINATE, 0x5D0L, 0x600L },
		513
		514	/* Latin, Greek */
		515	{ AH_CHAR_TYPE_LATINATE, 0x1E00L, 0x2000L },
		516
		517	/* CJK fullwidth Latin */
		518	{ AH_CHAR_TYPE_LATIN_FULLWIDTH, 0xFF00L, 0xFF60L }
		519	};
		520
		521
		522	static const AH_CharTypeTable
		523	ah_types_table_unicode =
		524	{
		525	sizeof( ah_types_for_unicode ) / sizeof( AH_CharType ),
		526	(AH_CharType *)ah_types_for_unicode
		527	};
		528
		529
		530	FT_LOCAL_DEF( void )
		531	ah_hinter_compute_char_table( AH_Hinter hinter )
		532	{
		533	FT_Memory memory = hinter->memory;
		534	FT_Face face = hinter->face;
		535	AH_CharTypeTable* table = hinter->globals->table;
		536	FT_ULong num_glyphs = face->num_glyphs;
		537	FT_Byte* types;
		538	FT_Error error;
		539	FT_CharMap charmap;
		540
		541
		542	if ( table )
		543	return;
		544
		545	if ( num_glyphs <= 0 )
		546	return;
		547
		548	if ( FT_NEW_ARRAY( types, num_glyphs ) )
		549	return;
		550
		551	FT_MEM_SET( types, AH_CHAR_TYPE_OTHER, num_glyphs );
		552
		553	charmap = face->charmap;
		554	if ( FT_Select_Charmap( face, FT_ENCODING_UNICODE ) )
		555	goto Exit;
		556
		557
		558	{
		559	FT_Bool empty = TRUE;
		560	FT_ULong i;
		561
		562
		563	for ( i = 0; i < ah_types_table_unicode.size; i++ )
		564	{
		565	FT_UInt glyph_index;
566	FT_ULong start = ah_types_table_unicode.types[i].start;
567	FT_ULong last = ah_types_table_unicode.types[i].last;
568	FT_Byte type = ah_types_table_unicode.types[i].type;
569	FT_ULong ucs = FT_Get_Next_Char( face, start - 1, &glyph_index );
570
571
572	while ( ucs && ucs <= last )
573	{
574	if ( glyph_index < num_glyphs )
575	{
576	empty = FALSE;
577	types[glyph_index] = type;
578	}
579
580	ucs = FT_Get_Next_Char( face, ucs, &glyph_index );
581	}
582	}
583
584	if ( empty )
585	goto Exit;
586	}
587
588
589	{
590	FT_Byte* cur = types;
591	FT_Byte* last = types + num_glyphs - 1;
592	FT_Byte type = AH_CHAR_TYPE_OTHER;
593	FT_ULong num = 0;
594	FT_ULong alloc_size;
595
596
597	while ( ++cur <= last )
598	{
599	if ( *cur != type )
600	{
601	type = *cur;
602
603	if ( type < AH_CHAR_TYPE_OTHER )
604	num++;
605	}
606	}
607
608	alloc_size = sizeof( AH_CharTypeTable ) + num * sizeof( AH_CharType );
609	if ( FT_ALLOC( table, alloc_size ) )
610	goto Exit;
611
612	table->size = num;
613	table->types = (AH_CharType *)( table + 1 );
614	}
615
616
617	{
618	FT_Byte* cur = types + 1;
619	FT_Byte* last = types + face->num_glyphs - 1;
620	FT_Byte type = AH_CHAR_TYPE_OTHER;
621	FT_ULong num = 0;
622	FT_ULong i;
623
624
625	for ( i = 1; cur <= last; i++, cur++ )
626	{
627	if ( *cur != type )
628	{
629	if ( type < AH_CHAR_TYPE_OTHER )
630	table->types[num - 1].last = i - 1;
631
632	type = *cur;
633	if ( type < AH_CHAR_TYPE_OTHER )
634	{
635	table->types[num].type = type;
636	table->types[num++].start = i;
637	}
638	}
639	}
640
641	if ( type < AH_CHAR_TYPE_OTHER )
642	table->types[num - 1].last = i - 1;
643	}
644
645	hinter->globals->table = table;
646
647	Exit:
648	FT_Set_Charmap( face, charmap );
649	FT_FREE( types );
650	}
651
652
653	FT_LOCAL_DEF( FT_Byte )
654	ah_hinter_get_char_type( AH_Hinter hinter,
655	FT_ULong glyph_index )
656	{
657	AH_CharTypeTable* table = hinter->globals->table;
658
659
660	if ( table && table->size > 0 && glyph_index )
661	{
662	AH_CharType* cur;
663	AH_CharType* types = table->types;
664	FT_ULong min = 0;
665	FT_ULong max = table->size - 1;
666	FT_ULong mid;
667
668
669	if ( glyph_index < types[min].start \|\|
670	glyph_index > types[max].last )
671	return AH_CHAR_TYPE_OTHER;
672
673	while ( min <= max )
674	{
675	mid = ( min + max ) / 2;
676	cur = types + mid;
677
678	if ( glyph_index < cur->start )
679	max = mid - 1;
680	else if ( glyph_index > cur->last )
681	min = mid + 1;
682	else
683	return cur->type;
684	}
685	}
686
687	return AH_CHAR_TYPE_OTHER;
399	}	688	}
400		689
401		690