Usage of hinting in UIs is on the way out.
macOS stopped applying hints ages ago. Apple also canned LCD text.
High DPI displays are obsoleting the raison d'etre of both of these.
A big problem with hinting is that it distorts both the size and the
shape, so UIs do not scale evenly
and animations look jerky.
Another is that a poorly hinted font is far worse than no hinting at all.
-phil.
On 12/12/23 6:10 AM, Mark Raynsford wrote:
Hello!
I've never been particularly satisfied with the font rendering in
JavaFX. In particular, on Linux, the text always appears very soft and
blurry compared to non-JavaFX applications on the same system. Even
applications that render antialiased text with Java2D seem to look
better.
I decided to take a look into it to see if anything could be done about
this, and I have some questions. I'm only looking at the Freetype
implementation in Prism currently, as that's all I can realistically
test on at the moment.
For reference, here's how text rendered at 16px using Terminus TTF
looks today:
https://ataxia.io7m.com/2023/12/12/hinting_nobitmaps_normal.png
I'm not sure if I'm alone on this, but I find this almost migraine-
inducing. No other application on my system, including those that use
Freetype, using that font at that size will render as blurry as that.
Looking at
modules/javafx.graphics/src/main/java/com/sun/javafx/font/freetype/FTFo
ntFile.java, I see this in initGlyph():
```
int flags = OSFreetype.FT_LOAD_RENDER | OSFreetype.FT_LOAD_NO_HINTING |
OSFreetype.FT_LOAD_NO_BITMAP;
```
Additionally, the code might also add the FT_LOAD_TARGET_NORMAL
or FT_LOAD_TARGET_LCD flags later, but I'll assume
FT_LOAD_TARGET_NORMAL for the sake of avoiding combinatorial explosions
in testing at this point.
Essentially, we discard hinting information, and we discard bitmap
information. I'm not sure why we do either of these things. I decided
to try different combinations of flags to see what would happen.
Here's FT_LOAD_RENDER | FT_LOAD_NO_BITMAP (no bitmaps, but using
hinting data):
https://ataxia.io7m.com/2023/12/12/hinting_nobitmaps_normal.png
That's no real improvement. Here's FT_LOAD_RENDER | FT_LOAD_NO_HINTING
(ignore hinting data, but use bitmaps if they are included):
https://ataxia.io7m.com/2023/12/12/nohinting_bitmaps_normal.png
That, to my poor suffering eyes, is already a _vast_ improvement.
Let's try including both hinting and bitmaps (FT_LOAD_RENDER):
https://ataxia.io7m.com/2023/12/12/hinting_bitmaps_normal.png
Inspecting that in an image editor shows the pixels of the text to be
identical.
So, clearly, Terminus TTF includes bitmaps for smaller text sizes.
Let's try another font such as Droid Sans that renders crisply at ~10pt
sizes on my system, and that I'm reasonably confident doesn't include
any bitmaps.
Here's the JavaFX default (FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP):
https://ataxia.io7m.com/2023/12/12/droid_12_nohinting_nobitmaps.png
That's pretty nasty. Let's enable hinting (FT_LOAD_NO_BITMAP):
https://ataxia.io7m.com/2023/12/12/droid_12_hinting_nobitmaps.png
That's already a lot better. If you overlay the two images in an image
editor, it's clear that the glyph shapes are not quite the same (with
hinting, some glyphs are ever-so-slightly taller).
For completeness, let's allow bitmaps:
https://ataxia.io7m.com/2023/12/12/droid_12_hinting_bitmaps.png
The rendered glyphs are pixel-identical.
Now, most modern desktops have options to disable antialiasing for text
under a given size. Antialiasing on 10pt text is rarely an improvement
over just not having it as there are so few pixels to work with. I
decided to experiment a bit with turning off antialiasing. This
requires setting the load target to FT_LOAD_TARGET_MONO so that
Freetype returns a monochrome image instead of what amounts to an alpha
coverage map. Unfortunately, this does also change the format of the
image returned to a 1bpp image instead of an 8bpp greyscale image, and
JavaFX isn't equipped to handle that. However, we can do the conversion
manually if we see that bitmap.pixel_mode == 1, and then the rest of
JavaFX doesn't need to care about it:
```
if (bitmap.pixel_mode == 1) {
byte[] newBuffer = new byte[width * height];
for (int y = 0; y < height; y++) {
final var rowOffset = y * width;
for (int x = 0; x < width; x++) {
final var byteOffset = rowOffset + x;
newBuffer[byteOffset] = bitAt(buffer, x, y, pitch);
}
}
buffer = newBuffer;
}
private static byte bitAt(byte[] buffer, int x, int y, int pitch)
{
final var byteOffset = (y * pitch) + (x / 8);
final var bitOffset = 7 - (x % 8);
final var bit = (buffer[byteOffset] >>> bitOffset) & 1;
return (byte) (bit == 1 ? 0xff : 0x00);
}
```
Here's the JavaFX default of (FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP)
combined with FT_LOAD_TARGET_MONO:
https://ataxia.io7m.com/2023/12/12/droid_12_nohinting_nobitmaps_mono.png
That's not a typeface even a mother could love. :)
However, what happens if we enable hinting?
Here's (FT_LOAD_NO_BITMAP | FT_LOAD_TARGET_MONO):
https://ataxia.io7m.com/2023/12/12/droid_12_hinting_nobitmaps_mono.png
I mean, it's not exactly wonderful for Droid Sans 12 (the O is a little
mangled), but that's more an issue with the font itself. It's certainly
better than the result _without_ hinting.
Amusingly, here's DejaVu Sans at 7pt, (FT_LOAD_NO_BITMAP |
FT_LOAD_TARGET_MONO):
https://ataxia.io7m.com/2023/12/12/dejavu_12_hinting_nobitmaps_mono.png
That, to my eyes, looks pretty good. The JavaFX defaults for the same
font are not good:
https://ataxia.io7m.com/2023/12/12/dejavu_12_nohinting_nobitmaps_normal.png
I've tried on multiple systems (all Linux, however), and I've yet to be
able to contrive a situation where the JavaFX defaults give better
rendering results with any combinations of font sizes, with or without
AA. A brief inspection of the JDK's Java2D sources show that it does
conditionally use FT_LOAD_NO_HINTING depending on various settings
(there are comments about FT_LOAD_NO_HINTING yielding constant-sized
glyphs, which supposedly can make things easier in some cases). The
Java2D results on the systems I tested are consistently better.
So I guess my questions are:
* Why do we discard hinting information?
* Why do we discard bitmaps?
* Would JavaFX accept patches to allow hinting, bitmaps, and
FT_LOAD_TARGET_MONO? Ideally this should be developer-controlled, so I
would need to come up with a pleasant API for it.
My experience has been that most JavaFX applications tend to bundle
fonts rather than relying on anything the system has. I suspect that,
given that developers are including their own fonts, they are the best
equipped to answer questions about hinting and AA, rather than just
setting values and hoping that the font they get will work well, so an
explicit API might be fine.
