Files
Behdad EsfahbodandMattias Eriksson e563058688 [font] Add hb_font_create_without_funcs_or_fail() (#6651)
Let clients install their own font funcs without initializing and
immediately discarding the default backend. Return NULL if the font
object or its initial variation coordinates cannot be allocated.
Keep hb_font_create()'s initialization order and behavior.

Use the new constructor in hb-ft, Fontconfig, explicit tool backend
selection, and the font benchmarks. This avoids loading a second
FT_Face when FreeType is the default while preserving the caller's
face. Document the custom-client use case and add API and stream-read
regressions.

Testing: full Meson suite (302 passed, one skipped), generated docs,
reduced-feature builds, allocator failures, and tool/benchmark checks.

Supersedes: https://github.com/harfbuzz/harfbuzz/pull/6648

Assisted-by: OpenAI Codex

Co-authored-by: Mattias Eriksson <me@axentia.se>
2026-11-12 13:30:19 -06:00

803 lines
23 KiB
C

/*
* Copyright © 2022 Red Hat, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Author: Matthias Clasen
*/
#include "hb-test.h"
#include "hb-ft.h"
#include FT_FONT_FORMATS_H
static FT_Library ft_library;
static void
init_freetype (void)
{
FT_Error ft_error;
if ((ft_error = FT_Init_FreeType (&ft_library)))
abort ();
}
static void
cleanup_freetype (void)
{
FT_Done_FreeType (ft_library);
}
static FT_Face
get_ft_face (const char *file)
{
FT_Face ft_face;
#if GLIB_CHECK_VERSION(2,37,2)
char* path = g_test_build_filename (G_TEST_DIST, file, NULL);
#else
char* path = g_strdup (file);
#endif
FT_Error ft_error;
if ((ft_error = FT_New_Face (ft_library, path, 0, &ft_face))) {
g_free (path);
abort();
}
g_free (path);
if ((ft_error = FT_Set_Char_Size (ft_face, 2000, 1000, 0, 0)))
abort ();
return ft_face;
}
static void
test_native_ft_basic (void)
{
FT_Face ft_face;
hb_font_t *font;
FT_Face ft_face2;
init_freetype ();
ft_face = get_ft_face ("fonts/adwaita.ttf");
g_assert_nonnull (ft_face);
g_assert_nonnull (FT_Get_Font_Format (ft_face));
font = hb_ft_font_create_referenced (ft_face);
ft_face2 = hb_ft_font_get_ft_face (font);
g_assert_true (ft_face2 == ft_face);
ft_face2 = hb_ft_font_lock_face (font);
g_assert_true (ft_face2 == ft_face);
hb_ft_font_unlock_face (font);
hb_ft_font_set_load_flags (font, FT_LOAD_NO_SCALE | FT_LOAD_NO_AUTOHINT);
int load_flags = hb_ft_font_get_load_flags (font);
g_assert_true (load_flags == (FT_LOAD_NO_SCALE | FT_LOAD_NO_AUTOHINT));
hb_font_destroy (font);
FT_Done_Face (ft_face);
cleanup_freetype ();
}
static void
test_native_ft_set_funcs_preserves_load_flags (void)
{
FT_Face ft_face;
hb_font_t *font;
const int requested_load_flags = FT_LOAD_DEFAULT | FT_LOAD_TARGET_NORMAL;
init_freetype ();
ft_face = get_ft_face ("fonts/Cantarell.A.otf");
g_assert_nonnull (ft_face);
font = hb_ft_font_create_referenced (ft_face);
g_assert_nonnull (font);
hb_ft_font_set_load_flags (font, requested_load_flags);
hb_ft_font_set_funcs (font);
g_assert_cmpint (hb_ft_font_get_load_flags (font), ==, requested_load_flags);
hb_font_destroy (font);
FT_Done_Face (ft_face);
cleanup_freetype ();
}
static void
test_native_ft_set_funcs_immutable (void)
{
FT_Face ft_face;
hb_font_t *font;
hb_glyph_extents_t extents;
init_freetype ();
ft_face = get_ft_face ("fonts/Cantarell.A.otf");
g_assert_nonnull (ft_face);
font = hb_ft_font_create_referenced (ft_face);
g_assert_nonnull (font);
/* Setters must fail silently on an immutable font; this used to
* create a new FT_Face, free it, and then use it. */
hb_font_make_immutable (font);
hb_ft_font_set_funcs (font);
g_assert_true (hb_ft_font_get_ft_face (font) == ft_face);
g_assert_true (hb_font_get_glyph_extents (font, 1, &extents));
hb_font_destroy (font);
FT_Done_Face (ft_face);
cleanup_freetype ();
}
static void
test_native_ft_glyph_name_zero_size_probe (void)
{
static const char *files[] = {
"fonts/adwaita.ttf",
"fonts/SourceSansPro-Regular.otf",
"fonts/Cantarell.A.otf",
};
FT_Face ft_face = NULL;
hb_font_t *font = NULL;
hb_bool_t ret;
hb_codepoint_t glyph = 0;
char name[64];
char guard[4] = { 0x7f, 0x7f, 0x7f, 0x7f };
unsigned int i;
init_freetype ();
for (i = 0; i < G_N_ELEMENTS (files); i++)
{
unsigned int gid;
ft_face = get_ft_face (files[i]);
g_assert_nonnull (ft_face);
font = hb_ft_font_create_referenced (ft_face);
g_assert_nonnull (font);
hb_ft_font_set_funcs (font);
for (gid = 0; gid < (unsigned int) ft_face->num_glyphs; gid++)
if (hb_font_get_glyph_name (font, gid, name, sizeof (name)))
{
glyph = gid;
goto found;
}
hb_font_destroy (font);
font = NULL;
FT_Done_Face (ft_face);
ft_face = NULL;
}
g_test_skip ("No FreeType glyph-name test font available");
cleanup_freetype ();
return;
found:
ret = hb_font_get_glyph_name (font, glyph, name, sizeof (name));
g_assert_true (ret);
g_assert_true (*name);
ret = hb_font_get_glyph_name (font, glyph, NULL, 0);
g_assert_true (ret);
ret = hb_font_get_glyph_name (font, glyph, guard, 0);
g_assert_true (ret);
g_assert_cmpint (guard[0], ==, 0x7f);
g_assert_cmpint (guard[1], ==, 0x7f);
g_assert_cmpint (guard[2], ==, 0x7f);
g_assert_cmpint (guard[3], ==, 0x7f);
ret = hb_font_get_glyph_name (font, 0xFFFFFF, NULL, 0);
g_assert_false (ret);
hb_font_destroy (font);
FT_Done_Face (ft_face);
cleanup_freetype ();
}
/* A minimal custom FT_Stream, so that FT_Open_Face() takes the
* hb_face_create_for_tables() path in hb_ft_face_create() (ie.
* ft_face->stream->read != NULL), instead of wrapping FT_Face's
* mmap'd bytes directly in a shared blob. */
typedef struct
{
const FT_Byte *data;
FT_ULong length;
unsigned int full_reads;
} memory_stream_data_t;
static unsigned long
memory_stream_read (FT_Stream stream,
unsigned long offset,
unsigned char *buffer,
unsigned long count)
{
memory_stream_data_t *sd = (memory_stream_data_t *) stream->descriptor.pointer;
if (offset > sd->length || count > sd->length - offset)
return count ? 0 : 1;
if (count)
{
if (!offset && count == sd->length)
sd->full_reads++;
memcpy (buffer, sd->data + offset, count);
}
return count;
}
static void
memory_stream_close (FT_Stream stream HB_UNUSED)
{
}
static void
test_native_ft_set_funcs_stream_face_no_deadlock (void)
{
#ifndef HB_NO_GETENV
if (!g_test_subprocess ())
{
g_test_trap_subprocess (NULL, 0, 0);
g_test_trap_assert_passed ();
return;
}
g_assert_true (g_setenv ("HB_FONT_FUNCS", "ft", TRUE));
#endif
init_freetype ();
#if GLIB_CHECK_VERSION(2,37,2)
char *path = g_test_build_filename (G_TEST_DIST, "fonts/adwaita.ttf", NULL);
#else
char *path = g_strdup ("fonts/adwaita.ttf");
#endif
gchar *contents;
gsize length;
GError *error = NULL;
g_assert_true (g_file_get_contents (path, &contents, &length, &error));
g_free (path);
memory_stream_data_t stream_data = { (const FT_Byte *) contents, (FT_ULong) length, 0 };
FT_StreamRec stream_rec;
memset (&stream_rec, 0, sizeof (stream_rec));
stream_rec.size = (unsigned long) length;
stream_rec.descriptor.pointer = &stream_data;
stream_rec.read = memory_stream_read;
stream_rec.close = memory_stream_close;
FT_Open_Args args;
memset (&args, 0, sizeof (args));
args.flags = FT_OPEN_STREAM;
args.stream = &stream_rec;
FT_Face ft_face;
FT_Error ft_error = FT_Open_Face (ft_library, &args, 0, &ft_face);
g_assert_cmpint (ft_error, ==, 0);
g_assert_cmpint (FT_Set_Char_Size (ft_face, 2000, 1000, 0, 0), ==, 0);
/* hb_ft_font_create() followed by hb_ft_font_set_funcs() on a face
* opened from a custom stream used to self-deadlock in
* hb_font_destroy(); https://github.com/harfbuzz/harfbuzz/issues/6276 */
unsigned int full_reads = stream_data.full_reads;
hb_font_t *font = hb_ft_font_create (ft_face, NULL);
g_assert_nonnull (font);
/* Even with FreeType as the default backend, creation must not read the
* entire font stream to load a second FT_Face before installing ours. */
g_assert_cmpuint (stream_data.full_reads, ==, full_reads);
g_assert_true (hb_ft_font_get_ft_face (font) == ft_face);
hb_ft_font_set_funcs (font);
hb_buffer_t *buffer = hb_buffer_create ();
hb_buffer_add_utf8 (buffer, "Hello", -1, 0, -1);
hb_buffer_guess_segment_properties (buffer);
hb_shape (font, buffer, NULL, 0);
hb_buffer_destroy (buffer);
hb_font_destroy (font);
FT_Done_Face (ft_face);
g_free (contents);
cleanup_freetype ();
}
static void
test_native_ft_create_invalid_blob_no_leak (void)
{
/* The error path of hb_ft_face_create_from_blob_or_fail() must release the
* FT_Library reference it took from reference_ft_library(); otherwise the
* static library is pinned and leaks. Drive the failing path repeatedly so
* LeakSanitizer flags any unbalanced reference. */
static const char junk[] = "this is not a valid font blob at all";
for (unsigned int i = 0; i < 16; i++)
{
hb_blob_t *blob = hb_blob_create (junk, sizeof (junk),
HB_MEMORY_MODE_READONLY, NULL, NULL);
hb_face_t *face = hb_ft_face_create_from_blob_or_fail (blob, 0);
g_assert_null (face);
hb_blob_destroy (blob);
}
}
static unsigned int ft_face_destroy_count;
static void
count_ft_face_destroy (void *data HB_UNUSED)
{
ft_face_destroy_count++;
}
static void
test_native_ft_create_unsanitizable_font (void)
{
/* A font that FreeType opens but HarfBuzz fails to sanitize: numTables
* claims more table records than the file has room for. hb_face_create()
* drops the blob then, but the destroy callback handed to hb_ft_face_create()
* must still not run before the hb_face_t / hb_font_t is destroyed. */
init_freetype ();
#if GLIB_CHECK_VERSION(2,37,2)
char *path = g_test_build_filename (G_TEST_DIST, "fonts/Roboto-Regular.abc.ttf", NULL);
#else
char *path = g_strdup ("fonts/Roboto-Regular.abc.ttf");
#endif
gchar *contents;
gsize length;
GError *error = NULL;
g_assert_true (g_file_get_contents (path, &contents, &length, &error));
g_free (path);
contents[4] = contents[5] = (gchar) 0xFF;
FT_Face ft_face;
g_assert_cmpint (FT_New_Memory_Face (ft_library, (const FT_Byte *) contents, length, 0, &ft_face), ==, 0);
g_assert_cmpint (FT_Set_Char_Size (ft_face, 2000, 1000, 0, 0), ==, 0);
ft_face_destroy_count = 0;
hb_face_t *face = hb_ft_face_create (ft_face, count_ft_face_destroy);
g_assert_cmpuint (ft_face_destroy_count, ==, 0);
hb_face_destroy (face);
g_assert_cmpuint (ft_face_destroy_count, ==, 1);
ft_face_destroy_count = 0;
hb_font_t *font = hb_ft_font_create (ft_face, count_ft_face_destroy);
g_assert_cmpuint (ft_face_destroy_count, ==, 0);
hb_font_destroy (font);
g_assert_cmpuint (ft_face_destroy_count, ==, 1);
/* The font holds its own FT_Face reference; releasing ours must be fine. */
font = hb_ft_font_create_referenced (ft_face);
FT_Done_Face (ft_face);
hb_font_extents_t extents;
hb_codepoint_t glyph;
g_assert_true (hb_font_get_h_extents (font, &extents));
g_assert_true (hb_font_get_nominal_glyph (font, 'a', &glyph));
hb_font_destroy (font);
g_free (contents);
cleanup_freetype ();
}
static unsigned int ft_blob_destroy_count;
static void
count_ft_blob_destroy (void *data)
{
ft_blob_destroy_count++;
g_free (data);
}
static void
test_native_ft_create_from_blob_table_outlives_face (void)
{
/* Table blobs of a face created by hb_ft_face_create_from_blob_or_fail()
* point into the caller's blob data; they must keep that data alive on
* their own, after both the face and the caller's blob reference are gone. */
#if GLIB_CHECK_VERSION(2,37,2)
char *path = g_test_build_filename (G_TEST_DIST, "fonts/Roboto-Regular.abc.ttf", NULL);
#else
char *path = g_strdup ("fonts/Roboto-Regular.abc.ttf");
#endif
gchar *contents;
gsize length;
GError *error = NULL;
g_assert_true (g_file_get_contents (path, &contents, &length, &error));
g_free (path);
ft_blob_destroy_count = 0;
hb_blob_t *blob = hb_blob_create (contents, length, HB_MEMORY_MODE_READONLY,
contents, count_ft_blob_destroy);
hb_face_t *face = hb_ft_face_create_from_blob_or_fail (blob, 0);
g_assert_nonnull (face);
hb_blob_destroy (blob);
hb_blob_t *head = hb_face_reference_table (face, HB_TAG ('h','e','a','d'));
hb_face_destroy (face);
g_assert_cmpuint (ft_blob_destroy_count, ==, 0);
unsigned int head_length;
const char *head_data = hb_blob_get_data (head, &head_length);
g_assert_cmpuint (head_length, ==, 54);
/* head.magicNumber */
g_assert_cmpmem (head_data + 12, 4, "\x5F\x0F\x3C\xF5", 4);
hb_blob_destroy (head);
g_assert_cmpuint (ft_blob_destroy_count, ==, 1);
}
static gpointer
create_static_ft_faces (gpointer data)
{
hb_blob_t *blob = (hb_blob_t *) data;
for (unsigned int i = 0; i < 100; i++)
{
hb_face_t *face = hb_ft_face_create_from_blob_or_fail (blob, 0);
g_assert_nonnull (face);
hb_font_t *font = hb_font_create (face);
hb_ft_font_set_funcs (font);
hb_font_destroy (font);
hb_face_destroy (face);
}
return NULL;
}
static void
test_static_ft_library_multithreaded (void)
{
hb_blob_t *blob;
GThread *threads[8];
#if GLIB_CHECK_VERSION(2,37,2)
char *path = g_test_build_filename (G_TEST_DIST, "fonts/adwaita.ttf", NULL);
#else
char *path = g_strdup ("fonts/adwaita.ttf");
#endif
blob = hb_blob_create_from_file_or_fail (path);
g_assert_nonnull (blob);
g_free (path);
for (unsigned int i = 0; i < G_N_ELEMENTS (threads); i++)
threads[i] = g_thread_new (NULL, create_static_ft_faces, blob);
for (unsigned int i = 0; i < G_N_ELEMENTS (threads); i++)
g_thread_join (threads[i]);
hb_blob_destroy (blob);
}
#if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) >= 21300
typedef struct
{
hb_font_t *font;
hb_paint_funcs_t *funcs;
hb_codepoint_t glyph;
unsigned int images;
} bitmap_paint_data_t;
static hb_bool_t
bitmap_paint_image (hb_paint_funcs_t *funcs HB_UNUSED,
void *paint_data,
hb_blob_t *blob,
unsigned int width,
unsigned int height,
hb_tag_t format,
float slant HB_UNUSED,
hb_glyph_extents_t *extents HB_UNUSED,
void *user_data HB_UNUSED)
{
bitmap_paint_data_t *data = paint_data;
hb_glyph_extents_t other_extents;
g_assert_cmpuint (format, ==, HB_PAINT_IMAGE_FORMAT_BGRA);
g_assert_cmpuint (width, >, 0);
g_assert_cmpuint (height, >, 0);
g_assert_cmpuint (hb_blob_get_length (blob), ==, width * height * 4);
/* Image callbacks must be able to query the same font. */
g_assert_true (hb_font_get_glyph_extents (data->font, 3 - data->glyph, &other_extents));
data->images++;
return TRUE;
}
static gpointer
paint_bitmaps (gpointer user_data)
{
bitmap_paint_data_t *data = user_data;
for (unsigned int i = 0; i < 100; i++)
g_assert_true (hb_font_paint_glyph_or_fail (data->font, data->glyph,
data->funcs, data, 0,
HB_COLOR (0, 0, 0, 255)));
return NULL;
}
#endif
static void
test_ft_paint_bitmap_multithreaded (void)
{
#if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) >= 21300
hb_face_t *face = hb_test_open_font_file ("fonts/NotoColorEmoji.subset.ttf");
hb_font_t *font = hb_font_create (face);
hb_paint_funcs_t *funcs = hb_paint_funcs_create ();
GThread *threads[4];
bitmap_paint_data_t data[4];
hb_ft_font_set_funcs (font);
FT_Face ft_face = hb_ft_font_lock_face (font);
hb_bool_t have_bitmaps = TRUE;
for (unsigned int glyph = 1; glyph <= 2; glyph++)
if (FT_Load_Glyph (ft_face, glyph, FT_LOAD_COLOR) ||
ft_face->glyph->bitmap.pixel_mode != FT_PIXEL_MODE_BGRA)
have_bitmaps = FALSE;
hb_ft_font_unlock_face (font);
if (!have_bitmaps)
{
g_test_skip ("FreeType color bitmap support not present");
goto out;
}
hb_font_make_immutable (font);
hb_paint_funcs_set_image_func (funcs, bitmap_paint_image, NULL, NULL);
hb_paint_funcs_make_immutable (funcs);
/* The two color bitmap glyphs share a FreeType glyph slot. */
for (unsigned int i = 0; i < G_N_ELEMENTS (threads); i++)
{
data[i] = (bitmap_paint_data_t) {font, funcs, 1 + i % 2, 0};
threads[i] = g_thread_new (NULL, paint_bitmaps, &data[i]);
}
for (unsigned int i = 0; i < G_N_ELEMENTS (threads); i++)
{
g_thread_join (threads[i]);
g_assert_cmpuint (data[i].images, ==, 100);
}
out:
hb_paint_funcs_destroy (funcs);
hb_font_destroy (font);
hb_face_destroy (face);
#else
g_test_skip ("FreeType bitmap paint support not present");
#endif
}
typedef struct
{
hb_position_t v_advance;
hb_position_t origin_x, origin_y;
} v_metrics_t;
static void
get_v_metrics (hb_font_t *font, hb_codepoint_t glyph, v_metrics_t *m)
{
memset (m, 0, sizeof (*m));
m->v_advance = hb_font_get_glyph_v_advance (font, glyph);
g_assert_true (hb_font_get_glyph_v_origin (font, glyph, &m->origin_x, &m->origin_y));
}
static void
assert_v_metrics_equal (const v_metrics_t *a, const v_metrics_t *b)
{
g_assert_cmpint (a->v_advance, ==, b->v_advance);
g_assert_cmpint (a->origin_x, ==, b->origin_x);
g_assert_cmpint (a->origin_y, ==, b->origin_y);
}
static void
test_native_ft_v_metrics_cache (void)
{
/* hb-ft caches the vertical advance and origin it gets from FreeType, so
* that a glyph that is slow to load is not loaded again for every
* occurrence in the text. Repeated queries must return what the first one
* did, and a change of scale or load flags must not serve stale values. */
FT_Face ft_face;
hb_font_t *font, *fresh;
hb_codepoint_t glyph = 0;
v_metrics_t first, again, expected;
int x_scale, y_scale;
init_freetype ();
ft_face = get_ft_face ("fonts/SourceSansPro-Regular.otf");
g_assert_nonnull (ft_face);
font = hb_ft_font_create_referenced (ft_face);
g_assert_nonnull (font);
hb_font_get_scale (font, &x_scale, &y_scale);
g_assert_true (hb_font_get_nominal_glyph (font, 'A', &glyph));
get_v_metrics (font, glyph, &first);
get_v_metrics (font, glyph, &again);
assert_v_metrics_equal (&first, &again);
/* Doubling the scale changes the metrics; the cache must be refreshed. */
hb_font_set_scale (font, 2 * x_scale, 2 * y_scale);
get_v_metrics (font, glyph, &again);
g_assert_cmpint (again.v_advance, !=, first.v_advance);
g_assert_cmpint (again.origin_y, !=, first.origin_y);
fresh = hb_ft_font_create_referenced (ft_face);
hb_font_set_scale (fresh, 2 * x_scale, 2 * y_scale);
get_v_metrics (fresh, glyph, &expected);
assert_v_metrics_equal (&again, &expected);
hb_font_destroy (fresh);
/* So must a change of load flags; FT_LOAD_NO_SCALE gives font units. */
hb_ft_font_set_load_flags (font, FT_LOAD_NO_SCALE);
get_v_metrics (font, glyph, &again);
g_assert_cmpint (again.origin_y, !=, expected.origin_y);
fresh = hb_ft_font_create_referenced (ft_face);
hb_font_set_scale (fresh, 2 * x_scale, 2 * y_scale);
hb_ft_font_set_load_flags (fresh, FT_LOAD_NO_SCALE);
get_v_metrics (fresh, glyph, &expected);
assert_v_metrics_equal (&again, &expected);
hb_font_destroy (fresh);
hb_font_destroy (font);
FT_Done_Face (ft_face);
cleanup_freetype ();
}
static void
test_native_ft_v_metrics_batched (void)
{
/* The vertical advance and origin callbacks are batched. A batched query
* over an array -- with repeats, so later entries are served from the cache,
* and a padded stride -- must agree with the single-glyph API (which routes
* through the same batched callbacks) and with a fresh font, at both
* positive and negative y_scale. The negative-scale case guards the sign
* normalization the advance cache needs, since hb_cache_t holds only
* non-negative values but vertical advances are non-positive when y_scale is
* positive. */
FT_Face ft_face;
hb_font_t *font, *fresh;
int x_scale, y_scale;
hb_codepoint_t glyphs[5];
unsigned n = 5;
init_freetype ();
ft_face = get_ft_face ("fonts/SourceSansPro-Regular.otf");
g_assert_nonnull (ft_face);
font = hb_ft_font_create_referenced (ft_face);
g_assert_nonnull (font);
hb_font_get_scale (font, &x_scale, &y_scale);
g_assert_true (hb_font_get_nominal_glyph (font, 'A', &glyphs[0]));
g_assert_true (hb_font_get_nominal_glyph (font, 'B', &glyphs[1]));
glyphs[2] = glyphs[0]; /* repeat: a cache hit */
g_assert_true (hb_font_get_nominal_glyph (font, 'C', &glyphs[3]));
glyphs[4] = glyphs[1]; /* repeat */
for (int sign = +1; sign >= -1; sign -= 2)
{
struct { hb_position_t v, pad; } adv[5];
struct { hb_position_t x, y, pad; } org[5];
unsigned i;
hb_font_set_scale (font, x_scale, sign * y_scale);
hb_font_get_glyph_v_advances (font, n,
glyphs, sizeof (glyphs[0]),
&adv[0].v, sizeof (adv[0]));
g_assert_true (hb_font_get_glyph_v_origins (font, n,
glyphs, sizeof (glyphs[0]),
&org[0].x, sizeof (org[0]),
&org[0].y, sizeof (org[0])));
/* Compare against a fresh font with no warmed cache. */
fresh = hb_ft_font_create_referenced (ft_face);
hb_font_set_scale (fresh, x_scale, sign * y_scale);
for (i = 0; i < n; i++)
{
hb_position_t ox, oy;
g_assert_cmpint (adv[i].v, ==, hb_font_get_glyph_v_advance (fresh, glyphs[i]));
g_assert_true (hb_font_get_glyph_v_origin (fresh, glyphs[i], &ox, &oy));
g_assert_cmpint (org[i].x, ==, ox);
g_assert_cmpint (org[i].y, ==, oy);
/* The origin comes from FreeType's bearings. */
g_assert_cmpint (FT_Load_Glyph (ft_face, glyphs[i], FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING), ==, 0);
g_assert_cmpint (org[i].x, ==, ft_face->glyph->metrics.horiBearingX -
ft_face->glyph->metrics.vertBearingX);
g_assert_cmpint (org[i].y, ==, sign * (ft_face->glyph->metrics.horiBearingY +
ft_face->glyph->metrics.vertBearingY));
}
hb_font_destroy (fresh);
}
/* A glyph FreeType fails to load has no vertical origin; repeating the
* query must not serve a cached value either. */
{
hb_position_t ox, oy;
hb_codepoint_t bad = ft_face->num_glyphs + 10;
g_assert_false (hb_font_get_glyph_v_origin (font, bad, &ox, &oy));
g_assert_false (hb_font_get_glyph_v_origin (font, bad, &ox, &oy));
}
hb_font_destroy (font);
FT_Done_Face (ft_face);
cleanup_freetype ();
}
int
main (int argc, char **argv)
{
hb_test_init (&argc, &argv);
hb_test_add (test_native_ft_basic);
hb_test_add (test_ft_paint_bitmap_multithreaded);
hb_test_add (test_native_ft_set_funcs_preserves_load_flags);
hb_test_add (test_native_ft_set_funcs_immutable);
hb_test_add (test_native_ft_set_funcs_stream_face_no_deadlock);
hb_test_add (test_native_ft_glyph_name_zero_size_probe);
hb_test_add (test_native_ft_create_invalid_blob_no_leak);
hb_test_add (test_native_ft_create_unsanitizable_font);
hb_test_add (test_native_ft_create_from_blob_table_outlives_face);
hb_test_add (test_static_ft_library_multithreaded);
hb_test_add (test_native_ft_v_metrics_cache);
hb_test_add (test_native_ft_v_metrics_batched);
return hb_test_run ();
}