ref: 2fd491d5f3ec42287a49d1aa5c0166b46f417fde
dir: /src/type1/t1hinter.c/
/***************************************************************************/ /* */ /* t1hinter.c */ /* */ /* Type 1 hinter (body). */ /* */ /* Copyright 1996-2000 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 Hinter is in charge of fitting th scaled outline to the pixel */ /* grid in order to considerably improve the quality of the Type 1 font */ /* driver's output. */ /* */ /*************************************************************************/ #include <freetype/internal/ftdebug.h> #ifdef FT_FLAT_COMPILE #include "t1objs.h" #include "t1hinter.h" #else #include <type1/t1objs.h> #include <type1/t1hinter.h> #endif /*************************************************************************/ /* */ /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ /* messages during execution. */ /* */ #undef FT_COMPONENT #define FT_COMPONENT trace_t1hint #undef ONE_PIXEL #define ONE_PIXEL 64 #undef ROUND #define ROUND( x ) ( ( x + ONE_PIXEL / 2 ) & -ONE_PIXEL ) #undef SCALE #define SCALE( val ) FT_MulFix( val, scale ) /* various constants used to describe the alignment of a horizontal */ /* stem with regards to the blue zones */ #define T1_ALIGN_NONE 0 #define T1_ALIGN_BOTTOM 1 #define T1_ALIGN_TOP 2 #define T1_ALIGN_BOTH 3 /* very simple bubble sort (not a lot of elements, mostly */ /* pre-sorted, no need for quicksort) */ static void t1_sort_blues( FT_Int* blues, FT_Int count ) { FT_Int i, swap; FT_Int* cur; for ( i = 2; i < count; i += 2 ) { cur = blues + i; do { if ( cur[-1] < cur[0] ) break; swap = cur[-2]; cur[-2] = cur[0]; cur[0] = swap; swap = cur[-1]; cur[-1] = cur[1]; cur[1] = swap; cur -= 2; } while ( cur > blues ); } } /*************************************************************************/ /* */ /* <Function> */ /* t1_set_blue_zones */ /* */ /* <Description> */ /* Sets a size object's blue zones during reset. This will compute */ /* the `snap' zone corresponding to each blue zone. */ /* */ /* <InOut> */ /* size :: A handle to target size object. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ /* <Note> */ /* This functions does the following: */ /* */ /* 1. It extracts the bottom and top blue zones from the face object. */ /* */ /* 2. Each zone is then grown by `BlueFuzz', overlapping is */ /* eliminated by adjusting the zone edges appropriately. */ /* */ /* 3. For each zone, we keep its original font units position, its */ /* original scaled position, as well as its grown/adjusted edges. */ /* */ static FT_Error t1_set_blue_zones( T1_Size size ) { T1_Face face = (T1_Face)size->root.face; T1_Private* priv = &face->type1.private_dict; FT_Int n; FT_Int blues[24]; FT_Int num_bottom; FT_Int num_top; FT_Int num_blues; T1_Size_Hints* hints = size->hints; T1_Snap_Zone* zone; FT_Pos pix, orus; FT_Pos min, max, threshold; FT_Fixed scale; FT_Bool is_bottom; /***********************************************************************/ /* */ /* copy bottom and top blue zones in local arrays */ /* */ /* First of all, check the sizes of the /BlueValues and /OtherBlues */ /* tables. They all must contain an even number of arguments. */ if ( priv->num_other_blues & 1 || priv->num_blue_values & 1 ) { FT_ERROR(( "t1_set_blue_zones: odd number of blue values\n" )); return T1_Err_Syntax_Error; } /* copy the bottom blue zones from /OtherBlues */ num_top = 0; num_bottom = priv->num_other_blues; for ( n = 0; n < num_bottom; n++ ) blues[n] = priv->other_blues[n]; /* add the first blue zone in /BlueValues to the table */ num_top = priv->num_blue_values - 2; if ( num_top >= 0 ) { blues[num_bottom ] = priv->blue_values[0]; blues[num_bottom + 1] = priv->blue_values[1]; num_bottom += 2; } /* sort the bottom blue zones */ t1_sort_blues( blues, num_bottom ); hints->num_bottom_zones = num_bottom >> 1; /* now copy the /BlueValues to the top of the blues array */ if ( num_top > 0 ) { for ( n = 0; n < num_top; n++ ) blues[num_bottom + n] = priv->blue_values[n + 2]; /* sort the top blue zones */ t1_sort_blues( blues + num_bottom, num_top ); } else num_top = 0; num_blues = num_top + num_bottom; hints->num_blue_zones = ( num_blues ) >> 1; /***********************************************************************/ /* */ /* build blue snap zones from the local blues arrays */ /* */ scale = size->root.metrics.y_scale; zone = hints->blue_zones; threshold = ONE_PIXEL / 4; /* 0.25 pixels */ for ( n = 0; n < num_blues; n += 2, zone++ ) { is_bottom = n < num_bottom ? 1 : 0; orus = blues[n + is_bottom]; /* get alignement coordinate */ pix = SCALE( orus ); /* scale it */ min = SCALE( blues[n ] - priv->blue_fuzz ); max = SCALE( blues[n + 1] + priv->blue_fuzz ); if ( min > pix - threshold ) min = pix - threshold; if ( max < pix + threshold ) max = pix + threshold; zone->orus = orus; zone->pix = pix; zone->min = min; zone->max = max; } /* adjust edges in case of overlap */ zone = hints->blue_zones; for ( n = 0; n < num_blues - 2; n += 2, zone++ ) { if ( n != num_bottom - 2 && zone[0].max > zone[1].min ) zone[0].max = zone[1].min = ( zone[0].pix + zone[1].pix ) / 2; } /* compare the current pixel size with the BlueScale value */ /* to know whether to supress overshoots */ hints->supress_overshoots = size->root.metrics.y_ppem < FT_MulFix( 1000, priv->blue_scale ); #ifdef FT_DEBUG_LEVEL_TRACE /* now print the new blue values in tracing mode */ FT_TRACE2(( "Blue Zones for size object at $%08lx:\n", (long)size )); FT_TRACE2(( " orus pix min max\n" )); FT_TRACE2(( "-------------------------------\n" )); zone = hints->blue_zones; for ( n = 0; n < hints->num_blue_zones; n++ ) { FT_TRACE2(( " %3d %.2f %.2f %.2f\n", zone->orus, zone->pix / 64.0, zone->min / 64.0, zone->max / 64.0 )); zone++; } FT_TRACE2(( "\nOvershoots are %s\n\n", hints->supress_overshoots ? "supressed" : "active" )); #endif /* DEBUG_LEVEL_TRACE */ return T1_Err_Ok; } /*************************************************************************/ /* */ /* <Function> */ /* t1_set_snap_zones */ /* */ /* <Description> */ /* This function set a size object's stem snap zones. */ /* */ /* <InOut> */ /* size :: A handle to the target size object. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ /* <Note> */ /* This function performs the following: */ /* */ /* 1. It reads and scales the stem snap widths from the parent face. */ /* */ /* 2. A `snap zone' is computed for each snap width, by `growing' it */ /* with a threshold of 1/2 pixel. Overlapping is avoided through */ /* proper edge adjustment. */ /* */ /* 3. Each width whose zone contain the scaled standard set width is */ /* removed from the table. */ /* */ /* 4. Finally, the standard set width is scaled, and its correponding */ /* `snap zone' is inserted into the sorted snap zones table. */ /* */ static FT_Error t1_set_snap_zones( T1_Size size ) { FT_Int n, direction, n_zones, num_zones; T1_Snap_Zone* zone; T1_Snap_Zone* base_zone; FT_Short* orgs; FT_Pos standard_width; FT_Fixed scale; T1_Face face = (T1_Face)size->root.face; T1_Private* priv = &face->type1.private_dict; T1_Size_Hints* hints = size->hints; /* start with horizontal snap zones */ direction = 0; standard_width = priv->standard_width[0]; n_zones = priv->num_snap_widths; base_zone = hints->snap_widths; orgs = priv->snap_widths; scale = size->root.metrics.x_scale; while ( direction < 2 ) { /*********************************************************************/ /* */ /* Read and scale stem snap widths table from the physical font */ /* record. */ /* */ FT_Pos prev, orus, pix, min, max, threshold; threshold = ONE_PIXEL / 4; zone = base_zone; if ( n_zones > 0 ) { orus = *orgs++; pix = SCALE( orus ); min = pix - threshold; max = pix + threshold; zone->orus = orus; zone->pix = pix; zone->min = min; prev = pix; for ( n = 1; n < n_zones; n++ ) { orus = *orgs++; pix = SCALE( orus ); if ( pix - prev < 2 * threshold ) { min = max = ( pix + prev ) / 2; } else min = pix - threshold; zone->max = max; zone++; zone->orus = orus; zone->pix = pix; zone->min = min; max = pix + threshold; prev = pix; } zone->max = max; } #ifdef FT_DEBUG_LEVEL_TRACE /* print the scaled stem snap values in tracing mode */ FT_TRACE2(( "Set_Snap_Zones: first %s pass\n", direction ? "vertical" : "horizontal" )); FT_TRACE2(( "Scaled original stem snap zones:\n" )); FT_TRACE2(( " orus pix min max\n" )); FT_TRACE2(( "-----------------------------\n" )); zone = base_zone; for ( n = 0; n < n_zones; n++, zone++ ) FT_TRACE2(( " %3d %.2f %.2f %.2f\n", zone->orus, zone->pix / 64.0, zone->min / 64.0, zone->max / 64.0 )); FT_TRACE2(( "\n" )); FT_TRACE2(( "Standard width = %d\n", standard_width )); #endif /* FT_DEBUG_LEVEL_TRACE */ /*********************************************************************/ /* */ /* Now, each snap width which is in the range of the standard set */ /* width will be removed from the list. */ /* */ if ( standard_width > 0 ) { T1_Snap_Zone* parent; FT_Pos std_pix, std_min, std_max; std_pix = SCALE( standard_width ); std_min = std_pix - threshold; std_max = std_pix + threshold; num_zones = 0; zone = base_zone; parent = base_zone; for ( n = 0; n < n_zones; n++ ) { if ( zone->pix >= std_min && zone->pix <= std_max ) { /* this zone must be removed from the list */ if ( std_min > zone->min ) std_min = zone->min; if ( std_max < zone->max ) std_max = zone->max; } else { *parent++ = *zone; num_zones++; } zone++; } /*******************************************************************/ /* */ /* Now, insert the standard width zone */ /* */ zone = base_zone + num_zones; while ( zone > base_zone && zone[-1].pix > std_max ) { zone[0] = zone[-1]; zone--; } /* check border zones */ if ( zone > base_zone && zone[-1].max > std_min ) zone[-1].max = std_min; if ( zone < base_zone + num_zones && zone[1].min < std_max ) zone[1].min = std_max; zone->orus = standard_width; zone->pix = std_pix; zone->min = std_min; zone->max = std_max; num_zones++; } else num_zones = n_zones; /* save total number of stem snaps now */ if ( direction ) hints->num_snap_heights = num_zones; else hints->num_snap_widths = num_zones; #ifdef FT_DEBUG_LEVEL_TRACE /* print the scaled stem snap values in tracing mode */ FT_TRACE2(( "Set_Snap_Zones: second %s pass\n", direction ? "vertical" : "horizontal" )); FT_TRACE2(( "Scaled clipped stem snap zones:\n" )); FT_TRACE2(( " orus pix min max\n" )); FT_TRACE2(( "-----------------------------\n" )); zone = base_zone; for ( n = 0; n < num_zones; n++, zone++ ) FT_TRACE2(( " %3d %.2f %.2f %.2f\n", zone->orus, zone->pix / 64.0, zone->min / 64.0, zone->max / 64.0 )); FT_TRACE2(( "\n" )); FT_TRACE2(( "Standard width = %d\n", standard_width )); #endif /* FT_DEBUG_LEVEL_TRACE */ /* continue with vertical snap zone */ direction++; standard_width = priv->standard_height[0]; n_zones = priv->num_snap_heights; base_zone = hints->snap_heights; orgs = priv->snap_heights; scale = size->root.metrics.y_scale; } return T1_Err_Ok; } /*************************************************************************/ /* */ /* <Function> */ /* T1_New_Size_Hinter */ /* */ /* <Description> */ /* Allocates a new hinter structure for a given size object. */ /* */ /* <InOut> */ /* size :: A handle to the target size object. */ /* */ /* <Return> */ /* FreeType Error code. 0 means success. */ /* */ LOCAL_FUNC FT_Error T1_New_Size_Hinter( T1_Size size ) { FT_Memory memory = size->root.face->memory; return MEM_Alloc( size->hints, sizeof ( *size->hints ) ); } /*************************************************************************/ /* */ /* <Function> */ /* T1_Done_Size_Hinter */ /* */ /* <Description> */ /* Releases a given size object's hinter structure. */ /* */ /* <Input> */ /* size :: A handle to the target size object. */ /* */ LOCAL_FUNC void T1_Done_Size_Hinter( T1_Size size ) { FT_Memory memory = size->root.face->memory; FREE( size->hints ); } /*************************************************************************/ /* */ /* <Function> */ /* T1_Reset_Size_Hinter */ /* */ /* <Description> */ /* Recomputes hinting information when a given size object has */ /* changed its resolutions/char sizes/pixel sizes. */ /* */ /* <InOut> */ /* size :: A handle to the size object. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ LOCAL_FUNC FT_Error T1_Reset_Size_Hinter( T1_Size size ) { return t1_set_blue_zones( size ) || t1_set_snap_zones( size ); } /*************************************************************************/ /* */ /* <Function> */ /* T1_New_Glyph_Hinter */ /* */ /* <Description> */ /* Allocates a new hinter structure for a given glyph slot. */ /* */ /* <InOut> */ /* glyph :: A handle to the target glyph slot. */ /* */ /* <Return> */ /* FreeType error code. 0 means success. */ /* */ LOCAL_FUNC FT_Error T1_New_Glyph_Hinter( T1_GlyphSlot glyph ) { FT_Memory memory = glyph->root.face->memory; return MEM_Alloc( glyph->hints, sizeof ( *glyph->hints ) ); } /*************************************************************************/ /* */ /* <Function> */ /* T1_Done_Glyph_Hinter */ /* */ /* <Description> */ /* Releases a given glyph slot's hinter structure. */ /* */ /* <Input> */ /* glyph :: A handle to the glyph slot. */ /* */ LOCAL_FUNC void T1_Done_Glyph_Hinter( T1_GlyphSlot glyph ) { FT_Memory memory = glyph->root.face->memory; FREE( glyph->hints ); } /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /********** **********/ /********** HINTED GLYPH LOADER **********/ /********** **********/ /********** The following code is in charge of the first **********/ /********** and second pass when loading a single outline **********/ /********** **********/ /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ static FT_Error t1_hinter_ignore( void ) { /* do nothing, used for `dotsection' which is unsupported for now */ return 0; } static FT_Error t1_hinter_stem( T1_Builder* builder, FT_Pos pos, FT_Int width, FT_Bool vertical ) { T1_Stem_Table* stem_table; T1_Stem_Hint* stems; T1_Stem_Hint* cur_stem; FT_Int min, max, n, num_stems; FT_Bool new_stem; T1_Glyph_Hints* hinter = builder->glyph->hints; /* select the appropriate stem array */ stem_table = vertical ? &hinter->vert_stems : &hinter->hori_stems; stems = stem_table->stems; num_stems = stem_table->num_stems; /* Compute minimum and maximum coord for the stem */ min = pos + ( vertical ? builder->left_bearing.x : builder->left_bearing.y ); if ( width >= 0 ) max = min + width; else { /* a negative width indicates a `ghost' stem */ if ( width == -21 ) min += width; max = min; } /* Now scan the array. If we find a stem with the same borders */ /* simply activate it. */ cur_stem = stems; new_stem = 1; for ( n = 0; n < num_stems; n++, cur_stem++ ) { if ( cur_stem->min_edge.orus == min && cur_stem->max_edge.orus == max ) { /* This stem is already in the table, simply activate it */ if ( ( cur_stem->hint_flags & T1_HINT_FLAG_ACTIVE ) == 0 ) { cur_stem->hint_flags |= T1_HINT_FLAG_ACTIVE; stem_table->num_active++; } new_stem = 0; break; } } /* add a new stem to the array if necessary */ if ( new_stem ) { if ( cur_stem >= stems + T1_HINTER_MAX_EDGES ) { FT_ERROR(( "t1_hinter_stem: too many stems in glyph charstring\n" )); return T1_Err_Syntax_Error; } /* on the first pass, we record the stem, otherwise, this is */ /* a bug in the glyph loader! */ if ( builder->pass == 0 ) { cur_stem->min_edge.orus = min; cur_stem->max_edge.orus = max; cur_stem->hint_flags = T1_HINT_FLAG_ACTIVE; stem_table->num_stems++; stem_table->num_active++; } else { FT_ERROR(( "t1_hinter_stem:" )); FT_ERROR(( " fatal glyph loader bug -- pass2-stem\n" )); return T1_Err_Syntax_Error; } } return T1_Err_Ok; } static FT_Error t1_hinter_stem3( T1_Builder* builder, FT_Pos pos0, FT_Int width0, FT_Pos pos1, FT_Int width1, FT_Pos pos2, FT_Int width2, FT_Bool vertical ) { /* For now, simply call `stem' 3 times */ return t1_hinter_stem( builder, pos0, width0, vertical ) || t1_hinter_stem( builder, pos1, width1, vertical ) || t1_hinter_stem( builder, pos2, width2, vertical ); } static FT_Error t1_hinter_changehints( T1_Builder* builder ) { FT_Int dimension; T1_Stem_Table* stem_table; T1_Glyph_Hints* hinter = builder->glyph->hints; /* If we are in the second pass of glyph hinting, we must */ /* call the function T1_Hint_Points() on the builder in order */ /* to force the fit the latest points to the pixel grid. */ if ( builder->pass == 1 ) T1_Hint_Points( builder ); /* Simply de-activate all hints in all arrays */ stem_table = &hinter->hori_stems; for ( dimension = 2; dimension > 0; dimension-- ) { T1_Stem_Hint* cur = stem_table->stems; T1_Stem_Hint* limit = cur + stem_table->num_stems; for ( ; cur < limit; cur++ ) cur->hint_flags &= ~T1_HINT_FLAG_ACTIVE; stem_table->num_active = 0; stem_table = &hinter->vert_stems; } return T1_Err_Ok; } const T1_Hinter_Funcs t1_hinter_funcs = { (T1_Hinter_ChangeHints)t1_hinter_changehints, (T1_Hinter_DotSection) t1_hinter_ignore, (T1_Hinter_Stem) t1_hinter_stem, (T1_Hinter_Stem3) t1_hinter_stem3 }; /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /********** *********/ /********** *********/ /********** STEM HINTS MANAGEMENT *********/ /********** *********/ /********** The following code is in charge of computing *********/ /********** the placement of each scaled stem hint. *********/ /********** *********/ /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /* */ /* <Function> */ /* t1_sort_hints */ /* */ /* <Description> */ /* Sorta the list of active stems in increasing order, through the */ /* `sort' indexing table. */ /* */ /* <InOut> */ /* table :: A stem hints table. */ /* */ static void t1_sort_hints( T1_Stem_Table* table ) { FT_Int num_stems = table->num_stems; FT_Int num_active = 0; FT_Int* sort = table->sort; T1_Stem_Hint* stems = table->stems; FT_Int n; /* record active stems in sort table */ for ( n = 0; n < num_stems; n++ ) { if ( stems[n].hint_flags & T1_HINT_FLAG_ACTIVE ) sort[num_active++] = n; } /* Now sort the indices. There are usually very few stems, */ /* and they are pre-sorted in 90% cases, so we choose a */ /* simple bubble sort (quicksort would be slower). */ for ( n = 1; n < num_active; n++ ) { FT_Int p = n - 1; T1_Stem_Hint* cur = stems + sort[n]; do { FT_Int swap; T1_Stem_Hint* prev = stems + sort[p]; /* note that by definition, the active stems cannot overlap */ /* so we simply compare their `min' to sort them (we could compare */ /* their max values also; this wouldn't change anything). */ if ( prev->min_edge.orus <= cur->min_edge.orus ) break; /* swap elements */ swap = sort[p ]; sort[p ] = sort[p + 1]; sort[p + 1] = swap; p--; } while ( p >= 0 ); } table->num_active = num_active; } /*************************************************************************/ /* */ /* <Function> */ /* t1_hint_horizontal_stems */ /* */ /* <Description> */ /* Computes the location of each scaled horizontal stem hint. This */ /* takes care of the blue zones and the horizontal stem snap table. */ /* */ /* <Input> */ /* table :: The horizontal stem hints table. */ /* */ /* hints :: The current size's hint structure. */ /* */ /* blueShift :: The value of the /BlueShift as taken from the face */ /* object. */ /* */ /* scale :: The 16.16 scale used to convert outline units to */ /* 26.6 pixels. */ /* */ /* <Note> */ /* For now, all stems are hinted independently from each other. It */ /* might be necessary, for better performance, to introduce the */ /* notion of `controlled' hints describing things like counter-stems, */ /* stem3, as well as overlapping stems control. */ /* */ static void t1_hint_horizontal_stems( T1_Stem_Table* table, T1_Size_Hints* hints, FT_Pos blueShift, FT_Fixed scale ) { T1_Stem_Hint* stem = table->stems; T1_Stem_Hint* limit = stem + table->num_stems; /* first of all, scale the blueShift */ blueShift = SCALE( blueShift ); /* then scan the horizontal stem table */ for ( ; stem < limit; stem++ ) { FT_Pos bottom_orus = stem->min_edge.orus; FT_Pos top_orus = stem->max_edge.orus; FT_Pos top_pix = SCALE( top_orus ); FT_Pos bottom_pix = SCALE( bottom_orus ); FT_Pos width_pix = top_pix - bottom_pix; FT_Pos bottom = bottom_pix; FT_Pos top = top_pix; FT_Int align = T1_ALIGN_NONE; /*********************************************************************/ /* */ /* Snap pixel width if in stem snap range */ /* */ { T1_Snap_Zone* zone = hints->snap_heights; T1_Snap_Zone* zone_limit = zone + hints->num_snap_heights; FT_Pos best_dist = 32000; T1_Snap_Zone* best_zone = 0; for ( ; zone < zone_limit; zone++ ) { FT_Pos dist; dist = width_pix - zone->min; if ( dist < 0 ) dist = -dist; if ( dist < best_dist ) { best_zone = zone; best_dist = dist; } } if ( best_zone ) { if ( width_pix > best_zone->pix ) { width_pix -= 0x20; if ( width_pix < best_zone->pix ) width_pix = best_zone->pix; } else { width_pix += 0x20; if ( width_pix > best_zone->pix ) width_pix = best_zone->pix; } } } /*********************************************************************/ /* */ /* round width - minimum 1 pixel if this isn't a ghost stem */ /* */ if ( width_pix > 0 ) width_pix = width_pix < ONE_PIXEL ? ONE_PIXEL : ROUND( width_pix ); /*********************************************************************/ /* */ /* Now check for bottom blue zones alignement */ /* */ { FT_Int num_blues = hints->num_bottom_zones; T1_Snap_Zone* blue = hints->blue_zones; T1_Snap_Zone* blue_limit = blue + num_blues; for ( ; blue < blue_limit; blue++ ) { if ( bottom_pix < blue->min ) break; if ( bottom_pix <= blue->max ) { align = T1_ALIGN_BOTTOM; bottom = ROUND( blue->pix ); /* implement blue shift */ if ( !hints->supress_overshoots ) { FT_Pos delta = blue->pix - bottom_pix; delta = delta < blueShift ? 0 : ROUND( delta ); bottom -= delta; } } } } /*********************************************************************/ /* */ /* check for top blue zones alignement */ /* */ { FT_Int num_blues = hints->num_blue_zones - hints->num_bottom_zones; T1_Snap_Zone* blue = hints->blue_zones + hints->num_bottom_zones; T1_Snap_Zone* blue_limit = blue + num_blues; for ( ; blue < blue_limit; blue++ ) { if ( top_pix < blue->min ) break; if ( top_pix <= blue->max ) { align |= T1_ALIGN_TOP; top = ROUND( blue->pix ); /* implement blue shift */ if ( !hints->supress_overshoots ) { FT_Pos delta = top - blue->pix; delta = delta < blueShift ? 0 : ROUND( delta ); top += delta; } } } } /*********************************************************************/ /* */ /* compute the hinted stem position, according to its alignment */ /* */ switch ( align ) { case T1_ALIGN_BOTTOM: /* bottom zone alignment */ bottom_pix = bottom; top_pix = bottom + width_pix; break; case T1_ALIGN_TOP: /* top zone alignment */ top_pix = top; bottom_pix = top - width_pix; break; case T1_ALIGN_BOTH: /* bottom+top zone alignment */ bottom_pix = bottom; top_pix = top; break; default: /* no alignment */ /* XXX TODO: Add management of controlled stems */ bottom = ( SCALE( bottom_orus + top_orus ) - width_pix ) / 2; bottom_pix = ROUND( bottom ); top_pix = bottom_pix + width_pix; } stem->min_edge.pix = bottom_pix; stem->max_edge.pix = top_pix; } } /*************************************************************************/ /* */ /* <Function> */ /* t1_hint_vertical_stems */ /* */ /* <Description> */ /* Computes the location of each scaled vertical stem hint. This */ /* takes care of the vertical stem snap table. */ /* */ /* <Input> */ /* table :: The vertical stem hints table. */ /* hints :: The current size's hint structure. */ /* scale :: The 16.16 scale used to convert outline units to */ /* 26.6 pixels. */ /* */ /* <Note> */ /* For now, all stems are hinted independently from each other. It */ /* might be necessary, for better performance, to introduce the */ /* notion of `controlled' hints describing things like counter-stems, */ /* stem3 as well as overlapping stems control. */ /* */ static void t1_hint_vertical_stems( T1_Stem_Table* table, T1_Size_Hints* hints, FT_Fixed scale ) { T1_Stem_Hint* stem = table->stems; T1_Stem_Hint* limit = stem + table->num_stems; for ( ; stem < limit; stem++ ) { FT_Pos stem_left = stem->min_edge.orus; FT_Pos stem_right = stem->max_edge.orus; FT_Pos width_pix, left; width_pix = SCALE( stem_right - stem_left ); /* Snap pixel width if in stem snap range */ { T1_Snap_Zone* zone = hints->snap_heights; T1_Snap_Zone* zone_limit = zone + hints->num_snap_heights; FT_Pos best_dist = 32000; T1_Snap_Zone* best_zone = 0; for ( ; zone < zone_limit; zone++ ) { FT_Pos dist; dist = width_pix - zone->min; if ( dist < 0 ) dist = -dist; if ( dist < best_dist ) { best_zone = zone; best_dist = dist; } } if ( best_zone ) { if ( width_pix > best_zone->pix ) { width_pix -= 0x20; if ( width_pix < best_zone->pix ) width_pix = best_zone->pix; } else { width_pix += 0x20; if ( width_pix > best_zone->pix ) width_pix = best_zone->pix; } } } /* round width - minimum 1 pixel if this isn't a ghost stem */ if ( width_pix > 0 ) width_pix = width_pix < ONE_PIXEL ? ONE_PIXEL : ROUND( width_pix ); /* now place the snapped and rounded stem */ /* XXX TODO: implement controlled stems for the overlapping */ /* cases */ left = ( SCALE( stem_left + stem_right ) - width_pix ) / 2; stem->min_edge.pix = ROUND( left ); stem->max_edge.pix = stem->min_edge.pix + width_pix; } } /*************************************************************************/ /* */ /* <Function> */ /* t1_hint_point */ /* */ /* <Description> */ /* Grid-fit a coordinate with regards to a given stem hints table. */ /* */ /* <Input> */ /* table :: The source stem hints table. */ /* coord :: The original coordinate, expressed in font units. */ /* scale :: The 16.16 scale used to convert font units into */ /* 26.6 pixels. */ /* */ /* <Return> */ /* The hinted/scaled value in 26.6 pixels. */ /* */ /* <Note> */ /* For now, all stems are hinted independently from each other. It */ /* might be necessary, for better performance, to introduce the */ /* notion of `controlled' hints describing things like counter-stems, */ /* stem3 as well as overlapping stems control. */ /* */ static FT_Pos t1_hint_point( T1_Stem_Table* table, FT_Pos coord, FT_Fixed scale ) { FT_Int num_active = table->num_active; FT_Int n; T1_Stem_Hint* prev = 0; T1_Stem_Hint* cur = 0; T1_Edge* min; T1_Edge* max; FT_Pos delta; /* only hint when there is at least one stem defined */ if ( num_active <= 0 ) return SCALE( coord ); /* scan the stem table to determine placement of coordinate */ /* relative to the list of sorted and stems */ for ( n = 0; n < num_active; n++, prev = cur ) { cur = table->stems + table->sort[n]; /* is it on the left of the current edge? */ delta = cur->min_edge.orus - coord; if ( delta == 0 ) return cur->min_edge.pix; if ( delta > 0 ) { /* if this is the left of the first edge, simply shift */ if ( !prev ) return cur->min_edge.pix - SCALE( delta ); /* otherwise, interpolate between the maximum of the */ /* previous stem, and the minimum of the current one */ min = &prev->max_edge; max = &cur->min_edge; goto Interpolate; } /* is it within the current edge? */ delta = cur->max_edge.orus - coord; if ( delta == 0 ) return cur->max_edge.pix; if ( delta > 0 ) { /* interpolate within the stem */ min = &cur->min_edge; max = &cur->max_edge; goto Interpolate; } } /* apparently, this coordinate is on the right of the last stem */ delta = coord - cur->max_edge.orus; return cur->max_edge.pix + SCALE( delta ); Interpolate: return min->pix + FT_MulDiv( coord - min->orus, max->pix - min->pix, max->orus - min->orus ); } /*************************************************************************/ /* */ /* <Function> */ /* T1_Hint_Points */ /* */ /* <Description> */ /* This function grid-fits several points in a given Type 1 builder */ /* at once. */ /* */ /* <Input> */ /* builder :: A handle to target Type 1 builder. */ /* */ LOCAL_FUNC void T1_Hint_Points( T1_Builder* builder ) { FT_Int first = builder->hint_point; FT_Int last = builder->current->n_points - 1; T1_Size size = builder->size; FT_Fixed scale_x = size->root.metrics.x_scale; FT_Fixed scale_y = size->root.metrics.y_scale; T1_Glyph_Hints* hints = builder->glyph->hints; T1_Stem_Table* hori_stems = &hints->hori_stems; T1_Stem_Table* vert_stems = &hints->vert_stems; FT_Vector* cur = builder->current->points + first; FT_Vector* limit = cur + last - first + 1; /* first of all, sort the active stem hints */ t1_sort_hints( hori_stems ); t1_sort_hints( vert_stems ); for ( ; cur < limit; cur++ ) { cur->x = t1_hint_point( vert_stems, cur->x, scale_x ); cur->y = t1_hint_point( hori_stems, cur->y, scale_y ); } builder->hint_point = builder->current->n_points; } /*************************************************************************/ /* */ /* <Function> */ /* T1_Hint_Stems */ /* */ /* <Description> */ /* This function is used to compute the location of each stem hint */ /* between the first and second passes of the glyph loader on the */ /* charstring. */ /* */ /* <Input> */ /* builder :: A handle to the target builder. */ /* */ LOCAL_FUNC void T1_Hint_Stems( T1_Builder* builder ) { T1_Glyph_Hints* hints = builder->glyph->hints; T1_Private* priv = &builder->face->type1.private_dict; T1_Size size = builder->size; FT_Fixed scale_x = size->root.metrics.x_scale; FT_Fixed scale_y = size->root.metrics.y_scale; t1_hint_horizontal_stems( &hints->hori_stems, builder->size->hints, priv->blue_shift, scale_y ); t1_hint_vertical_stems( &hints->vert_stems, builder->size->hints, scale_x ); } /* END */