blob: bca560b0f35168c808a6976800eee006ab07888d [file] [log] [blame]
CHANGES BETWEEN 2.10.1 and 2.10.2
- Support of WOFF2 fonts. This code contribution was Nikhil
Ramakrishnan's GSoC 2019 project.
- Function `FT_Get_Var_Axis_Flags' returned random data for Type 1
MM fonts.
- Type 1 fonts with non-integer metrics are now supported by the new
(CFF) engine introduced in FreeType 2.9.
- Drop support for Python 2 in Freetype's API reference generator
`docwriter' (Python >= 3.5 is required for targets `make refdoc'
and `make refdoc-venv').
- Auto-hinter support for Hanifi Rohingya and Medefaidrin.
- Document the `FT2_KEEP_ALIVE' debugging environment variable.
- The Visual C++ (and Visual C) project files for Windows builds no
longer generate libraries that contain the FreeType version in its
filenames. Instead, a resource file gets used to make the
libraries contain the corresponding information.
- The next release will remove Jam build support.
- The `ftbench' demo program has a new test for testing the
`FT_Glyph_Stroke' functionality.
CHANGES BETWEEN 2.10.0 and 2.10.1
- The bytecode hinting of OpenType variation fonts was flawed, since
the data in the `CVAR' table wasn't correctly applied.
- Auto-hinter support for Mongolian.
- For distribution, `.tar.bz2' packages are replaced with `.tar.xz'
- The handling of the default character in PCF fonts as introduced
in version 2.10.0 was partially broken, causing premature abortion
of charmap iteration for many fonts.
- If `FT_Set_Named_Instance' was called with the same arguments
twice in a row, the function returned an incorrect error code the
second time.
- Direct rendering using FT_RASTER_FLAG_DIRECT crashed (bug
introduced in version 2.10.0).
- Increased precision while computing OpenType font variation
- The flattening algorithm of cubic Bezier curves was slightly
changed to make it faster. This can cause very subtle rendering
changes, which aren't noticeable by the eye, however.
- The auto-hinter now disables hinting if there are blue zones
defined for a `style' (i.e., a certain combination of a script and
its related typographic features) but the font doesn't contain any
characters needed to set up at least one blue zone.
- The `ftmulti' demo program now supports multiple hidden axes with
the same name tag.
- `ftview', `ftstring', and `ftgrid' got a `-k' command line option
to emulate a sequence of keystrokes at start-up.
- `ftview', `ftstring', and `ftgrid' now support screen dumping to a
PNG file.
- The bytecode debugger, `ttdebug', now supports variation TrueType
fonts; a variation font instance can be selected with the new `-d'
command line option.
CHANGES BETWEEN 2.9.1 and 2.10.0
- A bunch of new functions has been added to access and process
COLR/CPAL data of OpenType fonts with color-layered glyphs.
Retrieve color palette data.
Select and activate a color palette for color-layered
Set text foreground color for palette index 0xFFFF.
Get color layers for a given glyph (using an interator
Blend one bitmap onto another with a given color.
- An experimental feature is the new behaviour of the
`FT_LOAD_COLOR' load flag for color-layered glyphs: Internally
it sets a flag so that if `FT_Render_Glyph' is called with
`FT_RENDER_MODE_NORMAL' (or `FT_Load_Glyph' with
`FT_LOAD_RENDER'), a default blending of the color glyph layers
will happen automatically for convenience.
- As a GSoC 2018 project, Nikhil Ramakrishnan completely
overhauled and modernized the API reference.
- The logic for computing the global ascender, descender, and
height of OpenType fonts has been slightly adjusted for
. If the `useTypoMetrics' flag (i.e., bit 7 in the `fsSelection'
field) in the `OS/2' table is set, use the `sTypo' fields in
`OS/2' unconditionally.
. Otherwise use the metrics data from the `hhea' table (if not
. Otherwise use the `sTypo' fields from the `OS/2' table (if not
. Otherwise use the `usWin' data from the `OS/2' table as a last
Variable fonts will apply the `MVAR' deltas to whichever metrics
were picked.
- `TT_Set_MM_Blend' could fail if call repeatedly with the same
- The precision of handling deltas in Variation Fonts has been
increased. The problem did only show up with multidimensional
- New function `FT_Library_SetLcdGeometry' to set up the geometry
of LCD subpixels.
- FreeType now uses the `defaultChar' property of PCF fonts to set
the glyph for the undefined character at glyph index 0 (as
FreeType already does for all other supported font formats). As
a consequence, the order of glyphs of a PCF font if accessed
with FreeType can be different now compared to previous
This change doesn't affect PCF font access with cmaps.
- `FT_Select_Charmap' has been changed to allow parameter value
`FT_ENCODING_NONE', which is valid for BDF, PCF, and Windows FNT
formats to access built-in cmaps that don't have a predefined
`FT_Encoding' value.
- A previously reserved field in the `FT_GlyphSlotRec' structure
now holds the glyph index.
- On Win32 platforms, the use of `_DLL' to build the library has
been replaced with `DLL_EXPORT' and `DLL_IMPORT'.
- The usual round of fuzzer bug fixes to better reject malformed
- `FT_Outline_New_Internal' and `FT_Outline_Done_Internal' have
been removed. These two functions were public by oversight only
and were never documented.
- A new function `FT_Error_String' returns descriptions of error
codes if configuration macro FT_CONFIG_OPTION_ERROR_STRINGS is
- `FT_Set_MM_WeightVector' and `FT_Get_MM_WeightVector' are new
functions limited to Adobe MultiMaster fonts to directly set and
get the weight vector.
- Support for Position Independent Code as needed by systems that
prohibit automatic address fixups, such as BREW, has been
removed. [Compilation with modern compilers that use flags like
`-fPIC' or `-fPIE' is not affected.]
- The `ftdump' demo program has new options `-c' and `-C' to
display charmaps in compact and detailed format, respectively.
Option `-V' has been removed.
- The `ftview', `ftstring', and `ftgrid' demo programs use a new
command line option `-d' to specify the program window's width,
height, and color depth.
- The `ftview' demo program now displays red boxes for zero-width
- `ftglyph' has limited support to display fonts with
color-layered glyphs. This will be improved later on.
- `ftgrid' can now display bitmap fonts also.
- The `ttdebug' demo program has a new option `-f' to select a
member of a TrueType collection (TTC).
- Other various improvements to the demo programs.
CHANGES BETWEEN 2.9 and 2.9.1
- Type 1 fonts containing flex features were not rendered
correctly (bug introduced in version 2.9).
- CVE-2018-6942: Older FreeType versions can crash with certain
malformed variation fonts.
- Bug fix: Multiple calls to `FT_Get_MM_Var' returned garbage.
- The base extensions `ftlcdfil' and `ftfntfmt' are now part of
the base module (and thus no longer configurable in file
- Emboldening of bitmaps didn't work correctly sometimes, showing
various artifacts (bug introduced in version 2.8.1).
- Use of the `freetype-config' script to get compilation and
linking options is deprecated since it doesn't support
cross-compiling, among other deficiencies. Instead, you should
use the `pkg-config' interface.
The `configure' script no longer installs `freetype-config' by
default. For backwards compatibility, a new configure option
`--enable-freetype-config' is provided that reverts this
- The auto-hinter script ranges have been updated for Unicode 11.
No support for new scripts have been added, however, with the
exception of Georgian Mtavruli.
- Support for cmake has been improved.
- The next release will remove support for Position Independent
Code as needed by systems that prohibit automatic address
fixups, such as BREW. [Compilation with modern compilers that
use flags like `-fPIC' or `-fPIE' is not affected.]
CHANGES BETWEEN 2.8.1 and 2.9
- Advance width values of variation fonts were often wrong.
- More fixes for variation font support; you should update to this
version if you want to support them.
- As a GSoC project, Ewald Hew extended the new (Adobe) CFF engine
to handle Type 1 fonts also, thus greatly improving the
rendering of this format. This is the new default. The old
engine is still available if the configuration macro
`T1_CONFIG_OPTION_OLD_ENGINE' gets defined; using the
`hinting-engine' property of the `type1' driver module you can
then switch between the two engines.
- A new function, `FT_Set_Named_Instance', can be used to set or
change the current named instance.
- Starting with this FreeType version, resetting variation
coordinates will return to the currently selected named
instance. Previously, FreeType returned to the base font (i.e.,
no instance set).
- The `face_flags' field of the `FT_Face' structure has a new bit,
`FT_FACE_FLAG_VARIATION', which is set if a variation font has
been altered with `FT_Set_MM_Design_Coordinates',
`FT_Set_Var_Design_Coordinates', or
- If the current face is a named instance, the new macro
`FT_IS_NAMED_INSTANCE' returns true.
- `FT_IS_VARIATION' is a new macro that returns true whenever a
face object has been altered by `FT_Set_MM_Design_Coordinates',
`FT_Set_Var_Design_Coordinates', or
- Changing the design coordinates of a variation font with
`FT_Set_Var_Design_Coordinates' or
`FT_Set_Var_Blend_Coordinates' does not influence the named
instance index value (only `FT_Set_Named_Instance' does that).
- Special PostScript names for named instances are only returned
if the named instance is set with `FT_Set_Named_Instance' (and
the font has corresponding entries in its `fvar' table). If
`FT_IS_VARIATION' returns true, the algorithmically derived
PostScript name is provided, not looking up special entries for
named instances.
- A new function `FT_Done_MM_Var' is provided to free the memory
returned in a call to `FT_Get_MM_Var'.
- On platforms using the `configure' script, the installed
`ftoption.h' file now correctly reflects configuration options
like `--with-harfbuzz'.
- Better support to build FreeType as a DLL on Windows using
Visual C.
- All data specific to driver modules is now collected in a single
file, `FT_DRIVER_H'. Consequently, the macros
and `FT_PCF_DRIVER_H' still work but are deprecated.
- Some fuzzer fixes to better reject malformed fonts.
- The `ftbench' demo program has a new test for opening a new face
and loading some glyphs.
- The `ftbench' demo program has a new option `-j' to specify the
last glyph index to be used in the tests.
- The `ftgrid' demo program has a new option `-n' to suppress
display of named instances of variation fonts.
- The `ttdebug' demo program can now show a stack trace (key `K')
and switch between hexadecimal and decimal display of integers
(key `I').
CHANGES BETWEEN 2.8 and 2.8.1
- B/W hinting of TrueType fonts didn't work properly if
interpreter version 38 or 40 was selected.
- Some severe problems within the handling of TrueType Variation
Fonts were found and fixed.
- Function `FT_Set_Var_Design_Coordinates' didn't correctly handle
the case with less input coordinates than axes.
- By default, FreeType now offers high quality LCD-optimized
output without resorting to ClearType techniques of resolution
tripling and filtering. In this method, called Harmony, each
color channel is generated separately after shifting the glyph
outline, capitalizing on the fact that the color grids on LCD
panels are shifted by a third of a pixel. This output is
indistinguishable from ClearType with a light 3-tap filter.
- Using the new function `FT_Get_Var_Axis_Flags', an application
can access the `flags' field of a variation axis (introduced in
OpenType version 1.8.2)
- More sanity checks.
- The internal representation of buffers for LCD rendering has
changed (to be more precise, the amount of padding gets computed
differently). Applications that use the FreeType API are not
- To reset all design axis values of a variation font to its
default values you can now say
error = FT_Set_Var_Design_Coordinates( face, 0, NULL );
This also works with functions `FT_Set_MM_Design_Coordinates'
and `FT_Set_MM_Blend_Coordinates'.
- FreeType now synthesizes a missing Unicode cmap for (older)
TrueType fonts also if glyph names are available.
- FreeType has improved handling of BDF fonts without the
`POINT_SIZE', `RESOLUTION_X', or `RESOLUTION_Y' properties; the
library now uses the values of the `SIZE' keyword if they are
missing. Previously, `SIZE' was completely ignored, and
FreeType used heuristic values instead.
- Multiple calls to `FT_Bitmap_Convert' do work now as advertised.
Previously, they failed with an assertion error if there was an
empty bitmap between non-empty ones.
- The warping option has moved from `light' to `normal' hinting
where it replaces the original hinting algorithm. The `light'
mode is now always void of any hinting in x-direction.
- 16bit compiler support is now officially ended. We didn't
provide any maintenance since many years, and given that there
were no error or problem reports either it seems that it is no
longer needed.
- The `ftgrid' demo program can now toggle the display of grid
lines with the `G' key.
- The `ftgrid' demo program can toggle a different set of colors
(suitable to color-blind people) with the `C' key.
- The `ftgrid' demo program now supports the `-e' command line
option to select a cmap.
- The `ftdump' demo program has a new command line option `-t' to
output the SFNT table list.
CHANGES BETWEEN 2.7.1 and 2.8
- Support for OpenType Variation Fonts is now complete. The last
missing part was handling the `VVAR' and `MVAR' tables, which is
available with this release.
- A new function `FT_Face_Properties' allows the control of some
module and library properties per font. Currently, the
following properties can be handled: stem darkening, LCD filter
weights, and the random seed for the `random' CFF operator.
- The PCF change to show more `colorful' family names (introduced
in version 2.7.1) was too radical; it can now be configured with
activated, it can be switched off at run time with the new pcf
property `no-long-family-names'. If the `FREETYPE_PROPERTIES'
environment variable is available, you can say
- Support for the following scripts has been added to the
Adlam, Avestan, Bamum, Buhid, Carian, Chakma, Coptic, Cypriot,
Deseret, Glagolitic, Gothic, Kayah, Lisu, N'Ko, Ol Chiki, Old
Turkic, Osage, Osmanya, Saurashtra, Shavian, Sundanese, Tai
Viet, Tifinagh, Unified Canadian Syllabics, Vai
- `Light' auto-hinting mode no longer uses TrueType metrics for
TrueType fonts. This bug was introduced in version 2.4.6,
causing horizontal scaling also. Almost all GNU/Linux
distributions (with Fedora as a notable exception) disabled the
corresponding patch for good reasons; chances are thus high that
you won't notice a difference.
If optical backward compatibility for legacy applications is
necessary, you might enable the AF_CONFIG_OPTION_TT_SIZE_METRICS
configuration option. However, it is strongly recommended to
avoid that, adjusting font sizes instead.
- Global size metrics values in the `FT_Size_Metrics' structure
can be different for TrueType fonts. Reason is that in older
FreeType versions the metrics were rounded differently to
integer pixels compared to all other font formats, yielding an
inconsistent behaviour if you used non-native hinting. Starting
with this version, global size metrics for TrueType fonts are
handled the same as other font formats: `ascender' gets rounded
up, `descender' gets rounded down, `height' gets normally
rounded, and `max_advance' gets normally rounded, too.
If you need more precise values of (global) ascender, descender,
height, or `max_advance', please take the corresponding values
from the `FT_Face' structure and scale them manually.
- If a TrueType font gets loaded with FT_LOAD_NO_HINTING, FreeType
now scales the font linearly again (bug introduced in version
- CVE-2017-8105, CVE-2017-8287: Older FreeType versions have
out-of-bounds writes caused by heap-based buffer overflows
related to Type 1 fonts.
- A new function `FT_Set_Default_Properties' has been added to
parse the `FREETYPE_PROPERTIES' environment variable
(previously, it was internal only). `FT_Init_FreeType' always
call this function, but `FT_New_Library' does not (similar to
- To be in sync with OpenType version 1.7 and newer, macros
are renamed to
The old macro names are deprecated (but still available).
- Support for SFNT `name' tables has been improved.
. Format 1 `name' tables are now supported. Use new function
`FT_Get_Sfnt_LangTag' to access associated language tags.
. Language, encoding, and name IDs have been updated to OpenType
version 1.8.1.
- The new CFF engine now handles the `random' operator. All CFF
opcodes are now supported.
- The CFF module has a new property `random-seed' to control the
pseudo-random number generation for the `random' operator.
- The `freetype-config' script is now a wrapper of `pkg-config' if
this program is available in the path.
this should provide better rendering results.
- A mode to display light auto-hinting with subpixel positioning
has been added to `ftdiff'.
CHANGES BETWEEN 2.7 and 2.7.1
- Support for the new CFF2 font format as introduced with OpenType
1.8 has been contributed by Dave Arnolds from Adobe.
- Preliminary support for variation fonts as specified in OpenType
1.8 (in addition to the already existing support for Adobe's MM
and Apple's GX formats). Dave Arnolds contributed handling of
advance width change variation; more will come in the next
- Handling of raw CID fonts was partially broken (bug introduced
in 2.6.4).
- CVE-2016-10328: Older FreeType versions had an out-of-bounds
write caused by a heap-based buffer overflow related to the CFF
- Some limits for TrueType bytecode execution have been tightened
to speed up FreeType's handling of malformed fonts, in
particular to quickly abort endless loops.
- The number of twilight points can no longer be set to an
arbitrarily large value.
- The total number of jump opcode instructions (like JMPR) with
negative arguments is dynamically restricted; the same holds
for the total number of iterations in LOOPCALL opcodes.
The dynamic limits are based on the number of points in a glyph
and the number of CVT entries. Please report if you encounter a
font where the selected values are not adequate.
- PCF family names are made more `colorful'; they now include the
foundry and information whether they contain wide characters.
For example, you no longer get `Fixed' but rather `Sony Fixed'
or `Misc Fixed Wide'.
- A new function `FT_Get_Var_Blend_Coordinates' (with its alias
name `FT_Get_MM_Blend_Coordinates') to retrieve the normalized
blend coordinates of the currently selected variation instance
has been added to the Multiple Masters interface.
- A new function `FT_Get_Var_Design_Coordinates' to retrieve the
design coordinates of the currently selected variation instance
has been added to the Multiple Masters interface.
- A new load flag `FT_LOAD_BITMAP_METRICS_ONLY' to retrieve bitmap
information without loading the (embedded) bitmap itself.
- Retrieving advance widths from bitmap strikes (using
`FT_Get_Advance' and `FT_Get_Advances') have been sped up.
- The usual round of fuzzer fixes to better reject malformed
- The `ftmulti' demo program can now switch engines with key `H'.
- The `ftstring' demo program can now show some built-in,
non-latin sample strings (to be selected with the TAB key).
- The `ftview' demo program can now switch between a font's
charmaps using the TAB key.
CHANGES BETWEEN 2.6.5 and 2.7
- As announced earlier, the 2.7.x series now uses the new subpixel
hinting mode as the default, emulating a modern version of
This change inevitably leads to different rendering results, and
configuration option to adapt it to your taste (or use the new
`FREETYPE_PROPERTIES' environment variable). See the
corresponding entry below for version 2.6.4, which gives more
introduced. If set (which is the default), an environment
variable `FREETYPE_PROPERTIES' can be used to control driver
properties. Example:
FREETYPE_PROPERTIES=truetype:interpreter-version=35 \
cff:no-stem-darkening=1 \
This allows to select, say, the subpixel hinting mode at runtime
for a given application. See file `ftoption.h' for more.
- After loading a named instance of a GX variation font, the
`face_index' value in the returned `FT_Face' structure now
correctly holds the named instance index in the upper 16bits as
- A new macro `FT_IS_NAMED_INSTANCE' to test whether a given face
is a named instance.
- More fixes to GX font handling.
- Apple's `GETVARIATION' bytecode operator (needed for GX
variation font support) has been implemented.
- Another round of fuzzer fixes, mainly to reject invalid fonts
- Handling of raw CID fonts was broken (bug introduced in version
- The smooth rasterizer has been streamlined to make it faster by
approx. 20%.
- The `ftgrid' demo program now understands command line option
`-d' to give start-up design coordinates.
- The `ftdump' demo program has a new command line option `-p' to
dump TrueType bytecode instructions.
CHANGES BETWEEN 2.6.4 and 2.6.5
- Compilation works again on Mac OS X (bug introduced in version
- The new subpixel hinting mode is now disabled by default; it
will be enabled by default in the forthcoming 2.7.x series.
Main reason for reverting this feature is the principle of least
surprise: a sudden change in appearance of all fonts (even if
the rendering improves for almost all recent fonts) should not
be expected in a new micro version of a series.
CHANGES BETWEEN 2.6.3 and 2.6.4
- A new subpixel hinting mode has been contributed by Nikolaus
Waxweiler, which is now the default rendering mode for TrueType
fonts. It implements (almost everything of) version 40 of the
bytecode engine.
The existing code base in FreeType (the `Infinality code') was
stripped to the bare minimum and all configurability removed in
the name of speed and simplicity. The configurability was
mainly aimed at legacy fonts like Arial, Times New Roman, or
Courier. [Legacy fonts are fonts that modify vertical stems to
achieve clean black-and-white bitmaps.] The new mode focuses on
applying a minimal set of rules to all fonts indiscriminately so
that modern and web fonts render well while legacy fonts render
Activation of the subpixel hinting support can be controlled
with the `TT_CONFIG_OPTION_SUBPIXEL_HINTING' configuration
option at compile time: If set to value 1, you get the old
Infinality mode (which was never the default due to its
slowness). Value 2 activates the new subpixel hinting mode, and
value 3 activates both. The default is value 2.
At run time, you can select the subpixel hinting mode with the
`interpreter-version' property (provided you have compiled in
the corresponding hinting mode); see `ftttdrv.h' for more.
- Support for the following scripts has been added to the
Armenian, Cherokee, Ethiopic, Georgian, Gujarati, Gurmukhi,
Malayalam, Sinhala, Tamil
- Type 42 fonts as created by LilyPond are now supported.
- Minor rendering improvements in the auto-hinter.
- For experimental reasons, the old CFF engine now supports all
CFF operators except `random', including the deprecated Multiple
Masters instructions. This allows the display of fonts like
`ITCGaramondMM-It.otf' (without font variations, though).
- Another round of fixes to improve handling of invalid fonts.
- The `ftgrid' demo program now displays the rendered pixels also;
this can be switched off with the `b' key. Selection of various
LCD filtering modes can be done with the `L' key.
- The demo programs have been extended to allow selection of all
available TrueType bytecode engines.
- A very early beta version of a new, Qt based demo program called
`ftinspect' is part of the source code bundle; it will
eventually supersede the other demo programs. Currently, you
have to compile it manually with `qmake; make'; note that many
features are still missing.
CHANGES BETWEEN 2.6.2 and 2.6.3
- Khmer, Myanmar, Bengali, and Kannada script support has been
added to the auto-hinter.
- Better support of Indic scripts like Devanagari by using a
top-to-bottom hinting flow.
- All FreeType macros starting with two underscores have been
renamed to avoid a violation of both the C and C++ standards.
Example: Header macros of the form `__FOO_H__' are now called
`FOO_H_'. In most cases, this should be completely transparent
to the user. The exception to this is `__FTERRORS_H__', which
must be sometimes undefined by the user to get FreeType error
strings: Both this form and the new `FTERRORS_H_' macro are
accepted for backward compatibility.
- Minor improvements mainly to the Type 1 driver.
- The new CFF engine now supports all Type 2 operators except
- The macro `_STANDALONE_', used for compiling the B/W and smooth
rasterizers as stand-alone modules, has been renamed to
`STANDALONE_', since macro names starting with an underscore and
followed by an uppercase letter are reserved in both C and C++.
- Function `FT_Library_SetLcdFilterWeights' now also activates
custom LCD filter weights (instead of just adjusting them).
- Support for `unpatented hinting' has been completely removed:
Consequently, the two functions `FT_Face_CheckTrueTypePatents'
and `FT_Face_SetUnpatentedHinting' now return always false,
doing nothing.
- The `ftgamma' demo program has been modernized; the gamma grid
display has been moved from `ftview' to this program.
- In `ftview', it is now possible to cycle through the available
LCD filtering modes.
CHANGES BETWEEN 2.6.1 and 2.6.2
- The auto-hinter now supports stem darkening, to be controlled by
the new `no-stem-darkening' and `darkening-parameters'
properties. This is an experimental feature contributed by
Nikolaus Waxweiler, and the interface might change in a future
- By default, stem darkening is now switched off (for both the CFF
engine and the auto-hinter). The main reason is that you need
linear alpha blending and gamma correction to get correct
rendering results, and the latter is not yet available in most
freely available rendering stacks like X11. Applying stem
darkening without proper gamma correction leads to far too dark
rendering results.
- The meaning of `FT_RENDER_MODE_LIGHT' has been slightly
modified. It now essentially means `no hinting along the
horizontal axis'; in particular, no change of glyph advance
widths. Consequently, the auto-hinter is used for all scalable
font formats except for CFF. It is planned that other
font-specific rendering engines (TrueType, Type 1) will follow.
- The default LCD filter has been changed to be normalized and
- For better compatibility with FontConfig, function
`FT_Library_SetLcdFilter' accepts a new enumeration value
`FT_LCD_FILTER_LEGACY1' (which has the same meaning as
- A large number of bugs have been detected by using the libFuzzer
framework, which should further improve handling of invalid
fonts. Thanks again to Kostya Serebryany and Bungeman!
option, controls the maximum number of executed opcodes within a
bytecode program. You don't want to change this except for very
special situations (e.g., making a library fuzzer spend less
time to handle broken fonts).
- The smooth renderer has been made faster.
- The `ftstring' demo program now supports subpixel rendering; use
key `l' to cycle through the LCD modes.
- The `ftstring' demo program now supports color rendering; use
the `space' key to cycle through various color combinations.
- The graphical demo programs now use a default gamma value of 1.8
(instead of 1.2).
CHANGES BETWEEN 2.6 and 2.6.1
- It turned out that for CFFs only the advance widths should be
taken from the `htmx' table, not the side bearings. This bug,
introduced in version 2.6.0, makes it necessary to upgrade if
you are using CFFs; otherwise, you get cropped glyphs with GUI
interfaces like GTK or Qt.
- Accessing Type 42 fonts returned incorrect results if the glyph
order of the embedded TrueType font differs from the glyph order
of the Type 42 charstrings table.
- The header file layout has been changed (again), moving all
header files except `ft2build.h' into a subdirectory tree.
Doing so reduces the possibility of header file name clashes
(e.g., FTGL's `FTGlyph.h' with FreeType's `ftglyph.h') on case
insensitive file systems like Mac OS X or Windows.
Applications that use (a) the `freetype-config' script or
FreeType's `freetype2.pc' file for pkg-config to get the include
directory for the compiler, and (b) the documented way for
header inclusion like
#include <ft2build.h>
#include FT_FREETYPE_H
don't need any change to the source code.
- Simple access to named instances in GX variation fonts is now
available (in addition to the previous method via FreeType's MM
interface). In the `FT_Face' structure, bits 16-30 of the
`face_index' field hold the current named instance index for the
given face index, and bits 16-30 of `style_flags' contain the
number of instances for the given face index. `FT_Open_Face'
and friends also understand the extended bits of the face index
You need to enable TT_CONFIG_OPTION_GX_VAR_SUPPORT for this new
feature. Otherwise, bits 16-30 of the two fields are zero (or
are ignored).
- Lao script support has been added to the auto-hinter.
- The auto-hinter's Arabic script support has been enhanced.
- Superscript-like and subscript-like glyphs as used by various
phonetic alphabets like the IPA are now better supported by the
- The TrueType bytecode interpreter now runs slightly faster.
- Improved support for builds with cmake.
- The function `FT_CeilFix' now always rounds towards plus
- The function `FT_FloorFix' now always rounds towards minus
- A new load flag `FT_LOAD_COMPUTE_METRICS' has been added; it
makes FreeType ignore pre-computed metrics, as needed by font
validating or font editing programs. Right now, only the
TrueType module supports it to ignore data from the `hdmx'
- Another round of bug fixes to better handle broken fonts, found
by Kostya Serebryany <>.
CHANGES BETWEEN 2.5.5 and 2.6
- Behdad Esfahbod contributed code for improved thread-safety,
which results in the following model.
* An `FT_Face' object can only be safely used from one thread at
a time.
* An `FT_Library' object can now be used without modification
from multiple threads at the same time.
* `FT_Face' creation and destruction with the same `FT_Library'
object can only be done from one thread at a time.
One can use a single `FT_Library' object across threads as long
as a mutex lock is used around `FT_New_Face' and `FT_Done_Face'.
Any calls to `FT_Load_Glyph' and similar API are safe and do not
need the lock to be held as long as the same `FT_Face' is not
used from multiple threads at the same time.
- Thai script support has been added to the auto-hinter.
- Arabic script support has been added to the auto-hinter.
- Following OpenType version 1.7, advance widths and side bearing
values in CFFs (wrapped in an SFNT structure) are now always
taken from the `hmtx' table.
- Following OpenType version 1.7, the PostScript font name of a
CFF font (wrapped in an SFNT structure) is now always taken from
the `name' table. This is also true for OpenType Collections
(i.e., TTCs using CFFs subfonts instead of TTFs), where it may
have a significant difference.
- Fonts natively hinted for ClearType are now supported, properly
handling selector index 3 of the INSTCTRL bytecode instruction.
- Major improvements to the GX TrueType variation font handling.
- A new auto-hinter property `warping' can switch on and off the
warping code if this experimental feature is compiled in (by
defining the AF_CONFIG_OPTION_USE_WARPER configuration option;
by default this option is now enabled but warping is switched
The AF_CONFIG_OPTION_USE_WARPER option itself is an old feature,
available since 2006. Warping only works in `light'
auto-hinting mode. The idea of the code is to slightly scale
and shift a glyph along the non-hinted dimension (which is
usually the horizontal axis) so that as much of its segments are
aligned (more or less) to the grid. To find out a glyph's
optimal scaling and shifting value, various parameter
combinations are tried and scored.
See file `ftautoh.h' for more; the demo programs `ftdiff',
`ftview', and `ftgrid' can toggle warping with key `w'.
- Some fields in the `FTC_ImageTypeRec' structure have been
changed from signed to unsigned type, which better reflects the
actual usage. It is also an additional means to protect against
malformed input.
This change doesn't break the ABI; however, it might cause
compiler warnings.
- Function `FT_Bitmap_New' has been renamed to `FT_Bitmap_Init',
since this name better reflects its function. For backward
compatibility, the old function name is still available.
- Function `FT_Get_X11_Font_Format' has been renamed to
`FT_Get_Font_Format', since this name better reflects its
function. For backward compatibility, the old function name is
still available.
Additionally, the header file macro for this function has been
renamed to `FT_FONT_FORMATS_H' (the old name `FT_XFREE86_H' is
retained for backward compatibility).
- Various improvements to the `ftgrid' demo program.
. It can now display GX and MM fonts while interactively
manipulating the axes (with keys F2, F3, and F4).
. Anti-aliasing rendering modes can now be selected (with keys
F5 and F6).
. The display of point numbers can be toggled with key `D'.
- Various improvements to the `ftdump' demo program.
. It now displays information on MM and GX variation axes.
. New command line option `-u' makes it output data in utf-8
- The `ftmulti' demo program can now handle up to six MM or GX
CHANGES BETWEEN 2.5.4 and 2.5.5
- Handling of uncompressed PCF files works again (bug introduced
in version 2.5.4).
CHANGES BETWEEN 2.5.3 and 2.5.4
- A variant of vulnerability CVE-2014-2240 was identified
(cf. and fixed in the
new CFF driver. All users should upgrade.
- The new auto-hinter code using HarfBuzz crashed for some invalid
- Many fixes to better protect against malformed input.
- Full auto-hinter support of the Devanagari script.
- Experimental auto-hinter support of the Telugu script.
- CFF stem darkening behaviour can now be controlled at build time
using the eight macros
- Some fields in the `FT_Bitmap' structure have been changed from
signed to unsigned type, which better reflects the actual usage.
It is also an additional means to protect against malformed
This change doesn't break the ABI; however, it might cause
compiler warnings.
- Improvements to the auto-hinter's algorithm to recognize stems
and local extrema.
- Function `FT_Get_SubGlyph_Info' always returned an error even in
case of success.
- Version 2.5.1 introduced major bugs in the cjk part of the
auto-hinter, which are now fixed.
- The `FT_Sfnt_Tag' enumeration values have been changed to
uppercase, e.g. `FT_SFNT_HEAD'. The lowercase variants are
deprecated. This is for orthogonality with all other
enumeration (and enumeration-like) values in FreeType.
- `cmake' now supports builds of FreeType as an OS X framework and
for iOS.
- Improved project files for vc2010, introducing a property file.
- The documentation generator for the API reference has been
updated to produce better HTML code (with proper CSS). At the
same time, the documentation got a better structure.
- The FT_LOAD_BITMAP_CROP flag is obsolete; it is not used by any
- The TrueType DELTAP[123] bytecode instructions now work in
subpixel hinting mode as described in the ClearType whitepaper
(i.e., for touched points in the non-subpixel direction).
- Many small improvements to the internal arithmetic routines.
CHANGES BETWEEN 2.5.2 and 2.5.3
- A vulnerability (CVE-2014-2240) was identified and fixed in the
new CFF driver (cf.
All users should upgrade.
- More bug fixes related to correct positioning of composite
- Many fixes to better protect against malformed input.
- FreeType can now use the HarfBuzz library to greatly improve the
auto-hinting of fonts that use OpenType features: Many glyphs
that are part of such features but don't have cmap entries are
now handled properly, for example small caps or superscripts.
Define the configuration macro FT_CONFIG_OPTION_USE_HARFBUZZ to
activate HarfBuzz support.
You need HarfBuzz version 0.9.19 or newer.
Note that HarfBuzz depends on FreeType; this currently causes a
chicken-and-egg problem that can be solved as follows in case
HarfBuzz is not yet installed on your system.
1. Compile and install FreeType without the configuration
2. Compile and install HarfBuzz.
3. Define macro FT_CONFIG_OPTION_USE_HARFBUZZ, then compile
and install FreeType again.
With FreeType's `configure' script the procedure boils down to
configure, build, and install FreeType, then configure, compile,
and install HarfBuzz, then configure, compile, and install
FreeType again (after executing `make distclean').
- All libraries FreeType depends on are now checked using the
`pkg-config' configuration files first, followed by alternative
- The new value `auto' for the various `--with-XXX' library
options (for example `--with-harfbuzz=auto') makes the
`configure' script automatically link to the libraries it finds.
This is now the default.
- In case FreeType's `configure' script can't find a library, you
can pass environment variables to circumvent pkg-config, and
those variables have been harmonized as a consequence of the
changes mentioned above:
LIBZ -> removed; use LIBZ_CFLAGS and LIBZ_LIBS
LIBBZ2 -> removed; use BZIP2_CFLAGS and BZIP2_LIBS
`./configure --help' shows all available environment variables.
- The `freetype-config' script now understands option `--static'
to emit static linking information.
CHANGES BETWEEN 2.5.1 and 2.5.2
- Improving the display of some broken TrueType fonts introduced a
bug that made FreeType crash on some popular (but not fully
conformant) fonts like `ahronbd.ttf'.
- Another round of improvements to correct positioning and hinting
of composite glyphs in TrueType fonts.
- Version 2.5.1 introduced a bug in handling embedded bitmap
strikes of TrueType fonts, causing garbage display under some
- The `ftgrid' demo program couldn't be compiled in
non-development builds.
CHANGES BETWEEN 2.5 and 2.5.1
- For some WinFNT files, the last glyph wasn't displayed but
incorrectly marked as invalid.
- The vertical size of glyphs was incorrectly set after a call to
`FT_GlyphSlot_Embolden', resulting in clipped glyphs.
- Many fields of the `PCLT' table in SFNT based fonts (if accessed
with `FT_Get_Sfnt_Table') were computed incorrectly.
- In TrueType fonts, hinting of composite glyphs could sometimes
deliver incorrect positions of components or even distorted
- WOFF font format support has been added.
- The auto-hinter now supports Hebrew. Greek and Cyrillic support
has been improved.
- Support for the forthcoming `OS/2' SFNT table version 5, as can
be found e.g. in the `Sitka' font family for Windows 8.1.
- The header file layout has been changed. After installation,
all files are now located in `<prefix>/include/freetype2'.
Applications that use (a) `freetype-config' or FreeType's
`pkg-config' file to get the include directory for the compiler,
and (b) the documented way for header inclusion like
#include <ft2build.h>
#include FT_FREETYPE_H
don't need any change to the source code.
- The stem darkening feature of the new CFF engine can now be
fine-tuned with the new `darkening-parameters' property.
- `ftgrid' has been updated to toggle various engines with the `H'
key, similar to `ftview' and `ftdiff'.
- The functionality of `ttdebug' has been greatly enhanced.
. It now displays twilight, storage, and control value data; key
`T' shows the twilight point table, key `S' the storage data,
and key `C' the control value table.
. Some keys have been reassigned from lowercase to their
uppercase equivalents; for example `q' to quit the program is
now `Q'.
. Key `f' finishes the current function.
. Key `R' restarts the debugger.
. Keys `b' and `p' set a breakpoint.
. Key `B' provides a function call backtrace.
- Better support of ARMv7 and x86_64 processors.
- Apple's `sbix' color bitmap format is now supported.
- Improved auto-hinter rendering for many TrueType fonts,
especially in the range 20-40ppem.
- A new face flag `FT_FACE_FLAG_COLOR' has been added (to be
accessed with the macro `FT_HAS_COLOR').
- `FT_Gzip_Uncompress' (modeled after zlib's `uncompress'
function) has been added; this is a by-product of the newly
added WOFF support.
- Support for a build with `cmake' has been contributed by John
Cary <>.
- Support for x64 builds with Visual C++ has been contributed by
Kenneth Miller <>
- Manual pages for most demo programs have been added.
- The GETINFO bytecode instruction for TrueType fonts was buggy if
used to retrieve subpixel hinting information. It was necessary
to set selector bit 6 to get results for selector bits 7-10,
which is wrong.
- Improved computation of emulated vertical metrics for TrueType
- Fixed horizontal start-up position of vertical phantom points in
TrueType bytecode.
CHANGES BETWEEN 2.4.12 and 2.5
- The cache manager function `FTC_Manager_Reset' didn't flush the
- Behdad Esfahbod (on behalf of Google) contributed support for
color embedded bitmaps (eg. color emoji).
A new load flag, FT_LOAD_COLOR, makes FreeType load color
embedded-bitmaps, following this draft specification
which defines two new SFNT tables, `CBDT' and `CBLC' (named and
modeled after `EBDT' and `EBLC', respectively). The color
bitmaps are stored in the new FT_PIXEL_MODE_BGRA format to
represent BGRA pre-multiplied sRGB images. If PNG support is
available, PNG color images as defined in the same proposed
specification are supported also.
Note that color bitmaps are converted to grayscale if client
didn't ask for color.
- As announced in the previous release, the old FreeType CFF
engine is now disabled by default. It can be conditionally
compiled by defining the configuration macro
- As announced in the previous release, all code related to macro
FT_CONFIG_OPTION_OLD_INTERNALS has been removed, thus becoming
- The property API (`FT_Property_Get' and `FT_Property_Set') is
now declared as stable.
The exception, however, are the experimental auto-hinter
properties `glyph-to-script-map' and `fallback-script' which are
subject to change in a forthcoming release.
- `ftview' has been updated to support color embedded bitmaps; it
can be toggled on and off with key `c'. The small cache toggle
is now key `K'.
- It is now possible to control the version of the TrueType
hinting engine using the new `interpreter-version' property of
the `truetype' module: Versions 35 and 38 (the default) are
supported, which roughly corresponds to disable and enable
subpixel hinting support, respectively.
In both `ftview' and `ftdiff', switching between the two
versions can be done with key `H'. In the `ftbench' demo
program, command line option `-H' has been extended to activate
the non-default interpreter version.
- The `ttdebug' program has been further improved. In particular,
it accepts a new command line option `-H' to select the hinting
- `ftdump's verbose option has been renamed to `-V'. For all demo
programs, `-v' now shows version information.
- Another round of TrueType subpixel hinting fixes.
- The `apinames' tool can now create an import file for NetWare.
- 64bit compilation of the new CFF engine was buggy.
- Some fixes to improve robustness in memory-tight situations.
CHANGES BETWEEN 2.4.11 and 2.4.12
- We have another CFF parsing and hinting engine! Written by Dave
Arnold <>, this work has been contributed by
Adobe in collaboration with Google. It is vastly superior to
the old CFF engine, and it will replace it in the next release.
Right now, it is still off by default, and you have to
explicitly select it using the new `hinting-engine' property of
the cff driver:
#include FT_MODULE_H
#include FT_CFF_DRIVER_H
FT_Library library;
int engine = FT_CFF_HINTING_ADOBE;
FT_Property_Set( library, "cff", "hinting-engine", &engine );
The code has a (mature) beta status; we encourage all users to
test it and report any problems.
In case you want to activate the new CFF engine unconditionally,
apply this patch:
--- snip ---
diff --git a/src/cff/cffobjs.c b/src/cff/cffobjs.c
index ebcf189..3f2ce6b 100644
--- a/src/cff/cffobjs.c
+++ b/src/cff/cffobjs.c
@@ -1056,7 +1056,7 @@
/* set default property values */
- driver->hinting_engine = FT_CFF_HINTING_FREETYPE;
+ driver->hinting_engine = FT_CFF_HINTING_ADOBE;
driver->no_stem_darkening = FALSE;
return FT_Err_Ok;
--- snip ---
- The macro FT_CONFIG_OPTION_OLD_INTERNALS is no longer set by
default. In the next release, we will completely remove the
associated code. Please update your programs in case you are
still using this macro.
- The (top-level) `configure' script now respects the MAKE
environment variable to specify a `make' binary. For backward
compatibility, GNUMAKE still overrides MAKE, though.
- The `ftview' and `ftdiff' demo programs have been redesigned,
showing more options permanently on the screen, among other
minor improvements.
- Using the `H' key, it is now possible to select the CFF engine
in both `ftview' and `ftdiff'.
- The new command line option `-H' for `ftbench' selects the Adobe
CFF engine.
- It is now possible to directly select the LCD rendering mode
with the keys `A'-`F' in `ftview'. The key mapping for cycling
through LCD modes has been changed from `K' and `L' to `k' and
`l', and toggling custom LCD filtering is no longer mapped to
key `F' but to key `L'.
- In `ftdiff', key `x' toggles between layout modes: Either use
the advance width (this is new and now the default) or the
bounding box information to determine line breaks.
- For all demo tools, the new command line option `-v' shows the
- For the demo tools with a GUI, the new command line options `-w'
and `-h' select the width and the height of the output window,
- The `ttdebug' program was broken and has been reactivated. Note
that this program is not compiled by default.
CHANGES BETWEEN 2.4.10 and 2.4.11
- Some vulnerabilities in the BDF implementation have been fixed.
Users of this font format should upgrade.
- Subpixel hinting support has been contributed by Infinality,
based on Greg Hitchcock's whitepaper at
Originally, it was a separate patch available from
and which has been integrated.
Note that ClearType support is not completely implemented! In
particular, full support for the options `compatible_widths',
`symmetrical_smoothing, and `bgr' (via the GETINFO bytecode
instruction) is missing.
Activation of subpixel hinting support can be controlled with
the `TT_CONFIG_OPTION_SUBPIXEL_HINTING' configuration option; it
is switched off by default. This feature is still experimental;
we welcome test reports!
- Support for OpenType collections (OTC) has been added.
- Pure CFF fonts within an SFNT wrapper are now supported.
- Minor rendering improvements to the auto-hinter.
- `FT_GlyphSlot_Oblique' now uses a shear angle of 12°.
- Experimental support to handle `property modules', for example
to control the behaviour of the auto-hinter. The API consists
of two new functions, `FT_Property_Set' and `FT_Property_Get'.
The code is still subject to change and should not be used for
- The `ftdiff' demo program now supports UTF-8 encoded input files
for option `-f'.
- Using keys `r' and `R', you can now adjust the stroker radius in
the `ftview' demo program.
- Other, minor fixes and improvements.
CHANGES BETWEEN 2.4.9 and 2.4.10
- Incremental glyph loading as needed by ghostscript was broken.
- A new function `FT_Outline_EmboldenXY', contributed by Alexei
- In the `ftview' demo program, key `e' has been replaced with `x'
and `y' to embolden in the horizontal and vertical direction,
- The glyph spacing computation in `FT_GlyphSlot_Embolden' (and
similar code in `ftview') has been improved.
- Minor improvements to the TrueType bytecode interpreter and
glyph loader, the auto-hinter, and the B/W rasterizer.
CHANGES BETWEEN 2.4.8 and 2.4.9
- Another round of fixes to better handle invalid fonts. Many of
them are vulnerabilities (see CVE-2012-1126 up to CVE-2012-1144
and SA48320) so all users should upgrade.
- The `ENCODING -1 <n>' format of BDF fonts is now supported.
- For BDF fonts, support for the whole Unicode encoding range has
been added.
- Better TTF support for x_ppem != y_ppem.
- `FT_Get_Advances' sometimes returned bogus values.
- The demo programs no longer recognize and handle default
suffixes; you now have to always specify the complete font name.
- Better rendering and LCD mode cycling added to `ftview'.
CHANGES BETWEEN 2.4.7 and 2.4.8
- Some vulnerabilities in handling CID-keyed PostScript fonts have
been fixed; see CVE-2011-3439.
- Chris Liddell contributed a new API, `FT_Get_PS_Font_Value', to
retrieve most of the dictionary keys in Type 1 fonts.
CHANGES BETWEEN 2.4.6 and 2.4.7
- Some vulnerabilities in handling Type 1 fonts have been fixed;
see CVE-2011-3256.
- FreeType now properly handles ZapfDingbats glyph names while
constructing a Unicode character map (for fonts which don't have
CHANGES BETWEEN 2.4.5 and 2.4.6
- For TrueType based fonts, the ascender and descender values were
incorrect sometimes (off by a pixel if the ppem value was not a
multiple of 5). Depending on the use you might now experience
a different layout; the change should result in better, more
consistent line spacing.
- Fix CVE-2011-0226 which causes a vulnerability while handling
Type 1 fonts.
- BDF fonts containing glyphs with negative values for ENCODING
were incorrectly rejected. This bug has been introduced in
FreeType version 2.2.0.
- David Bevan contributed a major revision of the FreeType stroker
. The behaviour of FT_STROKER_LINEJOIN_BEVEL has been corrected.
. A new line join style, FT_STROKER_LINEJOIN_MITER_FIXED, has
been introduced to support PostScript and PDF miter joins.
. FT_STROKER_LINEJOIN_MITER_VARIABLE has been introduced as an
. Various stroking glitches has been fixed.
- SFNT bitmap fonts which contain an outline glyph for `.notdef'
only no longer set the FT_FACE_FLAG_SCALABLE flag.
CHANGES BETWEEN 2.4.4 and 2.4.5
- A rendering regression for second-order Bézier curves has been
fixed, introduced in 2.4.3.
- If autohinting is not explicitly disabled, FreeType now uses
the autohinter if a TrueType based font doesn't contain native
- The load flag FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH has been made
redundant and is simply ignored; this means that FreeType now
ignores the global advance width value in TrueType fonts.
- `FT_Sfnt_Table_Info' can now return the number of SFNT tables of
a font.
- Support for PCF files compressed with bzip2 has been contributed
by Joel Klinghed. To make this work, the OS must provide a
bzip2 library.
- Bradley Grainger contributed project and solution files in
Visual Studio 2010 format.
- Again some fixes to better handle broken fonts.
- Some improvements to the B/W rasterizer.
- Fixes to the cache module to improve robustness.
- Just Fill Bugs contributed (experimental) code to compute blue
zones for CJK Ideographs, improving the alignment of horizontal
stems at the top or bottom edges.
- The `ftgrid' demo program can now display autohinter segments,
to be toggled on and off with key `s'.
CHANGES BETWEEN 2.4.3 and 2.4.4
- UVS support (TrueType/OpenType cmap format 14) support is fixed.
This regression has been introduced in version 2.4.0.
- Detect tricky fonts (e.g. MingLiU) by the lengths and checksums
of Type42-persistent subtables (`cvt ', `fpgm', and `prep') when
a TrueType font without family name is given. The previous fix,
introduced in 2.4.3, was too rigorous, causing many subsetted
fonts (mainly from PDF files) displayed badly because FreeType
forced rendering with the TrueType bytecode engine instead of
the autohinter.
- Better support for 64bit platforms.
- More fixes to improve handling of broken fonts.
CHANGES BETWEEN 2.4.2 and 2.4.3
- Fix rendering of certain cubic, S-shaped arcs. This regression
has been introduced in version 2.4.0.
- To fix the above mentioned rendering issue, a new spline
flattening algorithm has been introduced which speeds up both
conic and cubic arcs.
- Handling of broken fonts has been further improved.
CHANGES BETWEEN 2.4.1 and 2.4.2
- A stack overflow in CFF Type2 CharStrings interpreter is fixed.
- Handling Type 42 font deallocation was broken; additionally, the
library is now more robust against malformed Type 42 fonts.
- Two new functions, `FT_Reference_Library' (in FT_MODULE_H) and
`FT_Reference_Face' (in FT_FREETYPE_H), have been added to
simplify life-cycle management. A counter gets initialized to 1
at the time an FT_Library (or FT_Face) structure is created.
The two new functions increment the respective counter.
`FT_Done_Library' and `FT_Done_Face' then only destroy a library
or face if the counter is 1, otherwise they simply decrement the
CHANGES BETWEEN 2.4.0 and 2.4.1
- A serious bug in the CFF font module prevented display of many
glyphs in CFF fonts like `MinionPro-Regular.otf'.
CHANGES BETWEEN 2.3.12 and 2.4.0
- Since May 2010, all patents regarding the TrueType bytecode
interpreter have expired worldwide. Consequently, we now define
- A new function `FT_Library_SetLcdFilterWeights' is available to
adjust the filter weights set by `FT_Library_SetLcdFilter'.
- Thanks to many reports from Robert Święcki, FreeType's stability
in handling broken or damaged fonts is much improved.
- Support for LCD filter control has been added to the demo
programs `ftdiff' and `ftview'.
CHANGES BETWEEN 2.3.11 and 2.3.12
- For `FT_Open_Face', new parameters are available to ignore
preferred family names: FT_PARAM_TAG_IGNORE_PREFERRED_FAMILY and
- Support for incremental font loading (controlled with the
FT_CONFIG_OPTION_INCREMENTAL macro) is now active by default.
- Better support for vertical metrics.
- Various minor bug fixes.
CHANGES BETWEEN 2.3.10 and 2.3.11
- Version 2.3.10 broke PCF support.
CHANGES BETWEEN 2.3.10 and 2.3.9
- If all ASCII digits in a font have the same (unscaled) width,
the autohinter respects this and won't change it.
- TrueType fonts are now rasterized correctly if the horizontal
and vertical resolution differ.
- Type 1 fonts are now handled with increased precision internally
to avoid serious rounding issues if non-integral coordinates are
- Horizontally condensed CFF fonts (using the font matrix) were
rendered incorrectly. This bug has been introduced after
release 2.3.5.
- Support for the SFNT cmap 13 table format (as defined by the new
OpenType 1.6 specification) has been added.
- B/W rasterization of well-hinted TrueType fonts at small sizes
has been greatly improved.
- Calculation of vertical metrics in OpenType fonts has been
- It is now possible to change the emboldening factor in the
`ftview' demo program with keys `e' and `E'.
- It is now possible to change the slant value in the `ftview'
demo program with keys `s' and `S'.
- The 5-levels grayscale mode of the `ftraster' module (which
FreeType doesn't use by default) was broken since version 2.3.0.
- Compilation of the `ftgrays' and `ftraster' modules was broken
in stand-alone mode.
- Various fixes for compilation on 64bit and 16bit architectures.
CHANGES BETWEEN 2.3.9 and 2.3.8
- Very unfortunately, FreeType 2.3.8 contained a change that broke
its official ABI. The end result is that programs compiled
against previous versions of the library, but dynamically linked
to 2.3.8 can experience memory corruption if they call the
`FT_Get_PS_Font_Info' function.
We recommend all users to upgrade to 2.3.9 as soon as possible,
or to downgrade to a previous release of the library if this is
not an option.
The origin of the bug is that a new field was added to the
publicly defined `PS_FontInfoRec' structure. Unfortunately,
objects of this type can be stack or heap allocated by callers
of `FT_Get_PS_Font_Info', resulting in a memory buffer
overwrite with its implementation in 2.3.8.
If you want to know whether your code is vulnerable to this
issue, simply search for the substrings `PS_FontInfo' and
`PS_Font_Info' in your source code. If none is found, your code
is safe and is not affected.
The FreeType team apologizes for the problem.
- The POSIX support of MacOS resource-fork fonts (Suitcase fonts
and LaserWriter Type1 PostScript fonts) was broken in 2.3.8. If
FreeType2 is built without Carbon framework, these fonts are not
handled correctly. Version 2.3.7 didn't have this bug.
- `FT_Get_Advance' (and `FT_Get_Advances') returned bad values for
almost all font formats except TrueType fonts.
- Fix a bug in the SFNT kerning table loader/parser which could
crash the engine if certain malformed tables were encountered.
- Composite SFNT bitmaps are now handled correctly.
- The new functions `FT_Get_CID_Is_Internally_CID_keyed' and
`FT_Get_CID_From_Glyph_Index' can be used to access CID-keyed
CFF fonts via CID values. This code has been contributed by
Michael Toftdal.
- `FT_Outline_Get_InsideBorder' returns FT_STROKER_BORDER_RIGHT
for empty outlines. This was incorrectly documented.
- The `ftview' demo program now supports UTF-8 encoded strings.
CHANGES BETWEEN 2.3.8 and 2.3.7
- CID-keyed fonts in an SFNT wrapper were not handled correctly.
- The smooth renderer produced truncated images (on the right) for
outline parts with negative horizontal values. Most fonts don't
contain outlines left to the y coordinate axis, but the effect
was very noticeable for outlines processed with FT_Glyph_Stroke,
using thick strokes.
- `FT_Get_TrueType_Engine_Type' returned a wrong value if both
- The `face_index' field in the `FT_Face' structure wasn't
initialized properly after calling FT_Open_Face and friends with
a positive face index for CFFs, WinFNTs, and, most importantly,
for TrueType Collections (TTCs).
- Rudimentary support for Type 1 fonts and CID-keyed Type 1 fonts
in an SFNT wrapper has been added -- such fonts are used on the
Mac. The core SFNT tables `TYP1' and `CID ' are passed to the
PS Type 1 and CID-keyed PS font drivers; other tables (`ALMX',
`BBOX', etc.) are not supported yet.
- A new interface to extract advance values of glyphs without
loading their outlines has been added. The functions are called
`FT_Get_Advance' and `FT_Get_Advances'; they are defined in file
`ftadvanc.h' (to be accessed as FT_ADVANCES_H).
- A new function `FT_Get_FSType_Flags' (in FT_FREETYPE_H) has been
contributed by David Bevan to access the embedding and
subsetting restriction information of fonts.
- FT_MulFix is now an inlined function; by default, assembler code
is provided for x86 and ARM. See FT_CONFIG_OPTION_INLINE_MULFIX
and FT_CONFIG_OPTION_NO_ASSEMBLER (in ftoption.h) for more.
- The handling of `tricky' fonts (this is, fonts which don't work
with the autohinter, needing the font format's hinting engine)
has been generalized and changed slightly:
. A new face flag FT_FACE_FLAG_TRICKY indicates that the font
format's hinting engine is necessary for correct rendering.
The macro FT_IS_TRICKY can be used to check this flag.
. FT_LOAD_NO_HINTING is now ignored for tricky fonts. To really
force raw loading of such fonts (without hinting), both
this is something which you probably never want to do.
. Tricky TrueType fonts always use the bytecode interpreter,
either the patented or unpatented version.
- The function `FT_GlyphSlot_Own_Bitmap' has been moved from
FT_SYNTHESIS_H to FT_BITMAP_H; it is now part of the `official'
API. (The functions in FT_SYNTHESIS_H are still subject to
change, however.)
- In the `ftdiff' demo program you can now toggle the use of
CHANGES BETWEEN 2.3.7 and 2.3.6
- If the library was compiled on an i386 platform using gcc, and
compiler option -O3 was given, `FT_MulFix' sometimes returned
incorrect results which could have caused problems with
`FT_Request_Metrics' and `FT_Select_Metrics', returning an
incorrect descender size.
- Pure CFFs without subfonts were scaled incorrectly if the font
matrix was non-standard. This bug has been introduced in
version 2.3.6.
- The `style_name' field in the `FT_FaceRec' structure often
contained a wrong value for Type 1 fonts. This misbehaviour
has been introduced in version 2.3.6 while trying to fix
another problem. [Note, however, that this value is
informative only since the used algorithm to extract it is
very simplistic.]
- Two new macros, FT_OUTLINE_SMART_DROPOUTS and
FT_OUTLINE_EXCLUDE_STUBS, have been introduced. Together with
FT_OUTLINE_IGNORE_DROPOUTS (which was ignored previously) it is
now possible to control the dropout mode of the `raster' module
(for B&W rasterization), using the `flags' field in the
`FT_Outline' structure.
- The TrueType bytecode interpreter now passes the dropout mode to
the B&W rasterizer. This greatly increases the output for small
ppem values of many fonts like `pala.ttf'.
CHANGES BETWEEN 2.3.6 and 2.3.5
- A bunch of potential security problems have been found. All
users should update.
- Microsoft Unicode cmaps in TrueType fonts are now always
preferred over Apple cmaps. This is not a bug per se, but there
exist some buggy fonts created for MS which have broken Apple
cmaps. This affects only the automatic selection of FreeType;
it's always possible to manually select an Apple Unicode cmap if
- Many bug fixes to the TrueType bytecode interpreter.
- Improved Mac support.
- Subsetted CID-keyed CFFs are now supported correctly.
- CID-keyed CFFs with subfonts which are scaled in a non-standard
way are now handled correctly.
- A call to FT_Open_Face with `face_index' < 0 crashed FreeType if
the font was a Windows (bitmap) FNT/FON.
- The new function `FT_Get_CID_Registry_Ordering_Supplement' gives
access to those fields in a CID-keyed font. The code has been
contributed by Derek Clegg.
- George Williams contributed code to validate the new `MATH'
OpenType table (within the `otvalid' module). The `ftvalid'
demo program has been extended accordingly.
- An API for cmap 14 support (for Unicode Variant Selectors, UVS)
has been contributed by George Williams.
- A new face flag FT_FACE_FLAG_CID_KEYED has been added, together
with a macro FT_IS_CID_KEYED which evaluates to 1 if the font is
- Build support for symbian has been contributed.
- Better WGL4 glyph name support, contributed by Sergey Tolstov.
- Debugging output of the various FT_TRACEX macros is now sent to
- The `ftview' demo program now provides artificial slanting too.
- The `ftvalid' demo program has a new option `-f' to select the
font index.
CHANGES BETWEEN 2.3.5 and 2.3.4
- Some subglyphs in TrueType fonts were handled incorrectly due to
a missing graphics state reinitialization.
- Large .Z files (as distributed with some X11 packages) weren't
handled correctly, making FreeType increase the heap stack in an
endless loop.
- A large number of bugs have been fixed to avoid crashes and
endless loops with invalid fonts.
- The two new cache functions `FTC_ImageCache_LookupScaler' and
`FTC_SBit_Cache_LookupScaler' have been added to allow lookup of
glyphs using an `FTC_Scaler' object; this makes it possible to
use fractional pixel sizes in the cache. The demo programs have
been updated accordingly to use this feature.
- A new API `FT_Get_CMap_Format' has been added to get the cmap
format of a TrueType font. This is useful in handling PDF
files. The code has been contributed by Derek Clegg.
- The auto-hinter now produces better output by default for
non-Latin scripts like Indic. This was done by using the CJK
hinting module as the default instead of the Latin one. Thanks
to Rahul Bhalerao for this suggestion.
- A new API `FT_Face_CheckTrueTypePatents' has been added to find
out whether a given TrueType font uses patented bytecode
instructions. The `ft2demos' bundle contains a new program
called `ftpatchk' which demonstrates its usage.
- A new API `FT_Face_SetUnpatentedHinting' has been added to
enable or disable the unpatented hinter.
- Support for Windows FON files in PE format has been contributed
by Dmitry Timoshkov.
- Vincent Richomme contributed Visual C++ project files for Pocket
CHANGES BETWEEN 2.3.4 and 2.3.3
- A serious bug in the handling of bitmap fonts (and bitmap
strikes of outline fonts) has been introduced in 2.3.3.
CHANGES BETWEEN 2.3.3 and 2.3.2
- Remove a serious regression in the TrueType bytecode interpreter
that was introduced in version 2.3.2. Note that this does not
disable the improvements introduced to the interpreter in
version 2.3.2, only some ill cases that occurred with certain
fonts (though a few popular ones).
- The auto-hinter now ignores single-point contours for computing
blue zones. This bug created `wavy' baselines when rendering
text with various fonts that use these contours to model
mark-attach points (these are points that are never rasterized
and are placed outside of the glyph's real outline).
- The `rsb_delta' and `lsb_delta' glyph slot fields are now set to
zero for mono-spaced fonts. Otherwise code that uses them would
essentially ruin the fixed-advance property.
- Fix CVE-2007-1351 which can cause an integer overflow while
parsing BDF fonts, leading to a potentially exploitable heap
overflow condition.
- Fixed compilation issues on some 64-bit platforms (see ChangeLog
for details).
- A new demo program `ftdiff' has been added to compare TrueType
hinting, FreeType's auto hinting, and rendering without hinting
in three columns.
CHANGES BETWEEN 2.3.2 and 2.3.1
- FreeType returned incorrect kerning information from TrueType
fonts when the bytecode interpreter was enabled. This happened
due to a typo introduced in version 2.3.0.
- Negative kerning values from PFM files are now reported
correctly (they were read as 16-bit unsigned values from the
- Fixed a small memory leak when `FT_Init_FreeType' failed for
some reason.
- The Postscript hinter placed and sized very thin and ghost stems
- The TrueType bytecode interpreter has been fixed to get rid of
most of the rare differences seen in comparison to the Windows
font loader.
- The auto-hinter now better deals with serifs and corner cases
(e.g., glyph '9' in Arial at 9pt, 96dpi). It also improves
spacing adjustments and doesn't change widths for non-spacing
- Many Mac-specific functions are deprecated (but still
available); modern replacements have been provided for them.
See the documentation in file `ftmac.h'.
CHANGES BETWEEN 2.3.1 and 2.3.0
- The TrueType interpreter sometimes returned incorrect horizontal
metrics due to a bug in the handling of the SHZ instruction.
- A typo in a security check introduced after version 2.2.1
prevented FreeType to render some glyphs in CFF fonts.
CHANGES BETWEEN 2.3.0 and 2.2.1
- The PCF font loader is now much more robust while loading
malformed font files.
- Various memory leaks have been found and fixed.
- The TrueType name loader now deals properly with some fonts that
encode their names in UTF-16 (the specification was vague, and
the code incorrectly assumed UCS-4).
- Fixed the TrueType bytecode loader to deal properly with subtle
monochrome/gray issues when scaling the CVT. Some fonts
exhibited bad rendering artifacts otherwise.
- `FT_GlyphSlot_Embolden' now supports vertical layouts correctly
(it mangled the vertical advance height).
- Fixed byte endian issues of `ftmac.c' to support Mac OS X on
- The PFR font loader no longer erroneously tags font files
without any outlines as FT_FACE_FLAG_SCALABLE.
- `FT_Library_SetLcdFilter' allows you to select a special filter
to be applied to the bitmaps generated by `FT_Render_Glyph' if
one of the FT_RENDER_MODE_LCD and FT_RENDER_MODE_LCD_V modes has
been selected. This filter is used to reduce color fringes;
several settings are available through the FT_LCD_FILTER_XXX
Its declaration and documentation can be found in file
`include/freetype/ftlcdfil.h' (to be accessed with macro
*IMPORTANT*: This function returns an error
(FT_Err_Unimplemented_Feature) in default builds of the library
for patent reasons. See below.
- `FT_Get_Gasp' allows you to query the flags of the TrueType
`gasp' table for a given character pixel size. This is useful
to duplicate the text rendering of MS Windows when the native
bytecode interpreter is enabled (which isn't the default for
other patent reasons).
Its declaration and documentation can be found in file
`include/freetype/ftgasp.h' (to be accessed with macro
- The auto-hinter has been tuned a lot to improve its results with
serif fonts, resulting in much better font rendering of many web
- The unpatented hinter is now part of the default build of the
library; we have added code to automatically support `tricky'
fonts that need it.
This means that FreeType should `just work' with certain Asian
fonts, like MingLiU, which cannot properly be loaded without a
bytecode interpreter, but which fortunately do not use any of
the patented bytecode opcodes. We detect these fonts by name,
so please report any font file that doesn't seem to work with
FreeType, and we shall do what we can to support it in a next
Note that the API hasn't changed, so you can still force
unpatented hinting with a special parameter to `FT_Open_Face' as
well. This might be useful in same cases; for example, a PDF
reader might present a user option to activate it to deal with
certain `tricky' embedded fonts which cannot be clearly
If you are a developer for embedded systems, you might want to
*disable* the feature to save code space by undefining
- LCD-optimized rendering is now *disabled* in all default builds
of the library, mainly due to patent issues. For more
information see:
has been introduced in `ftoption.h'; manually define it in this
file if you want to re-enable the feature.
The change only affects the implementation, not the FreeType
API. This means that clients don't need to be modified, because
the library still generates LCD decimated bitmaps, but with the
added constraint that R=G=B on each triplet.
The displayed result should be equal to normal anti-aliased
defined, the new `FT_Library_SetLcdFilter' function returns the
FT_Err_Unimplemented_Feature error code.
- Some computation bugs in the TrueType bytecode interpreter were
found, which allow us to get rid of very subtle and rare
differences we had experienced with the Windows renderer.
- It is now possible to cross-compile the library easily. See the
file `docs/INSTALL.CROSS' for details.
- The file `src/base/ftmac.c' now contains code for Mac OS X only;
its deprecated function `FT_GetFile_From_Mac_Font_Name' always
returns an error even if the QuickDraw framework is available.
The previous version has been moved to `builds/mac/ftmac.c'.
Selecting configure option `--with-quickdraw-carbon' makes the
build process use the original `ftmac.c' file instead of the Mac
OS X-only version.
- Various performance and memory footprint optimizations have been
performed on the TrueType and CFF font loaders, sometimes with
very drastic benefits (e.g., the TrueType loader is now about
25% faster; FreeType should use less heap memory under nearly
all conditions).
- The anti-aliased rasterizer has been optimized and is now 15% to
25% percent faster than in previous versions, depending on
- The Type 1 loader has been improved; as an example, it now skips
top-level dictionaries properly.
- Better support for Mac fonts on POSIX systems, plus compilation
fixes for Mac OS X on ppc64 where `ftmac.c' cannot be built.
- Configuration without `--with-old-mac-fonts' does not include
`ftmac.c' (this was the behaviour in FreeType version 2.1.10).
- The TrueTypeGX validator (gxvalid) checks the order of glyph IDs
in the kern table.
CHANGES BETWEEN 2.2.1 and 2.2
- Various integer overflows have been fixed.
- PFB fonts with MacOS resource fork weren't handled correctly on
non-MacOS platforms.
CHANGES BETWEEN 2.2 and 2.1.10
(not released officially)
- Vertical metrics for SFNT fonts were incorrect sometimes.
- The FT_HAS_KERNING macro always returned 0.
- CFF OpenType fonts didn't return correct vertical metrics for
glyphs with outlines.
- If FreeType was compiled without hinters, all font formats based
on PS outlines weren't scaled correctly.
- Version 2.2 no longer exposes its internals, this is, the header
files located in the `include/freetype/internal' directory of
the source package are not copied anymore by the `make install'
command. Consequently, a number of rogue clients which directly
access FreeType's internal functions and structures won't
compile without modification.
We provide patches for most of those rogue clients. See the
following page for more information:
Note that, as a convenience to our Unix desktop users, version
2.2 is *binary* compatible with FreeType 2.1.7, which means that
installing this release on an existing distribution shall not
break any working desktop.
- FreeType's build mechanism has been redesigned. With GNU make
it is now sufficient in most cases to edit two files:
`modules.cfg', to select the library components, and the
configuration file `include/freetype/config/ftoption.h' (which
can be copied to the objects directory). Removing unused module
directories to prevent its compilation and editing
`include/freetype/config/ftmodule.h' is no longer necessary.
- The LIGHT hinting algorithm produces more pleasant results.
Also, using the FT_LOAD_TARGET_LIGHT flags within FT_Load_Glyph
always forces auto-hinting, as a special exception. This allows
you to experiment with it even if you have enabled the TrueType
bytecode interpreter in your build.
- The auto hinter now employs a new algorithm for CJK fonts, based
on Akito Hirai's patch. Note that this only works for fonts
with a Unicode charmap at the moment.
- The following callback function types have changed slightly (by
adding the `const' keyword where appropriate):
Note that this doesn't affect binary backward compatibility.
- On MacOS, new APIs have been added as replacements for legacy
APIs: `FT_New_Face_From_FSRef' for `FT_New_Face_From_FSSpec',
and `FT_GetFile_From_Mac_ATS_Name' for
`FT_GetFile_From_Mac_Name'. Legacy APIs are still available, if
FreeType is built without disabling them.
- A new API `FT_Select_Size' has been added to select a bitmap
strike by its index. Code using other functions to select
bitmap strikes should be updated to use this function.
- A new API `FT_Get_SubGlyph_Info' has been added to retrieve
subglyph data. This can be used by rogue clients which used to
access the internal headers to get the corresponding data.
- In 2.1.10, the behaviour of `FT_Set_Pixel_Sizes' was changed for
BDF/PCF fonts, and only for them. This causes inconsistency.
In this release, we undo the change. The intent of the change
in 2.1.10 is to allow size selection through real dimensions,
which can now be done through `FT_Request_Size'.
- Some security issues were discovered and fixed in the CFF and
Type 1 loader, causing crashes of FreeType by malformed font
- The documentation for FT_LOAD_TARGET_XXX and FT_RENDER_MODE_XXX
values now better reflects its usage and differences: One set is
used to specify the hinting algorithm, the other to specify the
pixel rendering mode.
- `FT_New_Face' and `FT_New_Face_From_FSSpec' in ftmac.c have been
changed to count supported scalable faces (sfnt, LWFN) only, and
to return the number of available faces via face->num_faces.
Unsupported bitmap faces (fbit, NFNT) are ignored.
- builds/unix/configure has been improved for MacOS X. It now
automatically checks available functions in Carbon library, and
prepare to use newest functions by default. Options to specify
the dependencies of each Carbon APIs (FSSpec, FSRef, old/new
QuickDraw, ATS) are available too. By manual disabling of all
QuickDraw functionality, FreeType can be built without
`deprecated function' warnings on MacOS 10.4.x, but
FT_GetFile_Mac_Name in ftmac.c then is changed to a dummy
function, and returns an `unimplemented' error. For details see
- SFNT cmap handling has been improved, mainly to run much faster
with CJK fonts.
- A new function `FT_Get_TrueType_Engine_Type (declared in
`FT_MODULE_H') is provided to determine the status of the
TrueType bytecode interpreter compiled into the library
(patented, unpatented, unimplemented).
- Vertical metrics of glyphs are synthesized if the font does not
provide such information. You can tell whether the metrics are
synthesized or not by checking the FT_FACE_FLAG_VERTICAL flag of
the face.
- The demo programs `ftview' and `ftstring' have been rewritten
for better readability. `ftview' has a new switch `-p' to test
FT_New_Memory_Face (instead of FT_New_Face).
- FreeType now honours bit 1 in the `head' table of TrueType fonts
(meaning `left sidebearing point at x=0'). This helps with some
buggy fonts.
- Rudimentary support for Adobe's new `SING Glyphlet' format. See
for more information.
- The `ftdump' program from the `ft2demos' bundle now shows some
information about charmaps. It also supports a new switch `-v'
to increase verbosity.
- Better AFM support. This includes track kerning support.
CHANGES BETWEEN 2.1.10 and 2.1.9
- The size comparison for BDF and PCF files could fail sometimes.
- Some CFF files were still not loaded correctly. Patch from
Derek Noonburg.
- The stroker still had some serious bugs.
- Boris Letocha fixed a bug in the TrueType interpreter: The
NPUSHW instruction wasn't skipped correctly in IF clauses. Some
fonts like `Helvetica 75 Bold' failed.
- Another serious bug in handling TrueType hints caused many
distortions. It has been introduced in version 2.1.8, and it is
highly recommended to upgrade.
- FreeType didn't properly parse empty Type 1 glyphs.
- An unbound dynamic buffer growth was fixed in the PFR loader.
- Several bugs have been fixed in the cache sub-system.
- FreeType behaved incorrectly when resizing two distinct but very
close character pixel sizes through `FT_Set_Char_Size' (Savannah
bug #12263).
- The auto-hinter didn't work properly for fonts without a Unicode
charmap -- it even refused to load the glyphs.
- Many fixes have been applied to drastically reduce the amount of
heap memory used by FreeType, especially when using
memory-mapped font files (which is the default on Unix systems
which support them).
- The auto-hinter has been replaced with a new module, called the
`auto-fitter'. It consumes less memory than its predecessor,
and it is prepared to support non-latin scripts better in next
- George Williams contributed code to read kerning data from PFM
- FreeType now uses the TT_NAME_ID_PREFERRED_FAMILY and
TT_NAME_ID_PREFERRED_SUBFAMILY strings (if available) for
setting family and style in SFNT fonts (patch from Kornfeld
Eliyahu Peter).
- A new API `FT_Sfnt_Table_Info' (in FT_TRUETYPE_TABLES_H) has
been added to retrieve name and size information of SFNT tables.
- A new API `FT_OpenType_Validate' (in FT_OPENTYPE_VALIDATE_H) has
been added to validate OpenType tables (BASE, GDEF, GPOS, GSUB,
JSTF). After validation it is no longer necessary to check
for errors in those tables while accessing them.
Note that this module might be moved to another library in the
future to avoid a tight dependency between FreeType and the
OpenType specification.
- A new API in FT_BITMAP_H (`FT_Bitmap_New', `FT_Bitmap_Convert',
`FT_Bitmap_Copy', `FT_Bitmap_Embolden', `FT_Bitmap_Done') has
been added. Its use is to convert an FT_Bitmap structure in
1bpp, 2bpp, 4bpp, or 8bpp format into another 8bpp FT_Bitmap,
probably using a different pitch, and to further manipulate it.
- A new API `FT_Outline_Embolden' (in FT_OUTLINE_H) gives finer
control how outlines are emboldened.
- `FT_GlyphSlot_Embolden' (in FT_SYNTHESIS_H) now handles bitmaps
also (code contributed by Chia I Wu). Note that this function
is still experimental and may be replaced with a better API.
- The method how BDF and PCF bitmap fonts are accessed has been
refined. Formerly, FT_Set_Pixel_Sizes and FT_Set_Char_Size
were synonyms in FreeType's BDF and PCF interface. This has
changed now. FT_Set_Pixel_Sizes should be used to select the
actual font dimensions (the `strike', which is the sum of the
`FONT_ASCENT' and `FONT_DESCENT' properties), while
FT_Set_Char_Size selects the `nominal' size (the `PIXELSIZE'
property). In both functions, the width parameter is ignored.
- The BDF driver no longer converts all returned bitmaps with a
depth of 2bpp or 4bpp to a depth of 8bpp. The documentation has
not mentioned this explicitly, but implementors might have
relied on this after looking into the source files.
- A new option `--ftversion' has been added to freetype-config to
return the FreeType version.
- The memory debugger has been updated to dump allocation
statistics on all allocation sources in the library. This is
useful to spot greedy allocations when loading and processing
- We removed a huge array of constant pointers to constant strings
in the `psnames' module. The problem was that compilations in
PIC mode (i.e., when generating a Unix shared object/dll) put
the array into the non-shared writable section of the library
since absolute pointers are not relocatable by nature.
This reduces the memory consumption by approximately 16KByte per
process linked to FreeType. We now also store the array in a
compressed form (as a trie) which saves about 20KByte of code as
- Kirill Smelkov provided patches to make src/raster/ftraster.c
compile stand-alone again.
CHANGES BETWEEN 2.1.9 and 2.1.8
- The function `FT_Get_CharMap_Index' was only declared, without
any real code. For consistency, it has been renamed to
`FT_Get_Charmap_Index'. (This function is needed to implement
cmap caches.)
- `FT_Outline_Get_BBox' sometimes returned incorrect values for
conic outlines (e.g., for TrueType fonts).
- Handling of `bhed' table has been fixed.
- The TrueType driver with enabled byte code interpreter sometimes
returned artifacts due to incorrect rounding. This bug has been
introduced after version 2.1.4.
- The BDF driver dropped the last glyph in the font.
- The BDF driver now uses the DEFAULT_CHAR property (if available)
to select a glyph shape for the undefined glyph.
- The stroker failed for closed outlines and single points.
- George Williams contributed code to handle Apple's font
distortion technology found in GX fonts (`avar', `cvar', `fvar',
and `gvar' tables; the Multiple Masters API has been slightly
extended to cope with the new functionality).
- The `FT_GlyphSlotRec' structure has been extended: The elements
`lsb_delta' and `rsb_delta' give the difference between hinted
and unhinted left and right side bearings if autohinting is
active. Using those values can improve the inter-letter spacing
considerably. See the documentation of `FT_GlyphSlotRec' and
the `ftstring' demo program how to use it.
- Loading TrueType and Type 1 fonts has been made much faster.
- The stroker is no longer experimental (but the cache subsystem
still is).
- A new documentation file `formats.txt' describes various font
formats supported (and not supported) by FreeType.
CHANGES BETWEEN 2.1.8 and 2.1.7
- The native TrueType hinter contained some bugs which prevented
some fonts to be rendered correctly, most notably Legendum.otf.
- The PostScript hinter now produces improved results.
- The linear advance width and height values were incorrectly
rounded, making them virtually unusable if not loaded with
- Indexing CID-keyed CFF fonts is now working: The glyph index is
correctly treated as a CID, similar to FreeType's CID driver
module. Note that CID CMap support is still missing.
- The FT_FACE_FLAG_GLYPH_NAMES flag is now set correctly for all
font formats.
- Some subsetted Type 1 fonts weren't parsed correctly. This bug
has been introduced in 2.1.7. In summary, the Type 1 parser has
become more robust.
- Non-decimal numbers weren't parsed correctly in PS fonts.
- The WinFNT driver now correctly reports FT_ENCODING_NONE for all
but one encoding. Use the new FT_WinFNT_ID_XXX values together
with `FT_Get_WinFNT_Header' to get the WinFNT charset ID.
- The descender metrics (face->size->metrics.descender) for WinFNT
bitmap fonts had the wrong sign.
- The (emulated) `seac' support for CFF fonts was broken.
- The `flex' operator didn't work for CFF fonts.
- PS glyphs which use the `hintmask' operator haven't been
rendered correctly in some cases.
- Metrics for BDF and PCF bitmap font formats have been fixed.
- Autohinting is now disabled for glyphs which are vertically
distorted or mirrored (using a transformation matrix). This
fixes a bug which produced zero-height glyphs.
- The `freetype-config' script now handles --prefix and
--exec-prefix correctly; it also returns the proper --rpath (or
-R) value if FreeType has been built as a shared library.
- Both PCF and BDF drivers now handle the SETWIDTH_NAME and
ADD_STYLE_NAME properties. Values are appended to
face->style_name; example: `Bold SemiCondensed'.
- The PCF driver now handles bitmap fonts compressed with the LZW
algorithm (extension .pcf.Z, compressed with `compress').
- A new API function `FT_Get_CMap_Language_ID' (declared in
`tttables.h') is available to get the language ID of a
TrueType/SFNT cmap.
- The hexadecimal format of data after the `StartData' command in
CID-keyed Type 1 fonts is now supported. While this can't occur
in file-based fonts, it can happen in document-embedded
resources of PostScript documents.
- Embedded bitmaps in SFNT-based CFF fonts are now supported.
- A simple API is now available to control FreeType's tracing
mechanism if compiled with FT_DEBUG_LEVEL_TRACE. See the file
`ftdebug.h' for more details.
- YAMATO Masatake contributed improved handling of MacOS resource
forks on non-MacOS platforms (for example, Linux can mount MacOS
file systems).
- Support for MacOS has been improved; there is now a new function
`FT_New_Face_From_FSSpec' similar to `FT_New_Face' except that
it accepts an FSSpec instead of a path.
- The cache sub-system has been rewritten.
- There is now support for deinstallation of faces.
- A new API function `FTC_Manager_RemoveFaceID' has been added
to delete all `idle' nodes that correspond to a given
FTC_FaceID. All `locked' nodes (i.e., those with a reference
count > 0), will be modified to prevent them from appearing in
further lookups (they will be cleaned normally when their
reference count reaches 0).
- There is now support for point scaling (i.e., providing
character sizes in points + dpis, instead of pixels).
- Three abstract cache classes are now available:
FTC_GCache: Used to store one glyph item per cache node,
with the ability to group common attributes into
`families'. This replaces the old
FTC_GlyphCache class.
FTC_ICache: Used to store one FT_Glyph per cache node. This
extends FTC_GCache. Family definition, family
comparison, and glyph loading are however left
to sub-classes.
FTC_SCache: Used to store up to 16 small bitmaps per cache
node. This extends FTC_GCache. Family
definition, family comparison and glyph loading
are however left to sub-classes.
- The file `src/cache/ftcbasic.c' implements:
FTC_ImageCache: Extends FTC_ICache; implements family
definitions and glyph loading similar to the
old API.
FTC_SBitCache: Extends FTC_SCache, implements family
definitions and glyph loading similar to the
old API
Client applications should be able to extend FTC_GCache,
FTC_ICache, or FTC_SCache much more easily (i.e., less code to
write, and less callbacks). For example, one could envision
caches that are capable of storing transformed (obliqued),
stroked, emboldened, or colored glyph images. Use
`ftcbasic.c' as an example.
- All public APIs are now in `include/freetype/ftcache.h', (to
be accessed as `FT_CACHE_H'). The contents of
`include/freetype/cache/' is only needed by applications that
wish to implement their own caches.
- There were some major performance improvements through the use
of various programming tricks. Cache hits are up to 70%
faster than in the old code.
- The FTC_CMapCache has been simplified. Charmaps can only be
accessed by index right now. There is also a new API named
`FT_Charmap_GetIndex' for this purpose.
- The demo programs have been updated to the new code. The
previous versions will not work with the current one.
- Using an invalid face index in FT_Open_Face and friends now
causes an error even if the font contains a single face only.
- Wolfgang Domröse contributed support files for building FreeType
on the Atari using the PureC compiler. Note that the Atari is a
16bit platform.
- Vitaliy Pasternak contributed project files for VS.NET 2003.
CHANGES BETWEEN 2.1.7 and 2.1.6
- Updated to newest libtool version, fixing build problems on
various platforms.
- On Unix platforms, `make install' didn't copy the correct
`ftconfig.h' file.
Note that version 2.1.7 contains the same library C source code as
version 2.1.6.
CHANGES BETWEEN 2.1.6 and 2.1.5
- The PFR font driver didn't load kerning tables correctly, and
the functions in FT_PFR_H didn't work at all.
- Type 1 font files in binary format (PFB) with an end-of-file
indicator weren't accepted by the FreeType engine.
- Fonts which contain /PaintType and /StrokeWidth no longer cause
a segfault. This bug has been introduced in version 2.1.5.
- Fonts loaded with FT_LOAD_RENDER no longer cause strange
results. This bug has been introduced in version 2.1.5.
- Some Windows (bitmap) FNT/FON files couldn't be handled
- The internal module API has been heavily changed in favor of
massive simplifications within the font engine. This also means
that authors of third-party modules must adapt their code to the
new scheme.
- The PostScript parser has been enhanced to handle comments and
strings correctly. Additionally, more syntax forms are
- Added the optional unpatented hinting system for TrueType. It
allows typefaces which need hinting to produce correct glyph
forms (e.g., Chinese typefaces from Dynalab) to work acceptably
without infringing Apple patents. This system is compiled only
ftoption.h (activated by default).
- There is now a guard in the public header files to protect
against inclusion of freetype.h from FreeType 1.
- Direct inclusion of freetype.h and other public header files no
longer works. You have to use the documented scheme
#include <ft2build.h>
#include FT_FREETYPE_H
to load freetype.h with a symbolic name. This protects against
renaming of public header files (which shouldn't happen but
actually has, avoiding two public header files with the same
CHANGES BETWEEN 2.1.5 and 2.1.4
- Parsing the /CIDFontName field now removes the leading slash to
be in sync with other font drivers.
- gzip support was buggy. Some fonts could not be read.
- Fonts which have nested subglyphs more than one level deep no
longer cause a segfault.
- Creation of synthetic cmaps for fonts in CFF format was broken
- Numeric font dictionary entries for synthetic fonts are no
longer overwritten.
- The font matrix wasn't applied to the advance width for Type1,
CID, and CFF fonts. This caused problems when loading certain
synthetic Type 1 fonts like `Helvetica Narrow'.
- The test for the charset registry in BDF and PCF fonts is now
- FT_Vector_Rotate sometimes returned strange values due to
rounding errors.
- The PCF driver now returns the correct number of glyphs
(including an artificial `notdef' glyph at index 0).
- FreeType now supports buggy CMaps which are contained in many
CJK fonts from Dynalab.
- Opening an invalid font on a Mac caused a segfault due to
double-freeing memory.
- BDF fonts with more than 32768 glyphs weren't supported
- Accessing bitmap font formats has been synchronized. To do that
the FT_Bitmap_Size structure has been extended to contain new
fields `size', `x_ppem', and `y_ppem'.
- The FNT driver now returns multiple faces, not multiple strikes.
- The `psnames' module has been updated to the Adobe Glyph List
version 2.0.
- The `psnames' module now understands `uXXXX[X[X]]' glyph names.
- The algorithm for guessing the font style has been improved.
- For fonts in SFNT format, root->height is no longer increased if
the line gap is zero. There exist fonts (containing e.g. form
drawing characters) which intentionally have a zero line gap
- ft_glyph_bbox_xxx flags are now deprecated in favour of
- ft_module_xxx flags are now deprecated in favour of
deprecated in favour of
FT_ENCODING_{SJIS,GB2312,BIG5,WANSUNG,JOHAB} -- those encodings
are not specific to Microsoft.
- The autohinter has been further improved; for example, `m'
glyphs now retain its vertical symmetry.
- Partial support of Mac fonts on non-Mac platforms.
- `make refdoc' (after first `make') builds the HTML
documentation. You need Python for this.
- The make build system should now work more reliably on DOS-like
- Support for EMX gcc and Watson C/C++ compilers on MS-DOS has
been added.
- Better VMS build support.
- Support for the pkg-config package by providing a `freetype.pc'
- New configure option --with-old-mac-fonts for Darwin.
- Some source files have been renamed (mainly to fit into the 8.3
naming scheme).
CHANGES BETWEEN 2.1.4 and 2.1.3
- Updated to newest libtool version, fixing build problems on
various platforms.
- A fix in the Gzip stream reader: It couldn't read certain .gz
files properly due to a small typo. In certain cases, FreeType
could also loop endlessly when trying to load tiny gzipped
- The configure script now tries to use the system-wide zlib when
it finds one (instead of the copy found in src/gzip). And
`freetype-config' has been updated to return relevant flags in
this case when invoked with `--libs' (e.g. `-lzlib').
- Certain fonts couldn't be loaded by 2.1.3 because they lacked a
Unicode charmap (e.g. SYMBOL.TTF). FreeType erroneously
rejected them.
- The CFF loader was modified to accept fonts which only contain a
subset of their reference charset. This prevented the correct
use of PDF-embedded fonts.
- The logic to detect Unicode charmaps has been modified. This is
required to support fonts which include both 16-bit and 32-bit
charmaps (like very recent asian ones) using the new 10 and 12
SFNT formats.
- The TrueType loader now limits the depth of composite glyphs.
This is necessary to prevent broken fonts to break the engine by
blowing the stack with recursive glyph definitions.
- The CMap cache is now capable of managing UCS-4 character codes
that are mapped through extended charmaps in recent
TrueType/OpenType fonts.
- The cache sub-system now properly manages out-of-memory
conditions instead of blindly reporting them to the caller.
This means that it will try to empty the cache before restarting
its allocations to see if that can help.
- The PFR driver didn't return the list of available embedded
bitmaps properly.
- There was a nasty memory leak when using embedded bitmaps in
certain font formats.
- David Chester contributed some enhancements to the auto-hinter
that significantly increase the quality of its output. The
Postscript hinter was also improved in several ways.
- The FT_RENDER_MODE_LIGHT render mode was implemented.
- A new API function called `FT_Get_BDF_Property' has been added
to FT_BDF_H to retrieve BDF properties from BDF _and_ PCF font
files. THIS IS STILL EXPERIMENTAL, since it hasn't been
properly tested yet.
- A Windows FNT specific API has been added, mostly to access font
headers. This is used by Wine.
- TrueType tables without an `hmtx' table are now tolerated when
an incremental interface is used. This happens for certain
Type42 fonts passed from Ghostscript to FreeType.
- The PFR font driver is now capable of returning the font family
and style names when they are available (instead of the sole
`FontID'). This is performed by parsing an *undocumented*
portion of the font file!
- The path stroker in FT_STROKER_H has entered beta stage. It now
works very well, but its interface might change a bit in the
future. More on this in later releases.
- The documentation for FT_Size_Metrics didn't appear properly in
the API reference.
- The file docs/VERSION.DLL has been updated to explain versioning
with FreeType (i.e., comparing release/libtool/so numbers, and
how to use them in autoconf scripts).
- The installation documentation has been seriously revamped.
Everything is now in the `docs' directory.
CHANGES BETWEEN 2.1.3 and 2.1.2
- FT_Vector_Transform had been incorrectly modified in 2.1.2,
resulting in incorrect transformations being applied (for
example, rotations were processed in opposite angles).
- The format 8 and 12 TrueType charmap enumeration routines have
been fixed (FT_Get_Next_Char returned invalid values).
- The PFR font driver returned incorrect advance widths if the
outline and metrics resolution defined in the font file were
- FT_Glyph_To_Bitmap now returns successfully when called with an
FT_BitmapGlyph argument (it previously returned an error).
- A bug in the Type 1 loader that prevented valid font bounding
boxes to be loaded from multiple master fonts.
- The SFNT validation code has been rewritten. FreeType can now
load `broken' fonts that were usable on Windows, but not with
previous versions of the library.
- The computation of bearings in the BDF driver has been fixed.
- The Postscript hinter crashed when trying to hint certain glyphs
(more precisely, when trying to apply hints to an empty glyph
- The TrueType glyph loader now supports composites in `Apple
format' (they differ slightly from Microsoft/OpenType ones in
the way transformation offsets are computed).
- FreeType was very slow at opening certain asian CID/CFF fonts,
due to fixed increment in dynamic array re-allocations. This
has been changed to exponential behaviour to get acceptable
- The PCF driver now supports gzip-compressed font files natively.
This means that you will be able to use all these bitmap fonts
that come with XFree86 with FreeType (and libXft/libXft2, by
- The automatic and postscript hinters have both been updated.
This results in a relatively important increase of rendering
quality since many nasty defaults have been suppressed. Please
visit the web page:
for additional details on this topic.
- The `load_flags' parameter of `FT_Load_Glyph' is now an FT_Int32
(instead of just being an FT_Int). This breaks source and
binary compatibility for 16bit systems only, while retaining
both of them for 32 and 64 bit ones.
Some new flags have been added consequently:
FT_LOAD_NO_AUTOHINT :: Disable the use of the auto-hinter
(but not native format hinters).
FT_LOAD_TARGET_NORMAL :: Hint and render for normal
anti-aliased displays.
FT_LOAD_TARGET_MONO :: Hint and render for 1-bit displays.
FT_LOAD_TARGET_LCD :: Hint and render for horizontal RGB or
BGR subpixel displays (like LCD
screens). THIS IS STILL
vertical subpixel displays (like
rotated LCD screens). THIS IS STILL
FT_LOAD_MONOCHROME is still supported, but only affects
rendering, not the hinting.
Note that the `ftview' demo program available in the `ft2demos'
package has been updated to support LCD-optimized display on
non-paletted displays (under Win32 and X11).
- The PFR driver now supports embedded bitmaps (all formats
supported), and returns correct kerning metrics for all glyphs.
- The TrueType charmap loader now supports certain `broken' fonts
that load under Windows without problems.
- The cache API has been slightly modified (it's still a beta!):
- The type FTC_ImageDesc has been removed; it is now replaced
by FTC_ImageTypeRec. Note that one of its fields is a
`load_flag' parameter for FT_Load_Glyph.
- The field `num_grays' of FT_SBitRec has been changed to
`max_grays' in order to fit within a single byte. Its
maximum value is thus 255 (instead of 256 as previously).
- Added support for the DESTDIR variable during `make install'.
This simplifies packaging of FreeType.
- Included modified copies of the ZLib sources in `src/gzip' in
order to support gzip-compressed PCF fonts. We do not use the
system-provided zlib for now, though this is a probable
enhancement for future releases.
- The DocMaker tool used to generate the on-line API reference has
been completely rewritten. It is now located in
`src/tools/docmaker/'. Features:
- better cross-referenced output
- more polished output
- uses Python regular expressions (though it didn't speed the
- much more modular structure, which allows for different
`backends' in order to generate HTML, XML, or whatever
One can regenerate the API reference by calling:
python src/tools/docmaker/ \
--prefix=ft2 \
--title=FreeType-2.1.3 \
include/freetype/*.h \
include/freetype/config/*.h \
- A new, experimental, support for incremental font loading (i.e.,
loading of fonts where the glyphs are not in the font file
itself, but provided by an external component, like a Postscript
interpreter) has been added by Graham Asher. This is still work
in progress, however.
- A new, EXPERIMENTAL, path stroker has been added. It doesn't
suffer from severe rounding errors and treat bezier arcs
directly. Still work in progress (i.e. not part of the official
API). See the file <freetype/ftstroker.h> for some of the
- The massive re-formatting of sources and internal re-design is
still under-way. Many internal functions, constants, and types
have been renamed.
CHANGES BETWEEN 2.1.2 and 2.1.1
- Many font drivers didn't select a Unicode charmap by default
when a new face was opened (with the FT_CONFIG_OPTION_USE_CMAPS
options enabled), causing many applications to not be able to
display text correctly with the 2.1.x releases.
- The PFR driver had a bug in its composite loading code that
produces incorrectly placed accents with many fonts.
- The Type42 driver crashed sometimes due to a nasty bug.
- The Type 1 custom encoding charmap didn't handle the case where
the first glyph index wasn't 0.
- A serious typo in the TrueType composite loader produced
incorrectly placed glyphs in fonts like `Wingdings' and a few
- The Win32 Visual C++ project file has been updated to include
the PFR driver as well.
- `freetype.m4' is now installed by default by `make install' on
Unix systems.
- The function FT_Get_PS_Font_Info now works with CID and Type42
fonts as well.
CHANGES BETWEEN 2.1.1 and 2.1.0
- The `version_info' returned by `freetype-config' in 2.1.0
returned an invalid value. It now returns 9:1:3 (2.0.9 returned
- Version 2.1.0 couldn't be linked against applications on Win32
and Amiga systems due to a new debug function that wasn't
properly propagated to the system-specific directory in
- Various MacOS and Mac OS X specific fixes.
- Fixed a bug in the TrueType charmap validation routines that
made version 2.1.0 too restrictive -- many popular fonts have
been rejected.
- There was still a very small difference between the monochrome
glyph bitmaps produced by FreeType 1.x and FreeType 2.x with the
bytecode interpreter enabled. This was caused by an invalid
flag setting in the TrueType glyph loader, making the rasterizer
change its drop-out control mode. Now the results should
_really_ be completely identical.
- The TrueType name table loader has been improved to support many
popular though buggy Asian fonts. It now ignores empty name
entries, invalid pointer offsets and a few other incorrect
subtleties. Moreover, name strings are now loaded on demand,
which reduces the memory load of many faces (e.g. the ARIAL.TTF
font file contains a 10kByte name table with 70 names).
- Fixed a bug in the Postscript hinter that prevented family blues
substitution to happen correctly.
- Three new font drivers in this release:
* A BDF font driver, contributed by Franco Zappa Nardelli,
heavily modified by Werner Lemberg. It also supports
anti-aliased bitmaps (using a slightly extended BDF format).
* A Type42 font driver, contributed by Roberto Alameda. It is
still experimental but seems to work relatively well.
* A PFR font driver, contributed by David Turner himself. It
doesn't support PFR hinting -- note that BitStream has at
least two patents on this format!
- The cache sub-system has been optimized in important ways.
Cache hits are now significantly faster. For example, using the
CMap cache is about twice faster than calling FT_Get_Char_Index
on most platforms. Similarly, using an SBit cache is about five
times faster than loading the bitmaps from a bitmap file, and
300 to 500 times faster than generating them from a scalable
Note that you should recompile your sources if you designed a
custom cache class for the FT2 Cache subsystem, since the
changes performed are source, but not binary, compatible.
CHANGES BETWEEN 2.1.0 and 2.0.9
- The TrueType bytecode interpreter has been fixed to produce
_exactly_ the same output as FreeType 1.x. Previous differences
were due to slightly distinct fixed-point computation routines
used to perform dot products and vector length measurements.
It seems that native TrueType hinting is _extremely_ sensitive
to rounding errors. The required vector computation routines
have been optimized and placed within the `ttinterp.c' file.
- Fixed the parsing of accelerator tables in the PCF font driver.
- Fixed the Type1 glyph loader routine used to compute the font's
maximum advance width.
- The `configure' script used on Unix systems has been modified to
check that GNU Make is being used to build the library.
Otherwise, it will display a message proposing to use the
GNUMAKE environment variable to name it.
The Unix-specific file README.UNX has been modified accordingly.
- The FreeType License in `docs/FTL.TXT' has been updated to
include a proposed preferred disclaimer. If you are using
FreeType in your products, you are encouraged (but not mandated)
to use the following text in your documentation:
Portions of this software are copyright © 1996-2002 The
FreeType Project ( All rights reserved.
- The default size of the render pool has been reduced to 16kByte.
This shouldn't result in any noticeable performance penalty,
unless you are using the engine as-is to render very large and
complex glyphs.
- The FreeType 2 redesign has begun. More information can be
found at this URL:
The following internal changes have been performed within the
sources of this release:
- Many internal types have been renamed to increase
consistency. The following should be true, except for
public types:
* All structure types have a name ending in `Rec' (short
for `record').
* A pointer-to-structure type has the same name as the
structure, _without_ the `Rec' suffix.
typedef struct FooRec_
} FooRec, *Foo;
- Many internal macros have been renamed to increase
consistency. The following should be true:
* All macros have a name beginning with `FT_'. This
required a few changes like
* All macros are completely UPPERCASE. This required a
few changes like:
* Whenever possible, all macro names follow the
FT_<OBJECT>_<METHOD> pattern. For example
- Many internal functions have been renamed to follow the
FT_<Object>_<Method> pattern. For example:
FT_Seek_Stream => FT_Stream_Seek
FT_Read_Stream_At => FT_Stream_ReadAt
FT_Done_Stream => FT_Stream_Close
FT_New_Stream => FT_Stream_Open
FT_New_Memory_Stream => FT_Stream_OpenMemory
FT_Extract_Frame => FT_Stream_ExtractFrame
Note that method names do not contain `_'.
- The FT_ALLOC_ARRAY and FT_REALLOC_ARRAY have been replaced
with FT_NEW_ARRAY and FT_RENEW_ARRAY which do not take a
type as the fourth argument. Instead, the array element
type size is computed automatically from the type of the
target pointer used.
- A new object class, FT_CMap, has been introduced. These
internal objects are used to model character maps. This
eases the support of additional charmap types within the
- A new configuration file named `ftstdlib.h' has been added
to `include/freetype/config'. It is used to define aliases
for _every_ routine of the ISO C library that the font
engine uses. Each aliases has a `ft_' prefix
(e.g. `ft_strlen' is an alias for `strlen').
This is used to ease the porting of FreeType 2 to exotic
runtime environments where the ISO C Library isn't available
(e.g. XFree86 extension modules).
More details are available in the `ChangeLog' file.
CHANGES BETWEEN 2.0.9 and 2.0.8
- Certain fonts like `foxjump.ttf' contain broken name tables with
invalid entries and wild offsets. This caused FreeType to crash
when trying to load them.
The SFNT `name' table loader has been fixed to be able to
support these strange fonts.
Moreover, the code in charge of processing this table has been
changed to always favour Windows-formatted entries over other
ones. Hence, a font that works on Windows but not on the Mac
will load cleanly in FreeType and report accurate values for
Family & PostScript names.
- The CID font driver has been fixed. It unfortunately returned a
Postscript Font name with a leading slash, as in
- FreeType 2 should now compile fine on AIX 4.3.3 as a shared
- A bug in the Postscript hinter has been found and fixed,
removing un-even stem widths at small pixel sizes (like 14-17).
This improves the quality of a certain number of Postscript
- A new function named `FT_Library_Version' has been added to
return the current library's major, minor, and patch version
numbers. This is important since the macros FREETYPE_MAJOR,
FREETYPE_MINOR, and FREETYPE_PATCH cannot be used when the
library is dynamically linked by a program.
- Two new APIs have been added: `FT_Get_First_Char' and
Together, these can be used to iterate efficiently over the
currently selected charmap of a given face. Read the API
reference for more details.
- The FreeType sources are under heavy internal re-factoring. As
a consequence, we have created a branch named `STABLE' on the
CVS to hold all future releases/fixes in the 2.0.x family.
The HEAD branch now contains the re-factored sources and
shouldn't be used for testing or packaging new releases. In
case you would like to access the 2.0.9 sources from our CVS
repository, use the tag `VER-2-0-9'.