Attached.
What about TT_LOADER_SET_PP in ttgload.c? Should we always use the
Infinality version?
>From 67e1f371fd6b6e9110997ba57a2fff3323857512 Mon Sep 17 00:00:00 2001
From: Nikolaus Waxweiler <madig...@gmail.com>
Date: Thu, 17 Mar 2016 21:45:28 +0100
Subject: [PATCH 1/2] Prepare landing of v38 bytecode interpreter
Modern TrueType fonts are usually rendered through Microsoft's
collection of rendering techniques called ClearType (e.g. subpixel
rendering and subpixel hinting). When ClearType was introduced, most
fonts were not ready. Microsoft decided to implement a backwards
compatibility mode that employed several simple to complicated
assumptions and tricks that modified the interpretation of the bytecode
contained in these fonts to make them look ClearType-y somehow. Most
(web)fonts that were released since then have come to rely on these
hacks to render correctly, even some of Microsoft's flagship ClearType
fonts (Calibri, Cambria, Segoe UI).
FreeType employs a small list of font-agnostic hacks to bludgeon
non-native-ClearType fonts (except tricky ones[1]) into submission.
FreeType will not try to toggle hacks for specific fonts for performance
and complexity reasons. The focus is on modern (web)fonts rather than
legacy fonts that were made for black-and-white rendering.
Major hacks:
- Any point movement on the X-axis will be ignored (cf. Direct_Move()
and Direct_Move_X()). This has the smallest code footprint and single
biggest effect. The ClearType way to increase resolution is
supersampling the x-axis, the FreeType way is ignoring instuctions on
the x-axis, which gives the same result in the majority of cases.
- Points will not be moved post-IUP, except the x-component of diagonal
moves post-IUP (cf. Direct_Move(), Direct_Move_Y(), Move_Zp2_Point()).
Post-IUP changes are commonly used to "fix" pixel patterns which has
little use outside monochrome rendering.
- SHPIX and DELTAP will not execute unless moving a composite on the
Y-axis or moving a previously Y-touched point. SHPIX will additionally
deny movement on the X-axis (c.f. Ins_SHPIX() and Ins_DELTAP()). Both
instructions are commonly used to "fix" pixel patterns for monochrome
or Windows's GDI rendering but make little sense for FreeType
rendering. Both can distort the outline. See [2] for details.
- The hdmx table and modifications to phantom points are ignored.
Bearings and advance widths remain unchanged (except rounding them
outside the interpreter!). C.f. compute_glyph_metrics() and
TT_Hint_Glyph(). Letting non-native-ClearType fonts modify spacing
might mess up spacing.
Minor hacks:
- All rounding instructions are turned into Round_None if the freedom
vector is parallel to the X-axis (c.f. Round_*()). Given ClearType's
virtual increase of resolution on the X-axis, rounding to the physical
pixel grid there doesn't make much sense. Native ClearType fonts know
this, the rest (where backwards compatibility applies) may or may not.
- SHP will deny movement on the X-axis (c.f. Ins_SHP()). Prevents dents.
- FLIPRGON, FLIPRGOFF and FLIPPT will not execute post-IUP. This
prevents dents in e.g. Arial-Regular's 'D' and 'G' at various sizes.
- MSIRP, MIAP, MDRP and MIRP will see a control value cut-in and minimum
distance of 0 if the freedom vector is parallel to the X-axis (c.f.
Ins_MSIRP(), Ins_MIAP(), Ins_MDRP() and Ins_MIRP()). See [2] for
details.
Post-IUP is the state after both IUP[x] and IUP[y] have been executed.
The best results are achieved for fonts that were from the outset
designed with ClearType in mind, meaning they leave the X-axis mostly
alone and don't mess with the "final" outline to produce more pleasing
pixel patterns. The harder the designer tried to produce very specific
patterns ("superhinting") for pre-ClearType-display, the worse the
results.
Microsoft defines a way to turn off backwards compatibility and
interpret instructions as before ("native ClearType")[2][3]. The font
designer then regains full control and is responsible for making the
font work correctly with ClearType without any hand-holding by the
interpreter or rasterizer[4]. The v38 interpreter assumes backwards
compatibility by default, which can be turned off the same way by
executing the following in the control program:
#PUSH 4,3
INSTCTRL[]
(cf. Ins_INSTCTRL()).
[1]: Tricky fonts as FreeType defines them rely on the bytecode
interpreter to display correctly. Hacks can interfere with them, so
they get treated like native ClearType fonts (v38 with
backwards compatibility turned off). C.f. TT_RunIns().
[2]: Proposed by Microsoft's Greg Hitchcock in
https://www.microsoft.com/typography/cleartype/truetypecleartype.aspx
[3]: Beat Stamm describes it in more detail:
http://www.beatstamm.com/typography/RTRCh4.htm#Sec12
[4]: The list of "native ClearType" fonts is small at the time of this
writing, I found the following on a Windows 10 Update 1511
installation: Constantia, Corbel, Sitka, Malgun Gothic, Microsoft
JhengHei (Bold and UI Bold), Microsoft YaHei (Bold and UI Bold),
SimSun, NSimSun and Yu Gothic.
---
src/truetype/ttdriver.c | 5 +--
src/truetype/ttgload.c | 69 +++++++++++++++++++++++++++------
src/truetype/ttinterp.h | 100 +++++++++++++++++++++++++++++++++++++++++++++++-
src/truetype/ttobjs.c | 5 ---
4 files changed, 159 insertions(+), 20 deletions(-)
diff --git a/src/truetype/ttdriver.c b/src/truetype/ttdriver.c
index bbebabd..a856fed 100644
--- a/src/truetype/ttdriver.c
+++ b/src/truetype/ttdriver.c
@@ -72,11 +72,10 @@
FT_UInt* interpreter_version = (FT_UInt*)value;
-#ifndef TT_CONFIG_OPTION_SUBPIXEL_HINTING
- if ( *interpreter_version != TT_INTERPRETER_VERSION_35 )
+ if ( *interpreter_version != TT_INTERPRETER_VERSION_35 &&
+ *interpreter_version != TT_INTERPRETER_VERSION_38 )
error = FT_ERR( Unimplemented_Feature );
else
-#endif
driver->interpreter_version = *interpreter_version;
return error;
diff --git a/src/truetype/ttgload.c b/src/truetype/ttgload.c
index 4ab6603..5635303 100644
--- a/src/truetype/ttgload.c
+++ b/src/truetype/ttgload.c
@@ -815,11 +815,16 @@
#endif
- /* save glyph phantom points */
- loader->pp1 = zone->cur[zone->n_points - 4];
- loader->pp2 = zone->cur[zone->n_points - 3];
- loader->pp3 = zone->cur[zone->n_points - 2];
- loader->pp4 = zone->cur[zone->n_points - 1];
+ /* Save possibly modified glyph phantom points unless in v38 backwards
+ * compatibility mode, where no movement on the X-axis means no reason to
+ * change bearings or advance widths. */
+ if ( !loader->exec->backwards_compatibility )
+ {
+ loader->pp1 = zone->cur[zone->n_points - 4];
+ loader->pp2 = zone->cur[zone->n_points - 3];
+ loader->pp3 = zone->cur[zone->n_points - 2];
+ loader->pp4 = zone->cur[zone->n_points - 1];
+ }
#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
@@ -1969,10 +1974,14 @@
glyph->metrics.horiBearingY = bbox.yMax;
glyph->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
- /* adjust advance width to the value contained in the hdmx table */
- /* unless FT_LOAD_COMPUTE_METRICS is set */
- if ( !face->postscript.isFixedPitch &&
- IS_HINTED( loader->load_flags ) &&
+ /* Adjust advance width to the value contained in the hdmx table unless
+ * FT_LOAD_COMPUTE_METRICS is set or backwards compatibility mode of the
+ * v38 interpreter is active. Non-"native ClearType" fonts should be
+ * stopped from changing advance widths or spacing may suffer, "native
+ * ClearType" fonts are trusted to know what they're doing. */
+ if ( !( loader->exec && loader->exec->backwards_compatibility ) &&
+ !face->postscript.isFixedPitch &&
+ IS_HINTED( loader->load_flags ) &&
!( loader->load_flags & FT_LOAD_COMPUTE_METRICS ) )
{
FT_Byte* widthp;
@@ -2186,6 +2195,7 @@
TT_Face face;
FT_Stream stream;
+ TT_Driver driver;
#ifdef TT_USE_BYTECODE_INTERPRETER
FT_Bool pedantic = FT_BOOL( load_flags & FT_LOAD_PEDANTIC );
#endif
@@ -2193,6 +2203,7 @@
face = (TT_Face)glyph->face;
stream = face->root.stream;
+ driver = (TT_Driver)FT_FACE_DRIVER( face );
FT_MEM_ZERO( loader, sizeof ( TT_LoaderRec ) );
@@ -2203,6 +2214,8 @@
{
TT_ExecContext exec;
FT_Bool grayscale;
+ FT_Bool subpixel_hinting;
+ FT_Bool grayscale_cleartype;
#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
TT_Driver driver = (TT_Driver)FT_FACE_DRIVER( face );
@@ -2239,6 +2252,18 @@
if ( !exec )
return FT_THROW( Could_Not_Find_Context );
+ if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
+ {
+ subpixel_hinting = TRUE;
+ grayscale_cleartype = ! FT_BOOL( load_flags & FT_LOAD_TARGET_LCD ||
+ load_flags & FT_LOAD_TARGET_LCD_V );
+ exec->vertical_lcd = FT_BOOL( load_flags & FT_LOAD_TARGET_LCD_V );
+ } else {
+ subpixel_hinting = FALSE;
+ grayscale_cleartype = FALSE;
+ exec->vertical_lcd = FALSE;
+ }
+
#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
@@ -2299,8 +2324,8 @@
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
{
- grayscale = FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) !=
- FT_RENDER_MODE_MONO );
+ grayscale = FT_BOOL( ! subpixel_hinting &&
+ FT_LOAD_TARGET_MODE( load_flags ) != FT_RENDER_MODE_MONO );
}
error = TT_Load_Context( exec, face, size );
@@ -2338,6 +2363,28 @@
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
{
+ /* a change from mono to subpixel rendering (and vice versa) */
+ /* requires a re-execution of the CVT program */
+ if ( subpixel_hinting != exec->subpixel_hinting )
+ {
+ FT_TRACE4(( "tt_loader_init: subpixel hinting change,"
+ " re-executing `prep' table\n" ));
+
+ exec->subpixel_hinting = subpixel_hinting;
+ reexecute = TRUE;
+ }
+
+ /* a change from colored to grayscale subpixel rendering (and vice
+ * versa) requires a re-execution of the CVT program */
+ if ( grayscale_cleartype != exec->grayscale_cleartype )
+ {
+ FT_TRACE4(( "tt_loader_init: grayscale subpixel hinting change,"
+ " re-executing `prep' table\n" ));
+
+ exec->grayscale_cleartype = grayscale_cleartype;
+ reexecute = TRUE;
+ }
+
/* a change from mono to grayscale rendering (and vice versa) */
/* requires a re-execution of the CVT program */
if ( grayscale != exec->grayscale )
diff --git a/src/truetype/ttinterp.h b/src/truetype/ttinterp.h
index e5a02b9..930a82e 100644
--- a/src/truetype/ttinterp.h
+++ b/src/truetype/ttinterp.h
@@ -247,7 +247,105 @@ FT_BEGIN_HEADER
TT_Set_CVT_Func func_write_cvt; /* write a cvt entry (in pixels) */
TT_Set_CVT_Func func_move_cvt; /* incr a cvt entry (in pixels) */
- FT_Bool grayscale; /* are we hinting for grayscale? */
+ FT_Bool grayscale; /* Bi-level hinting and grayscale
+ rendering */
+
+ /* Modern TrueType fonts are usually rendered through Microsoft's
+ * collection of rendering techniques called ClearType (e.g. subpixel
+ * rendering and subpixel hinting). When ClearType was introduced, most
+ * fonts were not ready. Microsoft decided to implement a backwards
+ * compatibility mode that employed several simple to complicated
+ * assumptions and tricks that modified the interpretation of the bytecode
+ * contained in these fonts to make them look ClearType-y somehow. Most
+ * (web)fonts that were released since then have come to rely on these
+ * hacks to render correctly, even some of Microsoft's flagship ClearType
+ * fonts (Calibri, Cambria, Segoe UI).
+ *
+ * FreeType employs a small list of font-agnostic hacks to bludgeon
+ * non-native-ClearType fonts (except tricky ones[1]) into submission.
+ * FreeType will not try to toggle hacks for specific fonts for performance
+ * and complexity reasons. The focus is on modern (web)fonts rather than
+ * legacy fonts that were made for black-and-white rendering.
+ *
+ * Major hacks:
+ * - Any point movement on the X-axis will be ignored (cf. Direct_Move()
+ * and Direct_Move_X()). This has the smallest code footprint and single
+ * biggest effect.
+ * - Points will not be moved post-IUP, except the x-component of diagonal
+ * moves post-IUP (cf. Direct_Move(), Move_Zp2_Point()).
+ * - SHPIX and DELTAP will not execute unless moving a composite on the
+ * Y-axis or moving a previously Y-touched point. SHPIX will additionally
+ * deny movement on the X-axis (c.f. Ins_SHPIX() and Ins_DELTAP()).
+ * - The hdmx table and modifications to phantom points are ignored.
+ * Bearings and advance widths remain unchanged (except rounding them
+ * outside the interpreter!). C.f. compute_glyph_metrics() and
+ * TT_Hint_Glyph().
+ *
+ * Minor hacks:
+ * - All rounding instructions are turned into Round_None if the freedom
+ * vector is parallel to the X-axis (c.f. Round_*()).
+ * - SHP will deny movement on the X-axis (c.f. Ins_SHP())
+ * - FLIPRGON, FLIPRGOFF and FLIPPT will not execute post-IUP.
+ * - MSIRP, MIAP, MDRP and MIRP will see a control value cut-in and minimum
+ * distance of 0 if the freedom vector is parallel to the X-axis (c.f.
+ * Ins_MSIRP(), Ins_MIAP(), Ins_MDRP() and Ins_MIRP()).
+ *
+ * Post-IUP is the state after both IUP[x] and IUP[y] have been executed.
+ *
+ * The best results are achieved for fonts that were from the outset
+ * designed with ClearType in mind, meaning they leave the X-axis mostly
+ * alone and don't mess with the "final" outline to produce more pleasing
+ * pixel patterns. The harder the designer tried to produce very specific
+ * patterns ("superhinting") for pre-ClearType-display, the worse the
+ * results.
+ *
+ * Microsoft defines a way to turn off backwards compatibility and
+ * interpret instructions as before ("native ClearType")[2][3]. The font
+ * designer then regains full control and is responsible for making the
+ * font work correctly with ClearType without any hand-holding by the
+ * interpreter or rasterizer[4]. The v38 interpreter assumes backwards
+ * compatibility by default, which can be turned off the same way by
+ * executing the following in the control program:
+ *
+ * #PUSH 4,3
+ * INSTCTRL[]
+ *
+ * (cf. Ins_INSTCTRL()).
+ *
+ * [1]: Tricky fonts as FreeType defines them rely on the bytecode
+ * interpreter to display correctly. Hacks can interfere with them, so
+ * they get treated like native ClearType fonts (v38 with
+ * backwards compatibility turned off). C.f. TT_RunIns().
+ * [2]: Proposed by Microsoft's Greg Hitchcock in
+ * https://www.microsoft.com/typography/cleartype/truetypecleartype.aspx#Toc227035738
+ * [3]: Beat Stamm describes it in more detail:
+ * http://www.beatstamm.com/typography/RTRCh4.htm#Sec12
+ * [4]: The list of "native ClearType" fonts is small at the time of this
+ * writing, I found the following on a Windows 10 Update 1511
+ * installation: Constantia, Corbel, Sitka, Malgun Gothic, Microsoft
+ * JhengHei (Bold and UI Bold), Microsoft YaHei (Bold and UI Bold),
+ * SimSun, NSimSun and Yu Gothic.
+ */
+ FT_Bool subpixel_hinting; /* Using v38 implies this. */
+ FT_Bool vertical_lcd; /* long side of LCD subpixel */
+ /* rectangles is horizontal */
+
+ /* Defaults to true with v38 interpreter. If this is false, it implies the
+ * interpreter is in v35 or in native ClearType mode. */
+ FT_Bool backwards_compatibility;
+
+ /* Useful for detecting and denying post-iup trickery that is usually used
+ * to fix pixel patterns ("superhinting"). */
+ FT_Bool iupx_called;
+ FT_Bool iupy_called;
+
+ /* ClearType hinting and grayscale rendering, as used by Universal Windows
+ * Platform apps (Windows 8 and above). Like the standard colorful
+ * ClearType mode, it utilizes a vastly increased virtual resolution on the
+ * X-axis. Different from bi-level hinting and grayscale rendering, the
+ * old mode from Win9x days that roughly adheres to the physical pixel grid
+ * on both axes. */
+ FT_Bool grayscale_cleartype;
#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
TT_Round_Func func_round_sphn; /* subpixel rounding function */
diff --git a/src/truetype/ttobjs.c b/src/truetype/ttobjs.c
index a05f216..953931f 100644
--- a/src/truetype/ttobjs.c
+++ b/src/truetype/ttobjs.c
@@ -1286,12 +1286,7 @@
#ifdef TT_USE_BYTECODE_INTERPRETER
TT_Driver driver = (TT_Driver)ttdriver;
-
-#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
driver->interpreter_version = TT_INTERPRETER_VERSION_38;
-#else
- driver->interpreter_version = TT_INTERPRETER_VERSION_35;
-#endif
#else /* !TT_USE_BYTECODE_INTERPRETER */
--
2.5.0
>From eb85288d5f50a51eabbec94096160ff19516b301 Mon Sep 17 00:00:00 2001
From: Nikolaus Waxweiler <madig...@gmail.com>
Date: Thu, 17 Mar 2016 21:49:06 +0100
Subject: [PATCH 2/2] Implement v38 bytecode interpreter.
---
src/truetype/ttinterp.c | 230 ++++++++++++++++++++++++++++++++++++++++++++----
1 file changed, 214 insertions(+), 16 deletions(-)
diff --git a/src/truetype/ttinterp.c b/src/truetype/ttinterp.c
index ccbb1d7..7932d62 100644
--- a/src/truetype/ttinterp.c
+++ b/src/truetype/ttinterp.c
@@ -1642,6 +1642,10 @@
/* <InOut> */
/* zone :: The affected glyph zone. */
/* */
+ /* <Note> */
+ /* See ttinterp.h for details on backwards compatibility mode. Will */
+ /* `touch' the point. */
+ /* */
static void
Direct_Move( TT_ExecContext exc,
TT_GlyphZone zone,
@@ -1660,6 +1664,10 @@
( !exc->ignore_x_mode ||
( exc->sph_tweak_flags & SPH_TWEAK_ALLOW_X_DMOVE ) ) )
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
+ /* Exception to the post-IUP curfew: Allow the x-component of diagonal
+ * moves, but only post-IUP. DejaVu tries to adjust diagonal stems like
+ * on 'Z' and 'z' post-IUP. */
+ if ( !exc->backwards_compatibility )
zone->cur[point].x += FT_MulDiv( distance, v, exc->F_dot_P );
zone->tags[point] |= FT_CURVE_TAG_TOUCH_X;
@@ -1669,7 +1677,9 @@
if ( v != 0 )
{
- zone->cur[point].y += FT_MulDiv( distance, v, exc->F_dot_P );
+ if ( !( exc->backwards_compatibility &&
+ exc->iupx_called && exc->iupy_called ) )
+ zone->cur[point].y += FT_MulDiv( distance, v, exc->F_dot_P );
zone->tags[point] |= FT_CURVE_TAG_TOUCH_Y;
}
@@ -1720,6 +1730,7 @@
/* */
/* The following versions are used whenever both vectors are both */
/* along one of the coordinate unit vectors, i.e. in 90% of the cases. */
+ /* See ttinterp.h for details on backwards compatibility mode. */
/* */
/*************************************************************************/
@@ -1736,6 +1747,7 @@
if ( !SUBPIXEL_HINTING ||
!exc->ignore_x_mode )
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
+ if ( ! exc->backwards_compatibility )
zone->cur[point].x += distance;
zone->tags[point] |= FT_CURVE_TAG_TOUCH_X;
@@ -1750,7 +1762,9 @@
{
FT_UNUSED( exc );
- zone->cur[point].y += distance;
+ if ( !( exc->backwards_compatibility &&
+ exc->iupx_called && exc->iupy_called ) )
+ zone->cur[point].y += distance;
zone->tags[point] |= FT_CURVE_TAG_TOUCH_Y;
}
@@ -1853,6 +1867,9 @@
/* <Return> */
/* Rounded distance. */
/* */
+ /* <Note> */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ /* */
static FT_F26Dot6
Round_To_Grid( TT_ExecContext exc,
FT_F26Dot6 distance,
@@ -1860,8 +1877,9 @@
{
FT_F26Dot6 val;
- FT_UNUSED( exc );
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0 )
+ return Round_None( exc, distance, compensation );
if ( distance >= 0 )
{
@@ -1896,6 +1914,9 @@
/* <Return> */
/* Rounded distance. */
/* */
+ /* <Note> */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ /* */
static FT_F26Dot6
Round_To_Half_Grid( TT_ExecContext exc,
FT_F26Dot6 distance,
@@ -1903,8 +1924,9 @@
{
FT_F26Dot6 val;
- FT_UNUSED( exc );
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0 )
+ return Round_None( exc, distance, compensation );
if ( distance >= 0 )
{
@@ -1939,6 +1961,9 @@
/* <Return> */
/* Rounded distance. */
/* */
+ /* <Note> */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ /* */
static FT_F26Dot6
Round_Down_To_Grid( TT_ExecContext exc,
FT_F26Dot6 distance,
@@ -1946,8 +1971,9 @@
{
FT_F26Dot6 val;
- FT_UNUSED( exc );
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0 )
+ return Round_None( exc, distance, compensation );
if ( distance >= 0 )
{
@@ -1982,6 +2008,9 @@
/* <Return> */
/* Rounded distance. */
/* */
+ /* <Note> */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ /* */
static FT_F26Dot6
Round_Up_To_Grid( TT_ExecContext exc,
FT_F26Dot6 distance,
@@ -1989,8 +2018,9 @@
{
FT_F26Dot6 val;
- FT_UNUSED( exc );
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0 )
+ return Round_None( exc, distance, compensation );
if ( distance >= 0 )
{
@@ -2025,6 +2055,9 @@
/* <Return> */
/* Rounded distance. */
/* */
+ /* <Note> */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ /* */
static FT_F26Dot6
Round_To_Double_Grid( TT_ExecContext exc,
FT_F26Dot6 distance,
@@ -2032,8 +2065,9 @@
{
FT_F26Dot6 val;
- FT_UNUSED( exc );
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0 )
+ return Round_None( exc, distance, compensation );
if ( distance >= 0 )
{
@@ -2074,6 +2108,8 @@
/* the description of super round that we should add the compensation */
/* before rounding. */
/* */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ /* */
static FT_F26Dot6
Round_Super( TT_ExecContext exc,
FT_F26Dot6 distance,
@@ -2082,6 +2118,9 @@
FT_F26Dot6 val;
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0 )
+ return Round_None( exc, distance, compensation );
+
if ( distance >= 0 )
{
val = ( distance - exc->phase + exc->threshold + compensation ) &
@@ -2123,6 +2162,8 @@
/* There is a separate function for Round_Super_45() as we may need */
/* greater precision. */
/* */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ /* */
static FT_F26Dot6
Round_Super_45( TT_ExecContext exc,
FT_F26Dot6 distance,
@@ -2131,6 +2172,9 @@
FT_F26Dot6 val;
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0 )
+ return Round_None( exc, distance, compensation );
+
if ( distance >= 0 )
{
val = ( ( distance - exc->phase + exc->threshold + compensation ) /
@@ -5049,6 +5093,11 @@
if ( K == 3 )
exc->ignore_x_mode = FT_BOOL( L == 4 );
#endif
+ /* Native ClearType fonts sign a waiver that turns off all backwards
+ * compatibility hacks and lets them program points to the grid like it's
+ * 1996. They might sign a waiver for just one glyph though. */
+ if ( K == 3 )
+ exc->backwards_compatibility = ! FT_BOOL( L == 4 );
}
@@ -5133,6 +5182,10 @@
FT_UShort point;
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ if ( exc->backwards_compatibility && exc->iupx_called && exc->iupy_called )
+ goto Fail;
+
if ( exc->top < exc->GS.loop )
{
if ( exc->pedantic_hinting )
@@ -5179,6 +5232,10 @@
FT_UShort I, K, L;
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ if ( exc->backwards_compatibility && exc->iupx_called && exc->iupy_called )
+ return;
+
K = (FT_UShort)args[1];
L = (FT_UShort)args[0];
@@ -5208,6 +5265,10 @@
FT_UShort I, K, L;
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ if ( exc->backwards_compatibility && exc->iupx_called && exc->iupy_called )
+ return;
+
K = (FT_UShort)args[1];
L = (FT_UShort)args[0];
@@ -5267,6 +5328,7 @@
}
+ /* See ttinterp.h for details on backwards compatibility mode. */
static void
Move_Zp2_Point( TT_ExecContext exc,
FT_UShort point,
@@ -5276,14 +5338,18 @@
{
if ( exc->GS.freeVector.x != 0 )
{
- exc->zp2.cur[point].x += dx;
+ if ( !( exc->backwards_compatibility &&
+ exc->iupx_called && exc->iupy_called ) )
+ exc->zp2.cur[point].x += dx;
if ( touch )
exc->zp2.tags[point] |= FT_CURVE_TAG_TOUCH_X;
}
if ( exc->GS.freeVector.y != 0 )
{
- exc->zp2.cur[point].y += dy;
+ if ( !( exc->backwards_compatibility &&
+ exc->iupx_called && exc->iupy_called ) )
+ exc->zp2.cur[point].y += dy;
if ( touch )
exc->zp2.tags[point] |= FT_CURVE_TAG_TOUCH_Y;
}
@@ -5337,7 +5403,10 @@
Move_Zp2_Point( exc, point, 0, dy, TRUE );
else
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
- Move_Zp2_Point( exc, point, dx, dy, TRUE );
+ if ( exc->backwards_compatibility )
+ Move_Zp2_Point( exc, point, 0, dy, TRUE );
+ else
+ Move_Zp2_Point( exc, point, dx, dy, TRUE );
exc->GS.loop--;
}
@@ -5468,7 +5537,6 @@
FT_Int B1, B2;
#endif
-
if ( exc->top < exc->GS.loop + 1 )
{
if ( exc->pedantic_hinting )
@@ -5574,7 +5642,17 @@
#else /* !TT_CONFIG_OPTION_SUBPIXEL_HINTING */
- Move_Zp2_Point( exc, point, dx, dy, TRUE );
+ if ( exc->backwards_compatibility )
+ {
+ /* XXX: breaks Rokkitt < v1.2 (glyphs explode vertically on ALIGNRP).
+ */
+ if ( !( exc->iupx_called && exc->iupy_called ) &&
+ ( ( exc->is_composite && exc->GS.freeVector.y != 0 ) ||
+ ( exc->zp2.tags[point] & FT_CURVE_TAG_TOUCH_Y ) ) )
+ Move_Zp2_Point( exc, point, 0, dy, TRUE );
+ }
+ else
+ Move_Zp2_Point( exc, point, dx, dy, TRUE );
#endif /* !TT_CONFIG_OPTION_SUBPIXEL_HINTING */
@@ -5616,6 +5694,12 @@
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
+ FT_F26Dot6 control_value_cutin = exc->GS.control_value_cutin;
+
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0 )
+ control_value_cutin = 0;
+
point = (FT_UShort)args[0];
if ( BOUNDS( point, exc->zp1.n_points ) ||
@@ -5646,6 +5730,10 @@
distance = args[1];
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
+ if ( exc->backwards_compatibility &&
+ FT_ABS( distance - args[1] ) >= control_value_cutin )
+ distance = args[1];
+
exc->func_move( exc, &exc->zp1, point, args[1] - distance );
exc->GS.rp1 = exc->GS.rp0;
@@ -5738,6 +5826,10 @@
control_value_cutin = 0;
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0 )
+ control_value_cutin = 0;
+
if ( BOUNDS( point, exc->zp0.n_points ) ||
BOUNDSL( cvtEntry, exc->cvtSize ) )
{
@@ -5845,6 +5937,10 @@
minimum_distance = 0;
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0x0 )
+ minimum_distance = 0;
+
point = (FT_UShort)args[0];
if ( BOUNDS( point, exc->zp1.n_points ) ||
@@ -5998,6 +6094,10 @@
control_value_cutin = minimum_distance = 0;
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ if ( exc->backwards_compatibility && exc->GS.freeVector.y == 0x0 )
+ control_value_cutin = minimum_distance = 0;
+
/* XXX: UNDOCUMENTED! cvt[-1] = 0 always */
if ( BOUNDS( point, exc->zp1.n_points ) ||
@@ -6106,6 +6206,13 @@
}
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
+ if ( exc->backwards_compatibility &&
+ exc->GS.gep0 == exc->GS.gep1 )
+ {
+ if ( FT_ABS( cvt_dist - org_dist ) > control_value_cutin )
+ cvt_dist = org_dist;
+ }
+
distance = Round_None(
exc,
cvt_dist,
@@ -6324,6 +6431,7 @@
R.x = FT_MulDiv( val, dax, discriminant );
R.y = FT_MulDiv( val, day, discriminant );
+ /* XXX: Block in backwards_compatibility and/or post-IUP? */
exc->zp2.cur[point].x = exc->zp1.cur[a0].x + R.x;
exc->zp2.cur[point].y = exc->zp1.cur[a0].y + R.y;
}
@@ -6331,6 +6439,7 @@
{
/* else, take the middle of the middles of A and B */
+ /* XXX: Block in backwards_compatibility and/or post-IUP? */
exc->zp2.cur[point].x = ( exc->zp1.cur[a0].x +
exc->zp1.cur[a1].x +
exc->zp0.cur[b0].x +
@@ -6719,6 +6828,20 @@
FT_Short contour; /* current contour */
+ /* See ttinterp.h for details on backwards compatibility mode. Allow IUP
+ * until it has been called on both axes, immediately return on subsequent
+ * ones. */
+ if ( exc->backwards_compatibility )
+ {
+ if ( exc->iupx_called && exc->iupy_called )
+ return;
+
+ if ( exc->opcode & 1 )
+ exc->iupx_called = TRUE;
+ else
+ exc->iupy_called = TRUE;
+ }
+
/* ignore empty outlines */
if ( exc->pts.n_contours == 0 )
return;
@@ -6945,8 +7068,15 @@
}
else
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
-
- exc->func_move( exc, &exc->zp0, A, B );
+ /* See ttinterp.h for details on backwards compatibility mode. */
+ if ( exc->backwards_compatibility )
+ {
+ if ( !( exc->iupx_called && exc->iupy_called ) &&
+ ( ( exc->is_composite && exc->GS.freeVector.y != 0 ) ||
+ ( exc->zp0.tags[A] & FT_CURVE_TAG_TOUCH_Y ) ) )
+ exc->func_move( exc, &exc->zp0, A, B );
+ } else
+ exc->func_move( exc, &exc->zp0, A, B );
}
}
else
@@ -7063,9 +7193,11 @@
FT_Long* args )
{
FT_Long K;
+ TT_Driver driver;
K = 0;
+ driver = (TT_Driver)FT_FACE_DRIVER( exc->face );
#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
/********************************/
@@ -7091,7 +7223,7 @@
else
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
if ( ( args[0] & 1 ) != 0 )
- K = TT_INTERPRETER_VERSION_35;
+ K = driver->interpreter_version;
/********************************/
/* GLYPH ROTATED */
@@ -7110,13 +7242,65 @@
K |= 1 << 8;
/********************************/
- /* HINTING FOR GRAYSCALE */
+ /* BI-LEVEL HINTING AND */
+ /* GRAYSCALE RENDERING */
/* Selector Bit: 5 */
/* Return Bit(s): 12 */
/* */
if ( ( args[0] & 32 ) != 0 && exc->grayscale )
K |= 1 << 12;
+
+ if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 )
+ {
+ /********************************/
+ /* HINTING FOR SUBPIXEL */
+ /* Selector Bit: 6 */
+ /* Return Bit(s): 13 */
+ /* */
+ /* v38 will do subpixel hinting by default. */
+ if ( ( args[0] & 64 ) != 0 )
+ K |= 1 << 13;
+
+ /********************************/
+ /* VERTICAL LCD SUBPIXELS? */
+ /* Selector Bit: 8 */
+ /* Return Bit(s): 15 */
+ /* */
+ if ( ( args[0] & 256 ) != 0 && exc->vertical_lcd )
+ K |= 1 << 15;
+
+ /********************************/
+ /* SUBPIXEL POSITIONED? */
+ /* Selector Bit: 10 */
+ /* Return Bit(s): 17 */
+ /* */
+ /* XXX: FreeType supports it, dependant on what client does? */
+ if ( ( args[0] & 1024 ) != 0 )
+ K |= 1 << 17;
+
+ /********************************/
+ /* SYMMETRICAL SMOOTHING */
+ /* Selector Bit: 11 */
+ /* Return Bit(s): 18 */
+ /* */
+ /* The only smoothing method FreeType supports unless someone set
+ * FT_LOAD_TARGET_MONO. */
+ if ( ( args[0] & 2048 ) != 0 )
+ K |= 1 << 18;
+
+ /********************************/
+ /* CLEARTYPE HINTING AND */
+ /* GRAYSCALE RENDERING */
+ /* Selector Bit: 12 */
+ /* Return Bit(s): 19 */
+ /* */
+ /* Grayscale rendering is what FreeType does anyway unless someone set
+ * FT_LOAD_TARGET_MONO or FT_LOAD_TARGET_LCD(_V) */
+ if ( ( args[0] & 4096 ) != 0 && exc->grayscale_cleartype )
+ K |= 1 << 19;
+ }
+
#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
if ( SUBPIXEL_HINTING &&
@@ -7274,6 +7458,8 @@
FT_Long ins_counter = 0; /* executed instructions counter */
FT_UShort i;
+ TT_Driver driver = (TT_Driver)FT_FACE_DRIVER( exc->face );
+
#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
FT_Byte opcode_pattern[1][2] = {
/* #8 TypeMan Talk Align */
@@ -7291,6 +7477,18 @@
#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
exc->iup_called = FALSE;
#endif /* TT_CONFIG_OPTION_SUBPIXEL_HINTING */
+ /* Toggle backwards compatibility according to what font says, except when
+ * it's a 'tricky' font that heavily relies on the interpreter to render
+ * glyphs correctly, e.g. DFKai-SB. Backwards compatibility hacks may break
+ * it. */
+ if ( driver->interpreter_version == TT_INTERPRETER_VERSION_38 &&
+ !FT_IS_TRICKY( (&exc->face->root) ) )
+ exc->backwards_compatibility = ! (exc->GS.instruct_control & 4);
+ else
+ exc->backwards_compatibility = FALSE;
+
+ exc->iupx_called = FALSE;
+ exc->iupy_called = FALSE;
/* set PPEM and CVT functions */
exc->tt_metrics.ratio = 0;
--
2.5.0
_______________________________________________
Freetype-devel mailing list
Freetype-devel@nongnu.org
https://lists.nongnu.org/mailman/listinfo/freetype-devel
