diff options
Diffstat (limited to 'testing/freetype-infinality/freetype-entire-infinality-patchset-20101114-1.patch')
| -rw-r--r-- | testing/freetype-infinality/freetype-entire-infinality-patchset-20101114-1.patch | 1602 |
1 files changed, 0 insertions, 1602 deletions
diff --git a/testing/freetype-infinality/freetype-entire-infinality-patchset-20101114-1.patch b/testing/freetype-infinality/freetype-entire-infinality-patchset-20101114-1.patch deleted file mode 100644 index aae5fadde..000000000 --- a/testing/freetype-infinality/freetype-entire-infinality-patchset-20101114-1.patch +++ /dev/null @@ -1,1602 +0,0 @@ -freetype-entire-infinality-patchset (excludes the TT subpixel patches) -------------------------------------------------------------------- - -This patch contains all the patches I used to distribute separately. -It made more sense to lump these all together into a single file -now that there are runtime options. It's also easier for me to maintain. ;) - -I recommend that if you are using this patch that you use - - /etc/fonts/local.conf - -that I provide at: http://www.infinality.net/files/local.conf -You will also need: http://www.infinality.net/files/infinality-settings - -The second one will need to be included in your profile with something like: - - . ~/path/to/the/file/infinality-settings - -It should be adjusted to your personal tastes as an end-user. - - -DISCLAIMERS: - -This patch will almost certainly result in a performance hit when -freetype is rendering the glyphs. The good news is that fontconfig -caches the glyphs so it's only the first time they are displayed that there -could be a performance issue. - -I expect that if you compile freetype with this patch along with my -TT subpixel hinting patch, you will have a complete build that works the -way I expect it to. However, I have not tested all compile configurations -for errors. I intend to at some point. This patch may make your system crash, -have memory leaks, not compile, or render fonts in a way that you don't like. -Either way, when you use this patch, you should recognize that it -is ALPHA / BETA quality. That said, I intend to run these patches on my -personal system, so they had better be pretty stable! - - -Changelog - -2010-11-14 - - All patches can now be enabled at runtime with ENVIRONMENT_VARIABLES. - See the file infinality-settings (and below) for how to enable these. - Effects that used to work now **REQUIRE** these in order to be turned on - at runtime. This lets end users have full control over what they want - without requiring different compiles. - - - Added option to auto-embolden thin/light fonts. - - - Further refinement of the stem calculations for enhanced autohint. - - - Adjustable FIR filter at runtime. - - - Stem alignment ability to align glyph bitmaps to pixel boundaries. - - - Adjustable gamma correction prior to the FIR filter for LCD rendering. - This can be used to make small ppem text more readable, or for whatever - else you want to use it for. - - - A height tweak on the enhanced autohint that makes Arial, Segoe, Times - and others render more similarly to Windows. - - - Separated out the option to maintain the original width of glyphs - when doing fake emboldening. - - - -################################################################## -# The environment variables below should be copied to a file in -# /etc/profile.d/ for system-wide effects and/or included in -# ~/.bashrc or ~/.bash_profile for per-user effects: -# -# . ~/path/to/the/file/infinality-settings -# -# Of course, the per-user settings will override the system-wide -# settings. - - - -################################################################## -# INFINALITY_FT_FILTER_PARAMS -# -# This is a modified version of the patch here: -# http://levelsofdetail.kendeeter.com/2008/12/dynamic_fir_filter_patch.html -# -# Allows you to adjust the FIR filter at runtime instead of at -# compile time. The idea is to have values add up to one, and be -# symmetrical around the middle value. Here are some samples -# of various filter parameters: -# -# Strong Extra Smooth "0.15 0.2 0.3 0.2 0.15" (extra smooth, natural weight) -# Extra Smooth "0.20 0.20 0.30 0.20 0.20" (extra smooth, extra weight) -# Smooth "0.15 0.20 0.32 0.20 0.15" (smooth, natural weight) -# Stronger Gibson "0.11 0.22 0.38 0.22 0.11" (smooth, extra weight) -# Gibson "0.11 0.22 0.33 0.22 0.11" (smooth, natural weight) -# Freetype Light "0.00 0.33 0.34 0.33 0.00" (sharp, natural weight) -# Freetype Default "0.06 0.25 0.44 0.25 0.06" (sharp, extra weight) *default -# Extra Sharp "0.00 0.35 0.35 0.35 0.00" (extra sharp, extra weight) -# -# Default: [Freetype's default] -# Recommended: "0.11 0.22 0.38 0.22 0.11" -# -# Example 1: export INFINALITY_FT_FILTER_PARAMS="0.11 0.22 0.38 0.22 0.11" -# - -export INFINALITY_FT_FILTER_PARAMS="0.11 0.22 0.38 0.22 0.11" - - - - -################################################################## -# INFINALITY_FT_STEM_ALIGNMENT_TYPE -# -# This performs analysis on each glyph and determines the best -# subpixel orientation for the glyph. The glyph is not scaled in -# any way, just moved left or right by a subpixel amount. This -# results in subtley cleaner looking fonts, at the expense of -# proper distances between glyphs. This is only active for sizes -# 10 px or greater and does not apply to bold or italic fonts. -# -# Possible values: -# full - Allows a glyph to be moved to the LEFT or RIGHT by 1 subpixel -# Best alignment, Worst positioning -# medium,medium1 - Only allows a glyph to be moved to the LEFT by 1 subpixel -# Good alignment, Good positioning -# medium2 - Only allows a glyph to be moved to the RIGHT by 1 subpixel -# Good alignment, Good positioning -# slight,slight1 - A stricter version of medium -# Minor alignment, Best positioning -# slight2 - A stricter version of medium2 -# Minor alignment, Best positioning -# infinality - medium1 when stem < 5 subpixels, full when >= 5 subpixels -# none - Don't do any alignment -# -# Default: none -# Recommended: medium - -export INFINALITY_FT_STEM_ALIGNMENT_TYPE=medium - - - - - -################################################################## -# INFINALITY_FT_AUTOFIT_STEM_SNAP_LIGHT -# -# Cause the height of horizontal stems to snap to integer pixels -# when using light auto-hinting. (This happens automatically -# when using full auto-hinting) -# -# This produces an effect similar to the way Windows renders fonts -# without requiring the font to contain bytecode instructions. -# -# Possible values: -# true - enable stem snapping -# false - do not enable stem snapping -# -# Default: false -# Recommended: true - -export INFINALITY_FT_AUTOFIT_STEM_SNAP_LIGHT=true - - - - -################################################################## -# INFINALITY_FT_AUTOFIT_EMBOLDEN_LIGHT -# -# Embolden particularly light or thin fonts, like DejaVu Sans Light, -# Inconsolata, Freemono, Courier New, etc. up until stem width is -# 1 pixel wide. This makes these fonts easier to read at lower -# ppems. Only applies when the autohinter is being used. -# -# Possible values: -# true - enable emboldening of light fonts -# false - do not enable emboldening of light fonts -# -# Default: false -# Recommended: true - -export INFINALITY_FT_AUTOFIT_EMBOLDEN_LIGHT=true - - - - -################################################################## -# INFINALITY_FT_PSEUDO_GAMMA -# -# This does a weighted gamma correction at the LCD filter phase -# prior to the LCD filter. -# -# The first value indicates a px value, the second indicates a -# "gamma" value. All sizes < the px value will be corrected -# on a weighted scale based on the second value. -# -# Values .1 < 1.0 will darken the glyph -# Values > 1.0 will lighten the glyph -# -# Example 1: Darken glyphs that are less than 10 px. With some fonts -# even 5 or 6px is readable! -# export INFINALITY_FT_PSEUDO_GAMMA="10 .6" -# -# Example 2: Lighten all glyphs (below 100px) -# export INFINALITY_FT_PSEUDO_GAMMA="100 1.5" -# -# Default: [No gamma correction] -# Recommended: "9 .7" - -export INFINALITY_FT_PSEUDO_GAMMA="9 .7" - - - - -################################################################## -# INFINALITY_FT_AUTOFIT_ADJUST_HEIGHTS -# -# This will slightly stretch some glyphs vertically between 9px -# and 14px (inclusive). Some people may find this more -# aesthetically pleasing. This only applies to fonts that are -# using autohint. -# -# Possible values: -# true - enable height adjustment -# false - do not enable height adjustment -# -# Default: false - -export INFINALITY_FT_AUTOFIT_ADJUST_HEIGHTS=true - - - - -################################################################## -# INFINALITY_FT_ENHANCED_EMBOLDEN -# -# When doing artificial emboldening, only embolden in the X -# direction, skipping the Y direction. Most people will find this -# more aesthetically pleasing than the default behavior. -# -# Possible values: -# true - enable enhanced emboldening -# false - no not enable enhanced emboldening -# -# Default: false -# Recommended: true - -export INFINALITY_FT_ENHANCED_EMBOLDEN=true - - - - -################################################################## -# INFINALITY_FT_EMBOLDEN_MAINTAIN_WIDTH -# -# When doing artificial emboldening, don't change the glyph width. -# -# Possible values: -# true - maintain width -# false - do not maintain width -# -# Default: false -# Recommended: true - -export INFINALITY_FT_EMBOLDEN_MAINTAIN_WIDTH=true - - - - -################################################################## -# INFINALITY_FT_AUTO_AUTOHINT -# -# Automatically use autohint when rendering a font that contains -# no truetype instructions, regardless of what the calling -# program asks for. The truetype hinter will not do a good job -# on these. -# -# Possible values: -# true - automatically use autohint -# false - do not automatically use autohint -# -# Default: false -# Recommended: true - -export INFINALITY_FT_AUTO_AUTOHINT=true - - - - - - -INFINALITY_FT_AUTOFIT_STEM_SNAP_LIGHT details ---------------------------------------------- - -This patch is intended to make freetype's autohinter round down widths of -horizontal stems to whole pixel values. This dramatically reduces the -graininess of the rendering at small sizes, at the expense of being true to the -glyph. - -Put simply, it makes freetype's autohinter render fonts similarly -to well-hinted TrueType fonts, even on fonts that contain no instructions. -So, as far as I can tell, this makes it 100% patent-free. - -The most dramatic results are on sans-serif fonts like Lucida Grande, -Arial, Helvetica Neue, Inconsolata, Droid Sans, Trebuchet MS, etc. - - -It is recommended to use this with antialiasing on, and fonts set to -slight hinting: - - <match target="font" > - <edit mode="assign" name="rgba" > - <const>rgb</const> - </edit> - <edit mode="assign" name="hinting" > - <bool>true</bool> - </edit> - <edit mode="assign" name="autohint" > - <bool>true</bool> - </edit> - <edit mode="assign" name="antialias" > - <bool>true</bool> - </edit> - <edit mode="assign" name="hintstyle" > - <const>hintslight</const> - </edit> - <edit name="lcdfilter" mode="assign"> - <const>lcddefault</const> - </edit> - </match> - - - - -diff -Nur freetype-2.4.3.orig/configure freetype-2.4.3.new/configure ---- freetype-2.4.3.orig/configure 2010-10-03 13:05:26.000000000 -0500 -+++ freetype-2.4.3.new/configure 2010-11-14 18:17:36.593491866 -0600 -@@ -13,6 +13,8 @@ - # Call the `configure' script located in `builds/unix'. - # - -+export LDFLAGS="$LDFLAGS -lm" -+ - rm -f config.mk builds/unix/unix-def.mk builds/unix/unix-cc.mk - - if test "x$GNUMAKE" = x; then -diff -Nur freetype-2.4.3.orig/include/freetype/internal/ftobjs.h freetype-2.4.3.new/include/freetype/internal/ftobjs.h ---- freetype-2.4.3.orig/include/freetype/internal/ftobjs.h 2010-07-18 11:07:31.000000000 -0500 -+++ freetype-2.4.3.new/include/freetype/internal/ftobjs.h 2010-11-07 11:18:19.681501081 -0600 -@@ -762,6 +770,10 @@ - FT_Library library ); - - -+ typedef void (*FT_Bitmap_LcdStemAlignFunc)( FT_Bitmap* bitmap, -+ FT_Render_Mode render_mode, -+ FT_GlyphSlot slot ); -+ - /*************************************************************************/ - /* */ - /* <Struct> */ -@@ -862,6 +874,7 @@ - FT_Int lcd_extra; /* number of extra pixels */ - FT_Byte lcd_weights[7]; /* filter weights, if any */ - FT_Bitmap_LcdFilterFunc lcd_filter_func; /* filtering callback */ -+ FT_Bitmap_LcdStemAlignFunc lcd_stem_align_func; - #endif - - #ifdef FT_CONFIG_OPTION_PIC -diff -Nur freetype-2.4.3.orig/src/autofit/aflatin.c freetype-2.4.3.new/src/autofit/aflatin.c ---- freetype-2.4.3.orig/src/autofit/aflatin.c 2010-09-11 01:23:02.000000000 -0500 -+++ freetype-2.4.3.new/src/autofit/aflatin.c 2010-11-14 18:55:57.678647844 -0600 -@@ -21,6 +21,7 @@ - - #include "aflatin.h" - #include "aferrors.h" -+#include "strings.h" - - - #ifdef AF_USE_WARPER -@@ -495,6 +496,29 @@ - AF_LatinAxis axis; - FT_UInt nn; - -+ int checked_adjust_heights_env = 0; -+ FT_Bool adjust_heights = FALSE; -+ -+ if ( checked_adjust_heights_env == 0 ) -+ { -+ char *adjust_heights_env = getenv( "INFINALITY_FT_AUTOFIT_ADJUST_HEIGHTS" ); -+ if ( adjust_heights_env != NULL ) -+ { -+ if ( strcasecmp(adjust_heights_env, "default" ) != 0 ) -+ { -+ if ( strcasecmp(adjust_heights_env, "true") == 0) -+ adjust_heights = TRUE; -+ else if ( strcasecmp(adjust_heights_env, "1") == 0) -+ adjust_heights = TRUE; -+ else if ( strcasecmp(adjust_heights_env, "on") == 0) -+ adjust_heights = TRUE; -+ else if ( strcasecmp(adjust_heights_env, "yes") == 0) -+ adjust_heights = TRUE; -+ } -+ } -+ checked_adjust_heights_env = 1; -+ } -+ - - if ( dim == AF_DIMENSION_HORZ ) - { -@@ -522,21 +546,46 @@ - { - AF_LatinAxis Axis = &metrics->axis[AF_DIMENSION_VERT]; - AF_LatinBlue blue = NULL; -- -+ int threshold = 40; - - for ( nn = 0; nn < Axis->blue_count; nn++ ) - { -- if ( Axis->blues[nn].flags & AF_LATIN_BLUE_ADJUSTMENT ) -+ if ( Axis->blues[nn].flags & AF_LATIN_BLUE_ADJUSTMENT -+ || ( adjust_heights && Axis->blues[nn].flags & AF_LATIN_BLUE_TOP ) -+ ) - { - blue = &Axis->blues[nn]; - break; - } - } - -+ if ( adjust_heights -+ && metrics->root.scaler.face->size->metrics.x_ppem < 15 -+ && metrics->root.scaler.face->size->metrics.x_ppem > 8 ) -+ threshold = 52; -+ -+ /* NEED TO FIND A WAY TO ADJUST CAPS AND LOWER SEPARATELY */ -+ /* The below does not work */ -+ /* if (Axis->blues[nn].flags & AF_LATIN_BLUE_SMALL_TOP ) -+ { -+ if (metrics->root.scaler.face->size->metrics.x_ppem < 15) -+ threshold = 22; -+ else threshold = 40; -+ break; -+ } -+ if ( Axis->blues[nn].flags & AF_LATIN_BLUE_CAPITAL_TOP ) -+ { -+ if (metrics->root.scaler.face->size->metrics.x_ppem < 15) -+ threshold = 40; -+ else threshold = 40; -+ break; -+ } -+ */ -+ - if ( blue ) - { - FT_Pos scaled = FT_MulFix( blue->shoot.org, scaler->y_scale ); -- FT_Pos fitted = ( scaled + 40 ) & ~63; -+ FT_Pos fitted = ( scaled + threshold ) & ~63; - - - if ( scaled != fitted ) -@@ -1340,7 +1389,8 @@ - if ( dist < 0 ) - dist = -dist; - -- dist = FT_MulFix( dist, scale ); -+ /* round down to pixels */ -+ dist = FT_MulFix( dist, scale ) & ~63; - if ( dist < best_dist ) - { - best_dist = dist; -@@ -1500,9 +1550,33 @@ - FT_Int vertical = ( dim == AF_DIMENSION_VERT ); - - -- if ( !AF_LATIN_HINTS_DO_STEM_ADJUST( hints ) || -- axis->extra_light ) -- return width; -+ int checked_stem_snap_env = 0; -+ FT_Bool stem_snap_light = FALSE; -+ -+ if ( checked_stem_snap_env == 0 ) -+ { -+ char *stem_snap_env = getenv( "INFINALITY_FT_AUTOFIT_STEM_SNAP_LIGHT" ); -+ if ( stem_snap_env != NULL ) -+ { -+ if ( strcasecmp(stem_snap_env, "default" ) != 0 ) -+ { -+ if ( strcasecmp(stem_snap_env, "true") == 0) -+ stem_snap_light = TRUE; -+ else if ( strcasecmp(stem_snap_env, "1") == 0) -+ stem_snap_light = TRUE; -+ else if ( strcasecmp(stem_snap_env, "on") == 0) -+ stem_snap_light = TRUE; -+ else if ( strcasecmp(stem_snap_env, "yes") == 0) -+ stem_snap_light = TRUE; -+ } -+ } -+ checked_stem_snap_env = 1; -+ } -+ -+ if ( !stem_snap_light ) -+ if ( !AF_LATIN_HINTS_DO_STEM_ADJUST( hints ) || -+ axis->extra_light ) -+ return width; - - if ( dist < 0 ) - { -@@ -1510,8 +1584,67 @@ - sign = 1; - } - -- if ( ( vertical && !AF_LATIN_HINTS_DO_VERT_SNAP( hints ) ) || -- ( !vertical && !AF_LATIN_HINTS_DO_HORZ_SNAP( hints ) ) ) -+ if ( stem_snap_light -+ && ( -+ ( vertical && !AF_LATIN_HINTS_DO_VERT_SNAP( hints ) ) -+ || ( !vertical && !AF_LATIN_HINTS_DO_HORZ_SNAP( hints ) ) ) ) -+ { -+ dist = af_latin_snap_width( axis->widths, axis->width_count, dist ); -+ -+ if ( metrics->root.scaler.face->size->metrics.x_ppem > 9 -+ && axis->width_count > 0 -+ && abs ( axis->widths[0].cur - dist ) < 32 -+ && axis->widths[0].cur > 52 ) -+ { -+ if ( strstr(metrics->root.scaler.face->style_name, "Regular") -+ || strstr(metrics->root.scaler.face->style_name, "Book") -+ || strstr(metrics->root.scaler.face->style_name, "Medium") -+ || strcmp(metrics->root.scaler.face->style_name, "Italic") == 0 -+ || strcmp(metrics->root.scaler.face->style_name, "Oblique") == 0 ) -+ { -+ /* regular weight */ -+ if ( axis->widths[0].cur < 64 ) dist = 64 ; -+ else if (axis->widths[0].cur < 88) dist = 64; -+ else if (axis->widths[0].cur < 160) dist = 128; -+ else if (axis->widths[0].cur < 240) dist = 190; -+ else dist = ( dist ) & ~63; -+ } -+ else -+ { -+ /* bold gets a different threshold */ -+ if ( axis->widths[0].cur < 64 ) dist = 64 ; -+ else if (axis->widths[0].cur < 108) dist = 64; -+ else if (axis->widths[0].cur < 160) dist = 128; -+ else if (axis->widths[0].cur < 222) dist = 190; -+ else if (axis->widths[0].cur < 288) dist = 254; -+ else dist = ( dist + 16 ) & ~63; -+ } -+ -+ /* fix any unusually low values */ -+ if (dist < ( axis->widths[0].cur & ~63 ) ) -+ dist = (axis->widths[0].cur & ~63); -+ -+ /* fix any unusually high values */ -+ if (dist > ( ( axis->widths[0].cur + 64 ) & ~63 ) ) -+ dist = ( ( axis->widths[0].cur + 64 ) & ~63 ); -+ -+ if (dist < 64 ) dist = 64 ; -+ -+ } -+ if (dist < 52) -+ { -+ if (metrics->root.scaler.face->size->metrics.x_ppem < 9 ) -+ { -+ /*dist = 64 - (64 - dist) / 2 ;*/ -+ if (dist < 31) dist = 31; -+ } -+ else -+ dist = 52; -+ } -+ -+ } -+ else if ( !stem_snap_light && (( vertical && !AF_LATIN_HINTS_DO_VERT_SNAP( hints ) ) || -+ ( !vertical && !AF_LATIN_HINTS_DO_HORZ_SNAP( hints ) ) ) ) - { - /* smooth hinting process: very lightly quantize the stem width */ - -@@ -1569,7 +1702,7 @@ - dist = ( dist + 32 ) & ~63; - } - } -- else -+ else if (!stem_snap_light) - { - /* strong hinting process: snap the stem width to integer pixels */ - FT_Pos org_dist = dist; -@@ -1577,6 +1710,8 @@ - - dist = af_latin_snap_width( axis->widths, axis->width_count, dist ); - -+ if ( stem_snap_light ) goto Done_Width; -+ - if ( vertical ) - { - /* in the case of vertical hinting, always round */ -@@ -2100,7 +2235,30 @@ - { - FT_Error error; - int dim; -+ int e_strength = 0; -+ -+ int checked_embolden_light_env = 0; -+ FT_Bool embolden_light = FALSE; - -+ if ( checked_embolden_light_env == 0 ) -+ { -+ char *embolden_light_env = getenv( "INFINALITY_FT_AUTOFIT_EMBOLDEN_LIGHT" ); -+ if ( embolden_light_env != NULL ) -+ { -+ if ( strcasecmp(embolden_light_env, "default" ) != 0 ) -+ { -+ if ( strcasecmp(embolden_light_env, "true") == 0) -+ embolden_light = TRUE; -+ else if ( strcasecmp(embolden_light_env, "1") == 0) -+ embolden_light = TRUE; -+ else if ( strcasecmp(embolden_light_env, "on") == 0) -+ embolden_light = TRUE; -+ else if ( strcasecmp(embolden_light_env, "yes") == 0) -+ embolden_light = TRUE; -+ } -+ } -+ checked_embolden_light_env = 1; -+ } - - error = af_glyph_hints_reload( hints, outline ); - if ( error ) -@@ -2146,8 +2304,15 @@ - } - #endif - -- if ( ( dim == AF_DIMENSION_HORZ && AF_HINTS_DO_HORIZONTAL( hints ) ) || -- ( dim == AF_DIMENSION_VERT && AF_HINTS_DO_VERTICAL( hints ) ) ) -+ if ( ( dim == AF_DIMENSION_HORZ && AF_HINTS_DO_HORIZONTAL( hints ) ) ) -+ { -+ af_latin_hint_edges( hints, (AF_Dimension)dim ); -+ af_glyph_hints_align_edge_points( hints, (AF_Dimension)dim ); -+ af_glyph_hints_align_strong_points( hints, (AF_Dimension)dim ); -+ af_glyph_hints_align_weak_points( hints, (AF_Dimension)dim ); -+ } -+ -+ if ( ( dim == AF_DIMENSION_VERT && AF_HINTS_DO_VERTICAL( hints ) ) ) - { - af_latin_hint_edges( hints, (AF_Dimension)dim ); - af_glyph_hints_align_edge_points( hints, (AF_Dimension)dim ); -@@ -2157,6 +2322,34 @@ - } - af_glyph_hints_save( hints, outline ); - -+ /* if the font is particularly thin, embolden it, up to 1 px */ -+ if ( embolden_light -+ && metrics->axis->widths[0].cur <= 80 -+ && !( dim == AF_DIMENSION_VERT ) -+ && !AF_LATIN_HINTS_DO_HORZ_SNAP( hints ) ) -+ { -+ if ( metrics->axis->widths[0].cur -+ / metrics->root.scaler.face->size->metrics.x_ppem < 5 ) -+ { -+ /* weakest at width 80, stronger at lower widths */ -+ e_strength = 40 * ( 80 - metrics->axis->widths[0].cur)/80 ; -+ /* Don't do low ppems as much */ -+ if ( metrics->root.scaler.face->size->metrics.x_ppem < 9 ) -+ e_strength -= -+ ( 9 - metrics->root.scaler.face->size->metrics.x_ppem ) * 10; -+ } -+ -+ /* Embolden small fonts on a sliding scale. Better readability. */ -+ if ( e_strength > 0 -+ && ( strstr(metrics->root.scaler.face->style_name, "Regular") -+ || strstr(metrics->root.scaler.face->style_name, "Book") -+ || strstr(metrics->root.scaler.face->style_name, "Light") -+ || strstr(metrics->root.scaler.face->style_name, "Medium") -+ || strcmp(metrics->root.scaler.face->style_name, "Italic") == 0 -+ || strcmp(metrics->root.scaler.face->style_name, "Oblique") == 0 ) ) -+ FT_Outline_Embolden(outline,e_strength); -+ } -+ - Exit: - return error; - } -diff -Nur freetype-2.4.3.orig/src/autofit/afloader.c freetype-2.4.3.new/src/autofit/afloader.c ---- freetype-2.4.3.orig/src/autofit/afloader.c 2009-07-03 08:28:24.000000000 -0500 -+++ freetype-2.4.3.new/src/autofit/afloader.c 2010-10-22 22:22:04.073099288 -0500 -@@ -180,8 +180,8 @@ - AF_Edge edge2 = edge1 + - axis->num_edges - 1; /* rightmost edge */ - -- -- if ( axis->num_edges > 1 && AF_HINTS_DO_ADVANCE( hints ) ) -+/* dont hint metrics - temporary until different hinting can be done */ -+ if ( FALSE && axis->num_edges > 1 && AF_HINTS_DO_ADVANCE( hints ) ) - { - old_rsb = loader->pp2.x - edge2->opos; - old_lsb = edge1->opos; -@@ -214,7 +214,8 @@ - slot->lsb_delta = loader->pp1.x - pp1x_uh; - slot->rsb_delta = loader->pp2.x - pp2x_uh; - } -- else -+/* dont hint metrics - temporary until different hinting can be done */ -+ else if (FALSE) - { - FT_Pos pp1x = loader->pp1.x; - FT_Pos pp2x = loader->pp2.x; -diff -Nur freetype-2.4.3.orig/src/base/ftlcdfil.c freetype-2.4.3.new/src/base/ftlcdfil.c ---- freetype-2.4.3.orig/src/base/ftlcdfil.c 2010-04-01 03:18:57.000000000 -0500 -+++ freetype-2.4.3.new/src/base/ftlcdfil.c 2010-11-14 18:33:58.300770778 -0600 -@@ -21,9 +21,659 @@ - #include FT_IMAGE_H - #include FT_INTERNAL_OBJECTS_H - -+#include <math.h> -+#include <string.h> -+#include <strings.h> - - #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING - -+/* -+int sinc( int val ) { -+ if (val == 0.0) -+ return(1.0); -+ return 256.0 * (sin(3.14*(double) (val/256.0))/(3.14*(double) (val/256.0))); -+} -+ -+int sigmoidal( int val ) { -+ int val2; -+ val2 = 256.0 /(1.0+exp(-(10.0*(val/256.0-.5)))); -+ return window(val2); -+} -+ -+int window ( int val ) -+{ -+ if (val < 0 ) return 0; -+ if (val > 255) return 255; -+ else return val; -+} -+*/ -+int gamma2 ( int val, float value ) { -+ return 256 * (1.0 - pow((1.0 - (float)val/ 256.0) , 1.0/value)); -+} -+/* -+int gamma3 ( int val, float value ) { -+ 1- (x-1)^10 -+} -+*/ -+/* -+int gamma ( int val ) { -+ return 256 * (1.0 - pow((1.0 - (float)val/ 256.0) , 1.5)); -+} -+ -+int brick (int val) { -+ if (val > 50) return val; -+ else return 0; -+} -+ -+int brick2 (int val) { -+ if (val > 100) return val; -+ if (val > 50) return 100; -+ else return 0; -+} -+ -+int none (int val) { -+ return val; -+} -+ -+float pixmoid (int val1, int val2, int val3, int testval) -+{ -+ int avg; -+ int result; -+ -+ avg = (val1 + val2 + val3)/3; -+ -+ if ( avg < 128 ) -+ { -+ if (testval > 128) result = avg; -+ else result = testval; -+ } -+ else -+ { -+ if (testval < 128) result = avg; -+ else result = testval; -+ } -+ -+ return none(result); -+} -+ -+float pixmoid2 (int val1, int val2, int val3, int testval) -+{ -+ int avg; -+ int result; -+ -+ avg = (val1 + val2 + val3)/3; -+ -+ if ( avg > 160 ) return 255; -+ else if ( avg < 100 ) return 0; -+ else return testval; -+ -+ return none(result); -+ -+} -+*/ -+/* -+bool Resample(FT_Byte* line, int newWidth, int newHeight) -+{ -+ -+ unsigned char* newData = new unsigned char [newWidth * newHeight * 3]; -+ -+ double scaleWidth = (double)newWidth / (double)_width; -+ double scaleHeight = (double)newHeight / (double)_height; -+ -+ for(int cy = 0; cy < newHeight; cy++) -+ { -+ for(int cx = 0; cx < newWidth; cx++) -+ { -+ int pixel = (cy * (newWidth *3)) + (cx*3); -+ int nearestMatch = (((int)(cy / scaleHeight) -+ * (_width *3)) + ((int)(cx / scaleWidth) *3) ); -+ -+ newData[pixel ] = _data[nearestMatch ]; -+ newData[pixel + 1] = _data[nearestMatch + 1]; -+ newData[pixel + 2] = _data[nearestMatch + 2]; -+ } -+ } -+ -+ delete[] _data; -+ _data = newData; -+ _width = newWidth; -+ _height = newHeight; -+ -+ return true; -+}*/ -+ -+ -+ /* Stem alignment for bitmaps; A hack with very nice results */ -+ /* Ideally this could be implemented on the outline, prior to -+ * rasterization */ -+ static void -+ _lcd_stem_align ( FT_Bitmap* bitmap, -+ FT_Render_Mode mode, -+ FT_GlyphSlot slot ) -+ { -+ /*FT_Byte* weights = library->lcd_weights;*/ -+ FT_UInt width = (FT_UInt)bitmap->width; -+ FT_UInt height = (FT_UInt)bitmap->rows; -+ -+ FT_UInt h; -+ -+ FT_UInt alignment_type = 0; -+ FT_UInt checked_alignment_type = 0; -+ float pseudo_gamma_value = 1; -+ float pseudo_gamma_lt = 0; -+ FT_UInt checked_pseudo_gamma_value = 0; -+ -+ if ( checked_alignment_type == 0) -+ { -+ char *alignment_type_env = getenv( "INFINALITY_FT_STEM_ALIGNMENT_TYPE" ); -+ if ( alignment_type_env != NULL ) -+ { -+ /*sscanf ( alignment_type_env, "%d", &alignment_type );*/ -+ if (strcasecmp(alignment_type_env, "full") == 0) alignment_type = 1; -+ else if (strcasecmp(alignment_type_env, "medium") == 0) alignment_type = 2; -+ else if (strcasecmp(alignment_type_env, "medium1") == 0) alignment_type = 2; -+ else if (strcasecmp(alignment_type_env, "slight") == 0) alignment_type = 3; -+ else if (strcasecmp(alignment_type_env, "slight1") == 0) alignment_type = 3; -+ else if (strcasecmp(alignment_type_env, "medium2") == 0) alignment_type = 4; -+ else if (strcasecmp(alignment_type_env, "slight2") == 0) alignment_type = 5; -+ else if (strcasecmp(alignment_type_env, "infinality") == 0) alignment_type = 6; -+ else if (strcasecmp(alignment_type_env, "infinality1") == 0) alignment_type = 6; -+ else alignment_type = 0; -+ -+ if ( /*strstr(slot.metrics->root.scaler.face->style_name, "Regular") -+ || strstr(slot.metrics->root.scaler.face->style_name, "Book") -+ || strstr(slot.metrics->root.scaler.face->style_name, "Medium") -+ ||*/ strcasestr(slot->face->style_name, "Italic") -+ || strcasestr(slot->face->style_name, "Oblique") ) -+ alignment_type = 0; -+ if ( strcasestr(slot->face->style_name, "Bold") ) -+ alignment_type = 0; -+ } -+ checked_alignment_type = 1; -+ } -+ -+ if ( checked_pseudo_gamma_value == 0 ) -+ { -+ char *pseudo_gamma_value_env = getenv( "INFINALITY_FT_PSEUDO_GAMMA" ); -+ if ( pseudo_gamma_value_env != NULL ) -+ { -+ float f1, f2; -+ -+ if ( strcasecmp(pseudo_gamma_value_env, "default" ) != 0) -+ { -+ sscanf ( pseudo_gamma_value_env, "%f %f", &f1, &f2 ); -+ pseudo_gamma_lt = f1; -+ pseudo_gamma_value = f2; -+ } -+ if ( pseudo_gamma_value < .1 ) pseudo_gamma_value = 1; -+ if ( pseudo_gamma_lt < 0 ) pseudo_gamma_lt = 1; -+ } -+ checked_pseudo_gamma_value = 1; -+ } -+ -+ /*printf("%s,%s ", slot->face->family_name, slot->face->style_name);*/ -+ /*printf("%d ", slot->face->size->metrics.x_ppem);*/ -+ -+ /* set gamma value to 1 if out of range */ -+ if ( slot->face->size->metrics.x_ppem >= pseudo_gamma_lt ) -+ { -+ pseudo_gamma_value = 1; -+ } -+ -+ /* don't do alignment for < 10 */ -+ if ( slot->face->size->metrics.x_ppem < 10 ) -+ { -+ alignment_type = 0; -+ } -+ -+ if ( mode == FT_RENDER_MODE_LCD ) -+ { -+ if (width >= 4 && alignment_type != 0 ) -+ { -+ FT_Byte* line = bitmap->buffer; -+ FT_Byte* lineabove = bitmap->buffer; -+ FT_Byte* linebelow = bitmap->buffer; -+ -+ FT_UInt vsums[width], vtotals[width], offsetruns[width / 2][width/2]; -+ FT_UInt offsetrank[width/2], offsetchosen, stemwidths[width], stemwidthsmax; -+ FT_UInt stemwidth, vstems = 0; -+ -+ FT_UInt shift = 0; -+ FT_UInt xx; -+ -+ FT_ULong rtotal = 0, vweight = 0, wtotal = 0; -+ FT_UInt lreached = 0, rreached = 0, rr = 0, ll = 0, testwidth; -+ FT_UInt lwidth = 0, loffset = 0, offset = 0, htotal = 0, windowstart; -+ FT_UInt windowelement; -+ -+ line = bitmap->buffer; -+ rreached = 0; lreached = width, ll = width; -+ -+ lwidth = 0; -+ loffset = 0; -+ -+ -+ /* initialize variables - can this be done inline??? */ -+ for ( testwidth = 3; testwidth < 4; testwidth += 1 ) -+ { -+ for ( offset = 0; offset < 3; offset +=1 ) -+ { -+ offsetruns[offset][testwidth] = 0; -+ offsetrank[offset] = 0; -+ } -+ } -+ for ( xx = 0; xx < width; xx += 1 ) -+ { -+ stemwidths[xx] = 0; -+ } -+ -+ -+ for ( h = (FT_UInt)bitmap->rows; h > 0; h--, line += bitmap->pitch ) -+ { -+ -+ if (rr > rreached) rreached = rr; -+ if (ll < lreached) lreached = ll; -+ -+ rr = width; -+ ll = 0; -+ rtotal = 0; -+ htotal = 0; -+ -+ /*stemwidthsmax = 0;*/ -+ stemwidth = 0; -+ -+ -+ /* Calculate various sums and stem widths of glyph */ -+ for ( xx = 0; xx < width; xx += 1 ) -+ { -+ if (line[xx] >= 128) -+ { -+ stemwidth += 1; -+ /*if (stemwidth > stemwidthsmax) stemwidthsmax = stemwidth;*/ /* necessary ? */ -+ } -+ else -+ { -+ if (xx > 0 && line[xx - 1] >= 128) stemwidths[stemwidth] += 1; -+ stemwidth = 0; -+ } -+ -+ if (h == (FT_UInt)bitmap->rows) vsums[xx] = 0; -+ if ( h == (FT_UInt)bitmap->rows ) vtotals[xx] = 0; -+ -+ if (line[xx] == 0) vsums[xx] -= 255; -+ else vsums[xx] += line[xx]; -+ if (vsums[xx] < 0) vsums[xx] = 0; -+ -+ if (ll == 0 && line[xx] != 0) ll = (xx); -+ -+ if (line[xx] != 0) rr = (xx); -+ -+ if (xx < width / 2) vweight -= line[xx]; -+ else vweight += line[xx]; -+ -+ htotal += line [xx]; -+ vtotals[xx] += line[xx]; -+ } -+ -+ if ( h < (FT_UInt)bitmap->rows ) lineabove = line - bitmap->pitch; -+ if ( h > 1 ) linebelow = line + bitmap->pitch; -+ -+ -+ /* Determine the offset at which the most weight of the glyph exists */ -+ /* This is currently hard-coded at 3, but the code is here to adjust */ -+ for ( testwidth = 3; testwidth < 4; testwidth += 1 ) -+ { -+ /* test the widths at each of these offsets */ -+ for ( offset = 0; offset < 3; offset +=1 ) -+ { -+ /* test window of size testwidth, starting at offset */ -+ rtotal = 0; -+ for ( windowstart = offset; windowstart < width; -+ windowstart += testwidth ) -+ { -+ /* calculate total for this window */ -+ wtotal = 0; -+ for ( windowelement = windowstart; -+ windowelement < windowstart + testwidth; windowelement += 1 ) -+ if ( windowelement < width) -+ { -+ wtotal += line[windowelement]; -+ -+ /* Assign extra value to this subpixel under certain conditions */ -+ if ( line[windowelement] == 255 ) -+ { -+ /* favor if full pixels above and below */ -+ if ( h < (FT_UInt)bitmap->rows -+ && lineabove[windowelement] == 255 ) -+ wtotal += 10; -+ if ( h > 1 && linebelow[windowelement] == 255 ) -+ wtotal += 10; -+ -+ /* favor if full pixels next to them */ -+ if ( windowelement > 0 && line[windowelement-1] == 255 ) -+ { -+ wtotal += 10; -+ if ( windowelement > 1 && line[windowelement-2] == 255 ) -+ { -+ wtotal += 10; -+ if ( windowelement > 2 && line[windowelement-3] == 255 ) -+ wtotal += 10; -+ } -+ } -+ if ( windowelement < width - 1 && line[windowelement+1] == 255 ) -+ { -+ wtotal += 10; -+ if ( windowelement < width - 2 && line[windowelement+2] == 255 ) -+ { -+ wtotal += 10; -+ if ( windowelement < width - 3 && line[windowelement+3] == 255 ) -+ wtotal += 10; -+ } -+ } -+ } -+ } -+ /* divide window total by number of subpixel samples */ -+ /* add to total for this run */ -+ rtotal += (wtotal * wtotal) / testwidth; -+ } -+ /* dont count horizontal stems */ -+ /*if (rtotal < ( 255 * testwidth ) * (255 * testwidth) * (width / testwidth) / (testwidth * 2) )*/ -+ if ( rtotal < ( 255 * 255 * width / 2 ) ) -+ offsetruns[offset][testwidth] += rtotal; -+ } -+ -+ /* determine the best offset for this width and increment its counter */ -+ offsetchosen = 0; -+ for ( offset = 0; offset < 2; offset +=1 ) -+ { -+ if ( offsetruns[offset][testwidth] < offsetruns[offset + 1][testwidth] ){ -+ offsetrank[offset + 1] += 1; -+ offsetchosen = offset; -+ } -+ } -+ if (offsetchosen == 0) offsetrank[0] += 1; -+ } -+ } -+ -+ /* Use the best offset */ -+ loffset = 0; -+ for ( offset = 0; offset < 2; offset +=1 ) -+ { -+ if ( offsetrank[offset] < offsetrank[offset + 1] ){ -+ loffset = offset + 1; -+ } -+ } -+ -+ /* Use the best width */ -+ lwidth = 0; -+ stemwidthsmax = 0; -+ -+ for ( xx = 0; xx < width - 1; xx +=1 ) -+ { -+ if ( stemwidthsmax < stemwidths[xx + 1] ){ -+ lwidth = xx + 1; -+ stemwidthsmax = stemwidths[xx + 1]; -+ } -+ } -+ -+ /* currently unused */ -+ rreached = width - rreached; -+ -+ /* Set the number of vertical stem components */ -+ for ( xx = 0; xx < width; xx += 1 ) -+ { -+ if ( height > 0 && vsums[xx] / height > 110 ) -+ vstems++; -+ } -+ -+ -+ /******************** CALCULATE GLYPH ALIGNMENT *********************/ -+ /*printf(" %d,%d,%d,%d,%d,%d,%d\n", width, height, lreached, -+ rreached, lwidth,vstems,alignment_type );*/ -+ -+ shift = 0; -+ -+ /* infinality1 alignment - combination of below */ -+ if ( alignment_type == 6 ) -+ { -+ if ( lwidth < 5 ) alignment_type = 2; -+ else alignment_type = 1; -+ } -+ -+ /* strong alignment - shift glyph left or right one subpixel */ -+ if ( alignment_type == 1 /*&& vstems > 0*/ ) -+ { -+ if ( lwidth < 5) -+ { -+ /* lower widths should use this */ -+ if (loffset % 3 == 0) shift = -1; -+ if (loffset % 3 == 1) shift = 1; -+ if (loffset % 3 == 2) shift = 0; -+ } -+ else if ( lwidth < 6 ) -+ { -+ /* medium widths should use this */ -+ if (loffset % 3 == 0) shift = 1; -+ if (loffset % 3 == 1) shift = 0; -+ if (loffset % 3 == 2) shift = -1; -+ } -+ else if ( lwidth < 20 ) -+ { -+ /* higher widths should use this */ -+ if (loffset % 3 == 0) shift = 1; -+ if (loffset % 3 == 1) shift = -1; -+ if (loffset % 3 == 2) shift = 0; -+ } -+ } -+ -+ /* medium alignment - shift glyph ONLY LEFT one subpixel -+ * - a compromise to prevent spacing issues */ -+ else if ( alignment_type == 2 /*&& vstems > 0*/ ){ -+ -+ if ( lwidth < 5 ) -+ { -+ /* medium alignment - use next highest value instead */ -+ if ( loffset == 1 && offsetrank[0] > offsetrank[2] ) loffset = 0; -+ -+ if ( loffset % 3 == 0 ) shift = -1; -+ /*if (loffset % 3 == 1 ) shift = 1;*/ -+ if ( loffset % 3 == 2 ) shift = 0; -+ } -+ else if (lwidth < 6 ) -+ { -+ /* medium alignment - use next highest value instead */ -+ if ( loffset == 0 && offsetrank[2] > offsetrank[1] ) loffset = 2; -+ /*if (loffset % 3 == 0 ) shift = 1;*/ -+ if ( loffset % 3 == 1 ) shift = 0; -+ if ( loffset % 3 == 2 ) shift = -1; -+ } -+ else if ( lwidth < 20 ) -+ { -+ /* medium alignment - use next highest value instead */ -+ if ( loffset == 0 && offsetrank[1] > offsetrank[2] ) loffset = 1; -+ /*if (loffset % 3 == 0 ) shift = 1;*/ -+ if ( loffset % 3 == 1 ) shift = -1; -+ if ( loffset % 3 == 2 ) shift = 0; -+ } -+ } -+ -+ /* medium alignment 2 - shift glyph ONLY RIGHT one subpixel -+ * - a compromise to prevent spacing issues */ -+ else if ( alignment_type == 4 ){ -+ if ( lwidth < 5 ) -+ { -+ /* medium alignment - use next highest value instead */ -+ if ( loffset == 0 && offsetrank[1] > offsetrank[2] ) loffset = 1; -+ -+ /*if ( loffset % 3 == 0 ) shift = -1;*/ -+ if ( loffset % 3 == 1 ) shift = 1; -+ if ( loffset % 3 == 2 ) shift = 0; -+ } -+ else if ( lwidth < 6 ) -+ { -+ /* medium alignment - use next highest value instead */ -+ if ( loffset == 2 && offsetrank[0] > offsetrank[1] ) loffset = 0; -+ if ( loffset % 3 == 0 ) shift = 1; -+ if ( loffset % 3 == 1 ) shift = 0; -+ /*if ( loffset % 3 == 2 ) shift = -1;*/ -+ } -+ else if ( lwidth < 20 ) -+ { -+ /* medium alignment - use next highest value instead */ -+ if ( loffset == 1 && offsetrank[0] > offsetrank[2] ) loffset = 0; -+ if ( loffset % 3 == 0 ) shift = 1; -+ /*if (loffset % 3 == 1 ) shift = -1;*/ -+ if ( loffset % 3 == 2 ) shift = 0; -+ } -+ } -+ -+ /* light alignment - shift glyph ONLY LEFT one subpixel -+ * - a compromise to prevent spacing issues */ -+ else if ( alignment_type == 3 ){ -+ if ( lwidth < 5 ) -+ { -+ if ( loffset % 3 == 0 ) shift = -1; -+ /*if ( loffset % 3 == 1 ) shift = 1;*/ -+ if ( loffset % 3 == 2 ) shift = 0; -+ } -+ else if ( lwidth < 6 ) -+ { -+ /*if ( loffset % 3 == 0 ) shift = 1;*/ -+ if ( loffset % 3 == 1 ) shift = 0; -+ if ( loffset % 3 == 2 ) shift = -1; -+ } -+ else if ( lwidth < 20 ) -+ { -+ /*if ( loffset % 3 == 0 ) shift = 1;*/ -+ if ( loffset % 3 == 1 ) shift = -1; -+ if ( loffset % 3 == 2 ) shift = 0; -+ } -+ } -+ -+ /* light alignment 2 - shift glyph ONLY RIGHT one subpixel -+ * - a compromise to prevent spacing issues */ -+ else if ( alignment_type == 5 ){ -+ if ( lwidth < 5 ) -+ { -+ /*if ( loffset % 3 == 0 ) shift = -1;*/ -+ if ( loffset % 3 == 1 ) shift = 1; -+ if ( loffset % 3 == 2 ) shift = 0; -+ } -+ else if ( lwidth < 6 ) -+ { -+ if ( loffset % 3 == 0 ) shift = 1; -+ if ( loffset % 3 == 1 ) shift = 0; -+ /*if ( loffset % 3 == 2 ) shift = -1;*/ -+ } -+ else if ( lwidth < 20 ) -+ { -+ if ( loffset % 3 == 0 ) shift = 1; -+ /*if ( loffset % 3 == 1 ) shift = -1;*/ -+ if ( loffset % 3 == 2 ) shift = 0; -+ } -+ } -+ -+ /******************** ALIGN GLYPHS *********************/ -+ if (shift == -1) -+ { -+ line = bitmap->buffer; -+ for ( height = (FT_UInt)bitmap->rows; height > 0; height--, -+ line += bitmap->pitch ) -+ { -+ FT_UInt xx; -+ -+ for ( xx = 0; xx < width - 1; xx += 1 ) -+ { -+ line[xx] = line[xx+1]; -+ } -+ line[width - 1] = 1; -+ } -+ } -+ -+ else if (shift == -2) -+ { -+ line = bitmap->buffer; -+ for ( height = (FT_UInt)bitmap->rows; height > 0; height--, -+ line += bitmap->pitch ) -+ { -+ FT_UInt xx; -+ -+ for ( xx = 0; xx < width - 2; xx += 1 ) -+ { -+ line[xx] = line[xx+2]; -+ } -+ line[width - 2] = 1; -+ line[width - 1] = 1; -+ } -+ } -+ else if (shift == 1) -+ { -+ line = bitmap->buffer; -+ for ( height = (FT_UInt)bitmap->rows; height > 0; height--, -+ line += bitmap->pitch ) -+ { -+ FT_UInt xx; -+ -+ for ( xx = width - 1; xx > 0; xx -= 1 ) -+ { -+ line[xx] = line[xx-1]; -+ } -+ line[0] = 1; -+ } -+ } -+ else if (shift == 2) -+ { -+ line = bitmap->buffer; -+ for ( height = (FT_UInt)bitmap->rows; height > 0; height--, -+ line += bitmap->pitch ) -+ { -+ FT_UInt xx; -+ -+ for ( xx = width; xx > 1; xx -= 1 ) -+ { -+ line[xx] = line[xx-2]; -+ } -+ line[0] = 1; -+ line[1] = 1; -+ } -+ } -+ } -+ -+ if ( pseudo_gamma_value != 1 ) -+ { -+ FT_Byte* line = bitmap->buffer; -+ float ppem = (float)slot->face->size->metrics.x_ppem; -+ -+ if (ppem >= 5 ) -+ for (height = (FT_UInt)bitmap->rows; height > 0; height--, line += bitmap->pitch ) -+ { -+ FT_UInt xx; -+ -+ for ( xx = 0; xx < width; xx += 1 ) -+ { -+ /*normal*/ -+ /*line[xx] = gamma2 ( line[xx], pseudo_gamma_value );*/ -+ -+ /* sloped */ -+ /*line[xx] = gamma2 ( line[xx], pseudo_gamma_value - 5 -+ * (1-pseudo_gamma_value)/(pseudo_gamma_lt -5) -+ + ((1-pseudo_gamma_value)/(pseudo_gamma_lt -5)) * ppem );*/ -+ -+ /* 1/3-sloped */ -+ line[xx] = gamma2 ( line[xx], pseudo_gamma_value - 5 -+ * ((1-pseudo_gamma_value)/(3*(pseudo_gamma_lt -5))) -+ * + ((1-pseudo_gamma_value)/(3*(pseudo_gamma_lt -5))) * ppem ); -+ } -+ } -+ } -+ } -+ } -+ -+ -+ -+ -+ -+ - /* define USE_LEGACY to implement the legacy filter */ - #define USE_LEGACY - -@@ -287,9 +1017,31 @@ - { 0x00, 0x55, 0x56, 0x55, 0x00 }; - /* the values here sum up to a value larger than 256, */ - /* providing a cheap gamma correction */ -- static const FT_Byte default_filter[5] = -+ static FT_Byte default_filter[5] = - { 0x10, 0x40, 0x70, 0x40, 0x10 }; - -+ int checked_filter_params_env = 0; -+ -+ if ( checked_filter_params_env == 0 ) -+ { -+ char *filter_params = getenv( "INFINALITY_FT_FILTER_PARAMS" ); -+ if ( filter_params != NULL ) -+ { -+ float f1, f2, f3, f4, f5; -+ -+ if ( strcasecmp(filter_params, "default" ) != 0) -+ { -+ sscanf ( filter_params, "%f %f %f %f %f", &f1, &f2, &f3, &f4, &f5 ); -+ -+ default_filter[0] = (FT_Byte) (f1 * 255.0f + 0.5f); -+ default_filter[1] = (FT_Byte) (f2 * 255.0f + 0.5f); -+ default_filter[2] = (FT_Byte) (f3 * 255.0f + 0.5f); -+ default_filter[3] = (FT_Byte) (f4 * 255.0f + 0.5f); -+ default_filter[4] = (FT_Byte) (f5 * 255.0f + 0.5f); -+ } -+ } -+ checked_filter_params_env = 1; -+ } - - if ( !library ) - return FT_Err_Invalid_Argument; -@@ -304,17 +1056,20 @@ - case FT_LCD_FILTER_DEFAULT: - #if defined( FT_FORCE_LEGACY_LCD_FILTER ) - -+ library->lcd_stem_align_func = _lcd_stem_align; - library->lcd_filter_func = _ft_lcd_filter_legacy; - library->lcd_extra = 0; - - #elif defined( FT_FORCE_LIGHT_LCD_FILTER ) - -+ library->lcd_stem_align_func = _lcd_stem_align; - ft_memcpy( library->lcd_weights, light_filter, 5 ); - library->lcd_filter_func = _ft_lcd_filter_fir; - library->lcd_extra = 2; - - #else - -+ library->lcd_stem_align_func = _lcd_stem_align; - ft_memcpy( library->lcd_weights, default_filter, 5 ); - library->lcd_filter_func = _ft_lcd_filter_fir; - library->lcd_extra = 2; -@@ -325,6 +1080,7 @@ - - case FT_LCD_FILTER_LIGHT: - ft_memcpy( library->lcd_weights, light_filter, 5 ); -+ library->lcd_stem_align_func = _lcd_stem_align; - library->lcd_filter_func = _ft_lcd_filter_fir; - library->lcd_extra = 2; - break; -@@ -332,6 +1088,7 @@ - #ifdef USE_LEGACY - - case FT_LCD_FILTER_LEGACY: -+ library->lcd_stem_align_func = _lcd_stem_align; - library->lcd_filter_func = _ft_lcd_filter_legacy; - library->lcd_extra = 0; - break; -diff -Nur freetype-2.4.3.orig/src/base/ftobjs.c freetype-2.4.3.new/src/base/ftobjs.c ---- freetype-2.4.3.orig/src/base/ftobjs.c 2010-08-06 13:02:15.000000000 -0500 -+++ freetype-2.4.3.new/src/base/ftobjs.c 2010-11-14 15:43:02.906303324 -0600 -@@ -562,6 +562,45 @@ - FT_Bool autohint = FALSE; - FT_Module hinter; - -+ TT_Face face2=(TT_Face)face; -+ int checked_auto_autohint_env; -+ FT_Bool auto_autohint = FALSE; -+ -+ if ( !checked_auto_autohint_env ) -+ { -+ char *auto_autohint_env = getenv( "INFINALITY_FT_AUTO_AUTOHINT" ); -+ if ( auto_autohint_env != NULL ) -+ { -+ if ( strcasecmp(auto_autohint_env, "default" ) != 0 ) -+ { -+ if ( strcasecmp(auto_autohint_env, "true") == 0) auto_autohint = TRUE; -+ else if ( strcasecmp(auto_autohint_env, "1") == 0) auto_autohint = TRUE; -+ else if ( strcasecmp(auto_autohint_env, "on") == 0) auto_autohint = TRUE; -+ else if ( strcasecmp(auto_autohint_env, "yes") == 0) auto_autohint = TRUE; -+ } -+ } -+ checked_auto_autohint_env = 1; -+ } -+/*printf("%d,%d ", load_flags, FT_LOAD_TARGET_NORMAL); -+10000001000101000 -+0#define FT_LOAD_DEFAULT 0x0 -+0#define FT_LOAD_NO_SCALE 0x1 -+0#define FT_LOAD_NO_HINTING 0x2 -+1#define FT_LOAD_RENDER 0x4 -+0#define FT_LOAD_NO_BITMAP 0x8 -+1#define FT_LOAD_VERTICAL_LAYOUT 0x10 -+0#define FT_LOAD_FORCE_AUTOHINT 0x20 -+0#define FT_LOAD_CROP_BITMAP 0x40 -+0#define FT_LOAD_PEDANTIC 0x80 -+1#define FT_LOAD_ADVANCE_ONLY 0x100 -+0#define FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH 0x200 -+0#define FT_LOAD_NO_RECURSE 0x400 -+0#define FT_LOAD_IGNORE_TRANSFORM 0x800 -+0#define FT_LOAD_MONOCHROME 0x1000 -+0#define FT_LOAD_LINEAR_DESIGN 0x2000 -+0#define FT_LOAD_SBITS_ONLY 0x4000 -+1#define FT_LOAD_NO_AUTOHINT 0x8000U -+*/ - - if ( !face || !face->size || !face->glyph ) - return FT_Err_Invalid_Face_Handle; -@@ -627,8 +666,11 @@ - - - if ( mode == FT_RENDER_MODE_LIGHT || -- face->internal->ignore_unpatented_hinter ) -+ face->internal->ignore_unpatented_hinter || -+ ( auto_autohint && face2->max_profile.maxSizeOfInstructions == 0 ) ) -+ { - autohint = TRUE; -+ } - } - } - -diff -Nur freetype-2.4.3.orig/src/base/ftoutln.c freetype-2.4.3.new/src/base/ftoutln.c ---- freetype-2.4.3.orig/src/base/ftoutln.c 2010-06-27 08:03:58.000000000 -0500 -+++ freetype-2.4.3.new/src/base/ftoutln.c 2010-11-14 09:06:38.779916717 -0600 -@@ -888,6 +888,28 @@ - FT_Int c, n, first; - FT_Int orientation; - -+ int checked_enhanced_embolden_env = 0; -+ FT_Bool enhanced_embolden = FALSE; -+ -+ if ( checked_enhanced_embolden_env == 0 ) -+ { -+ char *enhanced_embolden_env = getenv( "INFINALITY_FT_ENHANCED_EMBOLDEN" ); -+ if ( enhanced_embolden_env != NULL ) -+ { -+ if ( strcasecmp(enhanced_embolden_env, "default" ) != 0 ) -+ { -+ if ( strcasecmp(enhanced_embolden_env, "true") == 0) -+ enhanced_embolden = TRUE; -+ else if ( strcasecmp(enhanced_embolden_env, "1") == 0) -+ enhanced_embolden = TRUE; -+ else if ( strcasecmp(enhanced_embolden_env, "on") == 0) -+ enhanced_embolden = TRUE; -+ else if ( strcasecmp(enhanced_embolden_env, "yes") == 0) -+ enhanced_embolden = TRUE; -+ } -+ } -+ checked_enhanced_embolden_env = 1; -+ } - - if ( !outline ) - return FT_Err_Invalid_Argument; -@@ -957,7 +979,8 @@ - } - - outline->points[n].x = v_cur.x + strength + in.x; -- outline->points[n].y = v_cur.y + strength + in.y; -+ if ( !enhanced_embolden ) -+ outline->points[n].y = v_cur.y + strength + in.y; - - v_prev = v_cur; - v_cur = v_next; -diff -Nur freetype-2.4.3.orig/src/base/ftsynth.c freetype-2.4.3.new/src/base/ftsynth.c ---- freetype-2.4.3.orig/src/base/ftsynth.c 2010-09-11 01:28:32.000000000 -0500 -+++ freetype-2.4.3.new/src/base/ftsynth.c 2010-11-14 09:19:16.860168106 -0600 -@@ -88,9 +88,28 @@ - FT_Error error; - FT_Pos xstr, ystr; - -+ int checked_enhanced_embolden_env = 0; -+ FT_Bool enhanced_embolden = FALSE; -+ -+ if ( checked_enhanced_embolden_env == 0 ) -+ { -+ char *enhanced_embolden_env = getenv( "INFINALITY_FT_EMBOLDEN_MAINTAIN_WIDTH" ); -+ if ( enhanced_embolden_env != NULL ) -+ { -+ if ( strcasecmp(enhanced_embolden_env, "default" ) != 0 ) -+ { -+ if ( strcasecmp(enhanced_embolden_env, "true") == 0) enhanced_embolden = TRUE; -+ else if ( strcasecmp(enhanced_embolden_env, "1") == 0) enhanced_embolden = TRUE; -+ else if ( strcasecmp(enhanced_embolden_env, "on") == 0) enhanced_embolden = TRUE; -+ else if ( strcasecmp(enhanced_embolden_env, "yes") == 0) enhanced_embolden = TRUE; -+ } -+ } -+ checked_enhanced_embolden_env = 1; -+ } -+ - - if ( slot->format != FT_GLYPH_FORMAT_OUTLINE && -- slot->format != FT_GLYPH_FORMAT_BITMAP ) -+ slot->format != FT_GLYPH_FORMAT_BITMAP ) - return; - - /* some reasonable strength */ -@@ -108,7 +127,7 @@ - xstr = xstr * 2; - ystr = xstr; - } -- else /* slot->format == FT_GLYPH_FORMAT_BITMAP */ -+ else if ( slot->format == FT_GLYPH_FORMAT_BITMAP ) - { - /* round to full pixels */ - xstr &= ~63; -@@ -146,7 +165,8 @@ - slot->metrics.width += xstr; - slot->metrics.height += ystr; - slot->metrics.horiBearingY += ystr; -- slot->metrics.horiAdvance += xstr; -+ /* Don't add any horiAdvance - Personal preference */ -+ if ( !enhanced_embolden ) slot->metrics.horiAdvance += xstr; - slot->metrics.vertBearingX -= xstr / 2; - slot->metrics.vertBearingY += ystr; - slot->metrics.vertAdvance += ystr; -diff -Nur freetype-2.4.3.orig/src/smooth/ftsmooth.c freetype-2.4.3.new/src/smooth/ftsmooth.c ---- freetype-2.4.3.orig/src/smooth/ftsmooth.c 2010-08-09 19:47:47.000000000 -0500 -+++ freetype-2.4.3.new/src/smooth/ftsmooth.c 2010-11-07 11:17:08.693652341 -0600 -@@ -283,6 +283,9 @@ - vec->y /= 3; - } - -+ if ( slot->library->lcd_stem_align_func ) -+ slot->library->lcd_stem_align_func ( bitmap, mode, slot ); -+ - if ( slot->library->lcd_filter_func ) - slot->library->lcd_filter_func( bitmap, mode, slot->library ); |