aboutsummaryrefslogtreecommitdiff
path: root/font.c
diff options
context:
space:
mode:
authorDaniel Eklöf <daniel@ekloef.se>2019-07-29 18:12:33 +0000
committerDaniel Eklöf <daniel@ekloef.se>2019-07-29 18:12:33 +0000
commitd1b88f67e463fa2443efe903c3e2e736dd7282f3 (patch)
treed70328d758ff8b22508425b0a7b848f63e1dccf1 /font.c
parentrender: reset "last cursor" when resizing (diff)
parentfont: set FT load and render flags from FontConfig properties (diff)
Merge branch 'use-freetype-to-render-glyphs'
Diffstat (limited to 'font.c')
-rw-r--r--font.c279
1 files changed, 239 insertions, 40 deletions
diff --git a/font.c b/font.c
index 4d8bd65f..c6a118c9 100644
--- a/font.c
+++ b/font.c
@@ -2,46 +2,57 @@
#include <stdlib.h>
#include <stdbool.h>
+#include <wchar.h>
#include <assert.h>
#include <fontconfig/fontconfig.h>
-#include <cairo-ft.h>
#define LOG_MODULE "font"
#include "log.h"
+#define min(x, y) ((x) < (y) ? (x) : (y))
+
+static FT_Library ft_lib;
+
static void __attribute__((constructor))
init(void)
{
FcInit();
+ FT_Init_FreeType(&ft_lib);
}
static void __attribute__((destructor))
fini(void)
{
FcFini();
+ FT_Done_FreeType(ft_lib);
}
-cairo_scaled_font_t *
-font_from_name(const char *name)
+
+static void
+font_populate_glyph_cache(struct font *font)
{
+ memset(font->cache, 0, sizeof(font->cache));
+ for (size_t i = 0; i < 256; i++)
+ font_glyph_for_utf8(font, &(char){i}, &font->cache[i]);
+}
+
+bool
+font_from_name(const char *name, struct font *font)
+{
+ memset(font, 0, sizeof(*font));
+
FcPattern *pattern = FcNameParse((const unsigned char *)name);
if (pattern == NULL) {
LOG_ERR("%s: failed to lookup font", name);
- return NULL;
+ return false;
}
if (!FcConfigSubstitute(NULL, pattern, FcMatchPattern)) {
LOG_ERR("%s: failed to do config substitution", name);
FcPatternDestroy(pattern);
- return NULL;
+ return false;
}
- cairo_font_options_t *options = cairo_font_options_create();
- cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_DEFAULT);
- cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_DEFAULT);
- cairo_font_options_set_subpixel_order(options, CAIRO_SUBPIXEL_ORDER_DEFAULT);
- cairo_ft_font_options_substitute(options, pattern);
-
FcDefaultSubstitute(pattern);
FcResult result;
@@ -50,54 +61,242 @@ font_from_name(const char *name)
if (final_pattern == NULL) {
LOG_ERR("%s: failed to match font", name);
- return NULL;
+ return false;
+ }
+
+ FcChar8 *face_file = NULL;
+ if (FcPatternGetString(final_pattern, FC_FT_FACE, 0, &face_file) != FcResultMatch) {
+ if (FcPatternGetString(final_pattern, FC_FILE, 0, &face_file) != FcResultMatch) {
+ LOG_ERR("no font file name available");
+ FcPatternDestroy(final_pattern);
+ return false;
+ }
+ }
+
+ double dpi;
+ if (FcPatternGetDouble(final_pattern, FC_DPI, 0, &dpi) != FcResultMatch)
+ dpi = 96;
+
+ double size;
+ if (FcPatternGetDouble(final_pattern, FC_PIXEL_SIZE, 0, &size)) {
+ LOG_ERR("%s: failed to get size", name);
+ FcPatternDestroy(final_pattern);
+ return false;
}
- FcBool fc_hinting, fc_antialias;
+ LOG_DBG("loading: %s", face_file);
+
+ FT_Face ft_face;
+ FT_Error ft_err = FT_New_Face(ft_lib, (const char *)face_file, 0, &ft_face);
+ if (ft_err != 0)
+ LOG_ERR("%s: failed to create FreeType face", face_file);
+
+ if ((ft_err = FT_Set_Char_Size(ft_face, size * 64, 0, 0, 0)) != 0)
+ LOG_WARN("failed to set character size");
+
+ FcBool fc_hinting;
if (FcPatternGetBool(final_pattern, FC_HINTING,0, &fc_hinting) != FcResultMatch)
fc_hinting = FcTrue;
+ FcBool fc_antialias;
if (FcPatternGetBool(final_pattern, FC_ANTIALIAS, 0, &fc_antialias) != FcResultMatch)
fc_antialias = FcTrue;
- cairo_font_options_set_hint_style(
- options, fc_hinting ? CAIRO_HINT_STYLE_DEFAULT : CAIRO_HINT_STYLE_NONE);
- cairo_font_options_set_antialias(
- options, fc_antialias ? CAIRO_ANTIALIAS_DEFAULT : CAIRO_ANTIALIAS_NONE);
+ int fc_hintstyle;
+ if (FcPatternGetInteger(final_pattern, FC_HINT_STYLE, 0, &fc_hintstyle) != FcResultMatch)
+ fc_hintstyle = FC_HINT_SLIGHT;
- double size;
- if (FcPatternGetDouble(final_pattern, FC_PIXEL_SIZE, 0, &size)) {
- LOG_ERR("%s: failed to get size", name);
- FcPatternDestroy(final_pattern);
- return NULL;
+ int fc_rgba;
+ if (FcPatternGetInteger(final_pattern, FC_RGBA, 0, &fc_rgba) != FcResultMatch)
+ fc_rgba = FC_RGBA_UNKNOWN;
+
+ int load_flags = 0;
+ if (!fc_antialias) {
+ if (!fc_hinting || fc_hintstyle == FC_HINT_NONE)
+ load_flags |= FT_LOAD_MONOCHROME | FT_LOAD_NO_HINTING | FT_LOAD_TARGET_NORMAL;
+ else
+ load_flags |= FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO;
+ } else {
+ if (!fc_hinting || fc_hintstyle == FC_HINT_NONE)
+ load_flags |= FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING | FT_LOAD_TARGET_NORMAL;
+ else if (fc_hinting && fc_hintstyle == FC_HINT_SLIGHT)
+ load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_LIGHT;
+ else if (fc_rgba == FC_RGBA_RGB) {
+ LOG_WARN("unimplemented: subpixel antialiasing");
+ // load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_LCD;
+ load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_NORMAL;
+ } else if (fc_rgba == FC_RGBA_VRGB) {
+ LOG_WARN("unimplemented: subpixel antialiasing");
+ //load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_LCD_V;
+ load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_NORMAL;
+ } else
+ load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_NORMAL;
+ }
+
+ FcBool fc_embeddedbitmap;
+ if (FcPatternGetBool(final_pattern, FC_EMBEDDED_BITMAP, 0, &fc_embeddedbitmap) != FcResultMatch)
+ fc_embeddedbitmap = FcTrue;
+
+ if (!fc_embeddedbitmap)
+ load_flags |= FT_LOAD_NO_BITMAP;
+
+ int render_flags = 0;
+ if (!fc_antialias)
+ render_flags |= FT_RENDER_MODE_MONO;
+ else {
+ if (false)
+ ;
+#if 0
+ if (fc_rgba == FC_RGBA_RGB)
+ render_flags |= FT_RENDER_MODE_LCD;
+ else if (fc_rgba == FC_RGBA_VRGB)
+ render_flags |= FT_RENDER_MODE_LCD_V;
+#endif
+ else
+ render_flags |= FT_RENDER_MODE_NORMAL;
}
- cairo_font_face_t *face = cairo_ft_font_face_create_for_pattern(
- final_pattern);
+ int fc_lcdfilter;
+ if (FcPatternGetInteger(final_pattern, FC_LCD_FILTER, 0, &fc_lcdfilter) != FcResultMatch)
+ fc_lcdfilter = FC_LCD_DEFAULT;
+
+ switch (fc_lcdfilter) {
+ case FC_LCD_NONE: font->lcd_filter = FT_LCD_FILTER_NONE; break;
+ case FC_LCD_DEFAULT: font->lcd_filter = FT_LCD_FILTER_DEFAULT; break;
+ case FC_LCD_LIGHT: font->lcd_filter = FT_LCD_FILTER_LIGHT; break;
+ case FC_LCD_LEGACY: font->lcd_filter = FT_LCD_FILTER_LEGACY; break;
+ }
FcPatternDestroy(final_pattern);
- if (cairo_font_face_status(face) != CAIRO_STATUS_SUCCESS) {
- LOG_ERR("%s: failed to create cairo font face", name);
- cairo_font_face_destroy(face);
- return NULL;
+ mtx_init(&font->lock, mtx_plain);
+ font->face = ft_face;
+ font->load_flags = load_flags;
+ font->render_flags = render_flags;
+ font_populate_glyph_cache(font);
+ return true;
+}
+
+bool
+font_glyph_for_utf8(struct font *font, const char *utf8,
+ struct glyph *glyph)
+{
+ mbstate_t ps = {0};
+ wchar_t wc;
+ if (mbrtowc(&wc, utf8, 4, &ps) < 0) {
+ LOG_ERR("FAILED: %.4s", utf8);
+ return false;
+ }
+
+ wprintf(L"CONVERTED: %.1s\n", &wc);
+
+ mtx_lock(&font->lock);
+
+ /*
+ * LCD filter is per library instance. Thus we need to re-set it
+ * every time...
+ *
+ * Also note that many freetype builds lack this feature
+ * (FT_CONFIG_OPTION_SUBPIXEL_RENDERING must be defined, and isn't
+ * by default) */
+ FT_Error err = FT_Library_SetLcdFilter(ft_lib, font->lcd_filter);
+ if (err != 0 && err != FT_Err_Unimplemented_Feature)
+ goto err;
+
+ FT_UInt idx = FT_Get_Char_Index(font->face, wc);
+ err = FT_Load_Glyph(font->face, idx, font->load_flags);
+ if (err != 0) {
+ LOG_ERR("load failed");
+ goto err;
+ }
+
+ err = FT_Render_Glyph(font->face->glyph, font->render_flags);
+ if (err != 0)
+ goto err;
+
+ assert(font->face->glyph->format == FT_GLYPH_FORMAT_BITMAP);
+
+ FT_Bitmap *bitmap = &font->face->glyph->bitmap;
+ assert(bitmap->pixel_mode == FT_PIXEL_MODE_GRAY ||
+ bitmap->pixel_mode == FT_PIXEL_MODE_MONO);
+
+ cairo_format_t cr_format = bitmap->pixel_mode == FT_PIXEL_MODE_GRAY
+ ? CAIRO_FORMAT_A8 : CAIRO_FORMAT_A1;
+
+ int stride = cairo_format_stride_for_width(cr_format, bitmap->width);
+ assert(stride >= bitmap->pitch);
+
+ uint8_t *data = malloc(bitmap->rows * stride);
+ assert(bitmap->pitch >= 0);
+
+ switch (bitmap->pixel_mode) {
+ case FT_PIXEL_MODE_MONO:
+ for (size_t r = 0; r < bitmap->rows; r++) {
+ for (size_t c = 0; c < (bitmap->width + 7) / 8; c++) {
+ uint8_t v = bitmap->buffer[r * bitmap->pitch + c];
+ uint8_t reversed = 0;
+ for (size_t i = 0; i < min(8, bitmap->width - c * 8); i++)
+ reversed |= ((v >> (7 - i)) & 1) << i;
+
+ data[r * stride + c] = reversed;
+ }
+ }
+ break;
+
+ case FT_PIXEL_MODE_GRAY:
+ for (size_t r = 0; r < bitmap->rows; r++) {
+ for (size_t c = 0; c < bitmap->width; c++)
+ data[r * stride + c] = bitmap->buffer[r * bitmap->pitch + c];
+ }
+ break;
+
+ default:
+ LOG_ERR("unimplemented FreeType bitmap pixel mode: %d",
+ bitmap->pixel_mode);
+ free(data);
+ goto err;
+ }
+
+ cairo_surface_t *surf = cairo_image_surface_create_for_data(
+ data, cr_format, bitmap->width, bitmap->rows, stride);
+
+ if (cairo_surface_status(surf) != CAIRO_STATUS_SUCCESS) {
+ free(data);
+ cairo_surface_destroy(surf);
+ goto err;
}
- cairo_matrix_t matrix, ctm;
- cairo_matrix_init_identity(&ctm);
- cairo_matrix_init_scale(&matrix, size, size);
+ *glyph = (struct glyph){
+ .data = data,
+ .surf = surf,
+ .left = font->face->glyph->bitmap_left,
+ .top = font->face->glyph->bitmap_top,
- cairo_scaled_font_t *scaled_font = cairo_scaled_font_create(
- face, &matrix, &ctm, options);
+ .format = cr_format,
+ .width = bitmap->width,
+ .height = bitmap->rows,
+ .stride = stride,
+ };
+ mtx_unlock(&font->lock);
+ return true;
- cairo_font_options_destroy(options);
- cairo_font_face_destroy(face);
+err:
+ mtx_unlock(&font->lock);
+ return false;
+}
+
+void
+font_destroy(struct font *font)
+{
+ if (font->face != NULL)
+ FT_Done_Face(font->face);
- if (cairo_scaled_font_status(scaled_font) != CAIRO_STATUS_SUCCESS) {
- LOG_ERR("%s: failed to create scaled font", name);
- cairo_scaled_font_destroy(scaled_font);
- return NULL;
+ for (size_t i = 0; i < 256; i++) {
+ if (font->cache[i].surf != NULL)
+ cairo_surface_destroy(font->cache[i].surf);
+ if (font->cache[i].data != NULL)
+ free(font->cache[i].data);
}
- return scaled_font;
+ mtx_destroy(&font->lock);
}