mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-19 05:51:05 +01:00
841 lines
31 KiB
C++
841 lines
31 KiB
C++
/*
|
||
* Copyright © 2026 Behdad Esfahbod
|
||
*
|
||
* 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(s): Behdad Esfahbod
|
||
*/
|
||
|
||
#include "hb-test.h"
|
||
#include "hb-raster.h"
|
||
#include <hb-ot.h>
|
||
|
||
|
||
/* ── Helpers ─────────────────────────────────────────────────────── */
|
||
|
||
/* Draw a closed rectangle by emitting raw draw callbacks. */
|
||
static void
|
||
draw_rect (hb_raster_draw_t *rdr,
|
||
float x0, float y0, float x1, float y1)
|
||
{
|
||
hb_draw_funcs_t *df = hb_raster_draw_get_funcs (rdr);
|
||
hb_draw_state_t st = HB_DRAW_STATE_DEFAULT;
|
||
|
||
hb_draw_move_to (df, rdr, &st, x0, y0);
|
||
hb_draw_line_to (df, rdr, &st, x1, y0);
|
||
hb_draw_line_to (df, rdr, &st, x1, y1);
|
||
hb_draw_line_to (df, rdr, &st, x0, y1);
|
||
hb_draw_close_path (df, rdr, &st); /* emits closing line_to(x0,y0) */
|
||
}
|
||
|
||
/* Read one A8 pixel value; returns 0 for out-of-bounds coordinates. */
|
||
static uint8_t
|
||
pixel_at (hb_raster_image_t *img, int x, int y)
|
||
{
|
||
hb_raster_extents_t ext;
|
||
hb_raster_image_get_extents (img, &ext);
|
||
|
||
int col = x - ext.x_origin;
|
||
int row = y - ext.y_origin;
|
||
|
||
if (col < 0 || row < 0 ||
|
||
(unsigned) col >= ext.width || (unsigned) row >= ext.height)
|
||
return 0;
|
||
|
||
return hb_raster_image_get_buffer (img)[row * ext.stride + col];
|
||
}
|
||
|
||
|
||
/* ── Test 1: rectangle geometry ──────────────────────────────────── */
|
||
|
||
static void
|
||
test_rectangle (void)
|
||
{
|
||
hb_raster_draw_t *rdr = hb_raster_draw_create_or_fail ();
|
||
|
||
draw_rect (rdr, 2.f, 2.f, 30.f, 30.f);
|
||
|
||
hb_raster_image_t *img = hb_raster_draw_render (rdr);
|
||
g_assert_nonnull (img);
|
||
|
||
hb_raster_extents_t ext;
|
||
hb_raster_image_get_extents (img, &ext);
|
||
g_assert_cmpint (ext.x_origin, ==, 2);
|
||
g_assert_cmpint (ext.y_origin, ==, 2);
|
||
g_assert_cmpuint (ext.width, ==, 28);
|
||
g_assert_cmpuint (ext.height, ==, 28);
|
||
|
||
/* Center: fully inside → full coverage */
|
||
g_assert_cmpint (pixel_at (img, 16, 16), ==, 255);
|
||
|
||
/* Well outside the box → zero */
|
||
g_assert_cmpint (pixel_at (img, 0, 0), ==, 0); /* out of image */
|
||
g_assert_cmpint (pixel_at (img, 31, 31), ==, 0); /* out of image */
|
||
|
||
/* Left-most and right-most pixel columns: still fully inside
|
||
because integer-coordinate box edges align with pixel boundaries */
|
||
g_assert_cmpint (pixel_at (img, 2, 16), ==, 255);
|
||
g_assert_cmpint (pixel_at (img, 29, 16), ==, 255);
|
||
|
||
/* One pixel beyond the box right edge: out of image */
|
||
g_assert_cmpint (pixel_at (img, 30, 16), ==, 0);
|
||
|
||
hb_raster_image_destroy (img);
|
||
|
||
/* render() with no accumulated edges → empty (0×0) image */
|
||
img = hb_raster_draw_render (rdr);
|
||
g_assert_nonnull (img);
|
||
hb_raster_image_get_extents (img, &ext);
|
||
g_assert_cmpuint (ext.width, ==, 0);
|
||
g_assert_cmpuint (ext.height, ==, 0);
|
||
hb_raster_image_destroy (img);
|
||
|
||
hb_raster_draw_destroy (rdr);
|
||
}
|
||
|
||
|
||
/* ── Test 2: multi-glyph accumulation ────────────────────────────── */
|
||
|
||
static void
|
||
test_accumulate (void)
|
||
{
|
||
hb_raster_draw_t *rdr = hb_raster_draw_create_or_fail ();
|
||
|
||
/* Two non-overlapping boxes accumulated before a single render() */
|
||
draw_rect (rdr, 0.f, 0.f, 10.f, 10.f);
|
||
draw_rect (rdr, 20.f, 0.f, 30.f, 10.f);
|
||
|
||
hb_raster_image_t *img = hb_raster_draw_render (rdr);
|
||
g_assert_nonnull (img);
|
||
|
||
/* Both interiors fully covered */
|
||
g_assert_cmpint (pixel_at (img, 5, 5), ==, 255);
|
||
g_assert_cmpint (pixel_at (img, 25, 5), ==, 255);
|
||
|
||
/* Gap between the two boxes is empty */
|
||
g_assert_cmpint (pixel_at (img, 15, 5), ==, 0);
|
||
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_draw_destroy (rdr);
|
||
}
|
||
|
||
|
||
/* ── Test 3: sub-pixel edge coverage ─────────────────────────────── */
|
||
|
||
static void
|
||
test_subpixel_edge (void)
|
||
{
|
||
hb_raster_draw_t *rdr = hb_raster_draw_create_or_fail ();
|
||
|
||
/* Box with a half-pixel offset so the leftmost pixel column is split */
|
||
draw_rect (rdr, 2.5f, 2.f, 30.f, 30.f);
|
||
|
||
hb_raster_image_t *img = hb_raster_draw_render (rdr);
|
||
g_assert_nonnull (img);
|
||
|
||
/* The pixel at x=2 straddles the left edge → partial coverage */
|
||
int v = pixel_at (img, 2, 16);
|
||
g_assert_cmpint (v, >, 0);
|
||
g_assert_cmpint (v, <, 255);
|
||
|
||
/* The pixel at x=3 is fully inside */
|
||
g_assert_cmpint (pixel_at (img, 3, 16), ==, 255);
|
||
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_draw_destroy (rdr);
|
||
}
|
||
|
||
|
||
/* ── Test 4: wide scanline accumulators ─────────────────────────── */
|
||
|
||
static void
|
||
test_many_coincident_edges (void)
|
||
{
|
||
hb_raster_draw_t *rdr = hb_raster_draw_create_or_fail ();
|
||
|
||
/* A vertical edge at x=255/256 contributes 510*256 to one area cell.
|
||
* 16,449 such edges exceed INT32_MAX. */
|
||
for (unsigned i = 0; i < 16449; i++)
|
||
draw_rect (rdr, 0.f, 0.f, 255.f / 256.f, 1.f);
|
||
|
||
hb_raster_image_t *img = hb_raster_draw_render (rdr);
|
||
g_assert_nonnull (img);
|
||
g_assert_cmpint (pixel_at (img, 0, 0), ==, 255);
|
||
hb_raster_image_destroy (img);
|
||
|
||
/* 256 coincident unit boxes overflow the narrow cover accumulator. */
|
||
for (unsigned i = 0; i < 256; i++)
|
||
draw_rect (rdr, 0.f, 0.f, 1.f, 1.f);
|
||
|
||
img = hb_raster_draw_render (rdr);
|
||
g_assert_nonnull (img);
|
||
g_assert_cmpint (pixel_at (img, 0, 0), ==, 255);
|
||
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_draw_destroy (rdr);
|
||
}
|
||
|
||
/* ── Test 5: transform ───────────────────────────────────────────── */
|
||
|
||
static void
|
||
test_transform (void)
|
||
{
|
||
hb_raster_draw_t *rdr = hb_raster_draw_create_or_fail ();
|
||
|
||
/* Scale by 2 — same unit-square box maps to (0,0)→(20,20) */
|
||
hb_raster_draw_set_transform (rdr, 2.f, 0.f, 0.f, 2.f, 0.f, 0.f);
|
||
draw_rect (rdr, 0.f, 0.f, 10.f, 10.f);
|
||
|
||
hb_raster_image_t *img = hb_raster_draw_render (rdr);
|
||
g_assert_nonnull (img);
|
||
|
||
hb_raster_extents_t ext;
|
||
hb_raster_image_get_extents (img, &ext);
|
||
g_assert_cmpuint (ext.width, ==, 20);
|
||
g_assert_cmpuint (ext.height, ==, 20);
|
||
g_assert_cmpint (pixel_at (img, 10, 10), ==, 255); /* center of scaled box */
|
||
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_draw_destroy (rdr);
|
||
}
|
||
|
||
/* ── Test 6: transformed glyph extents helper ───────────────────── */
|
||
|
||
static void
|
||
test_set_glyph_extents_with_transform (void)
|
||
{
|
||
hb_raster_draw_t *rdr = hb_raster_draw_create_or_fail ();
|
||
|
||
hb_raster_draw_set_transform (rdr, 2.f, 0.f, 0.f, 3.f, 5.f, 7.f);
|
||
|
||
hb_glyph_extents_t gext = {
|
||
1, /* x_bearing */
|
||
4, /* y_bearing */
|
||
10, /* width */
|
||
-6 /* height */
|
||
};
|
||
|
||
g_assert_true (hb_raster_draw_set_glyph_extents (rdr, &gext));
|
||
|
||
draw_rect (rdr, (float) gext.x_bearing,
|
||
(float) gext.y_bearing + gext.height,
|
||
(float) gext.x_bearing + gext.width,
|
||
(float) gext.y_bearing);
|
||
|
||
hb_raster_image_t *img = hb_raster_draw_render (rdr);
|
||
g_assert_nonnull (img);
|
||
|
||
hb_raster_extents_t ext;
|
||
hb_raster_image_get_extents (img, &ext);
|
||
g_assert_cmpint (ext.x_origin, ==, 7); /* 2*1 + 5 */
|
||
g_assert_cmpint (ext.y_origin, ==, 1); /* 3*(-2) + 7 */
|
||
g_assert_cmpuint (ext.width, ==, 20); /* 2*10 */
|
||
g_assert_cmpuint (ext.height, ==, 18); /* 3*6 */
|
||
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_draw_destroy (rdr);
|
||
}
|
||
|
||
/* ── Test 7: image paint under an overflowing transform ──────────── */
|
||
|
||
/* Nested scales, each representable, whose product overflows to infinity.
|
||
* The inverse transform then carries NaN into the image sampler's texel
|
||
* coordinates. Exercised for the float-to-int conversion, so this needs a
|
||
* sanitizer build to catch a regression. */
|
||
static void
|
||
test_image_nonfinite_transform (void)
|
||
{
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
g_assert_nonnull (paint);
|
||
|
||
hb_raster_extents_t ext = {0, 0, 32, 32, 0};
|
||
hb_raster_paint_set_extents (paint, &ext);
|
||
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
|
||
hb_paint_push_transform (funcs, paint, 1e30f, 0.f, 0.f, 1e30f, 0.f, 0.f);
|
||
hb_paint_push_transform (funcs, paint, 1e30f, 0.f, 0.f, 1e30f, 0.f, 0.f);
|
||
|
||
const unsigned w = 4, h = 4;
|
||
char pixels[w * h * 4];
|
||
memset (pixels, 0, sizeof (pixels));
|
||
hb_blob_t *blob = hb_blob_create (pixels, sizeof (pixels),
|
||
HB_MEMORY_MODE_READONLY, nullptr, nullptr);
|
||
|
||
hb_glyph_extents_t gext = {0, 32, 32, -32};
|
||
hb_paint_image (funcs, paint, blob, w, h,
|
||
HB_PAINT_IMAGE_FORMAT_BGRA, 0.f, &gext);
|
||
|
||
hb_paint_pop_transform (funcs, paint);
|
||
hb_paint_pop_transform (funcs, paint);
|
||
|
||
hb_blob_destroy (blob);
|
||
hb_raster_paint_destroy (paint);
|
||
}
|
||
|
||
/* ── Test 8: glyph extents that overflow the int grid ────────────── */
|
||
|
||
/* Glyph extents are int32, so a transform that scales them up puts the
|
||
* corner coordinates far outside the int range before they are floored
|
||
* back to the integer pixel grid. Exercised for the conversion itself,
|
||
* so this needs a sanitizer build to catch a regression. */
|
||
static void
|
||
test_set_glyph_extents_overflow (void)
|
||
{
|
||
hb_glyph_extents_t gext = {-2000000000, 2000000000, 2000000000, -2000000000};
|
||
|
||
hb_raster_draw_t *rdr = hb_raster_draw_create_or_fail ();
|
||
g_assert_nonnull (rdr);
|
||
hb_raster_draw_set_transform (rdr, 1000.f, 0.f, 0.f, 1000.f, 0.f, 0.f);
|
||
hb_raster_draw_set_glyph_extents (rdr, &gext);
|
||
hb_raster_draw_destroy (rdr);
|
||
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
g_assert_nonnull (paint);
|
||
hb_raster_paint_set_transform (paint, 1000.f, 0.f, 0.f, 1000.f, 0.f, 0.f);
|
||
hb_raster_paint_set_glyph_extents (paint, &gext);
|
||
hb_raster_paint_destroy (paint);
|
||
}
|
||
|
||
/* ── Test 9: shared work-budget lifecycle ───────────────────────── */
|
||
|
||
static void
|
||
test_budget (void)
|
||
{
|
||
hb_face_t *face = hb_test_open_font_file ("fonts/glyphs.ttf");
|
||
hb_font_t *font = hb_font_create (face);
|
||
|
||
hb_raster_draw_t *draw = hb_raster_draw_create_or_fail ();
|
||
hb_draw_funcs_t *draw_funcs = hb_raster_draw_get_funcs (draw);
|
||
g_assert_cmpint (hb_draw_get_budget (draw_funcs, draw), ==, HB_BUDGET_DEFAULT);
|
||
g_assert_cmpint (hb_draw_get_budget_remaining (draw_funcs, draw), >, 0);
|
||
g_assert_cmpint (hb_draw_get_budget_remaining (draw_funcs, draw), <, HB_BUDGET_UNLIMITED);
|
||
|
||
g_assert_true (hb_draw_set_budget (draw_funcs, draw, 1));
|
||
hb_raster_draw_glyph (draw, font, 0);
|
||
g_assert_cmpint (hb_draw_get_budget_remaining (draw_funcs, draw), <, 0);
|
||
hb_raster_draw_clear (draw);
|
||
g_assert_cmpint (hb_draw_get_budget (draw_funcs, draw), ==, 1);
|
||
g_assert_cmpint (hb_draw_get_budget_remaining (draw_funcs, draw), ==, 1);
|
||
hb_raster_draw_reset (draw);
|
||
g_assert_cmpint (hb_draw_get_budget (draw_funcs, draw), ==, HB_BUDGET_DEFAULT);
|
||
g_assert_cmpint (hb_draw_get_budget_remaining (draw_funcs, draw), >, 0);
|
||
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
hb_paint_funcs_t *paint_funcs = hb_raster_paint_get_funcs (paint);
|
||
g_assert_cmpint (hb_paint_get_budget (paint_funcs, paint), ==, HB_BUDGET_DEFAULT);
|
||
g_assert_cmpint (hb_paint_get_budget_remaining (paint_funcs, paint), >, 0);
|
||
g_assert_cmpint (hb_paint_get_budget_remaining (paint_funcs, paint), <, HB_BUDGET_UNLIMITED);
|
||
|
||
hb_raster_extents_t extents = {0, 0, 1, 1, 0};
|
||
hb_raster_paint_set_extents (paint, &extents);
|
||
g_assert_true (hb_paint_set_budget (paint_funcs, paint, 2));
|
||
hb_raster_paint_glyph (paint, font, 0);
|
||
g_assert_cmpint (hb_paint_get_budget_remaining (paint_funcs, paint), <, 0);
|
||
hb_raster_paint_clear (paint);
|
||
g_assert_cmpint (hb_paint_get_budget (paint_funcs, paint), ==, 2);
|
||
g_assert_cmpint (hb_paint_get_budget_remaining (paint_funcs, paint), ==, 2);
|
||
hb_raster_paint_reset (paint);
|
||
g_assert_cmpint (hb_paint_get_budget (paint_funcs, paint), ==, HB_BUDGET_DEFAULT);
|
||
g_assert_cmpint (hb_paint_get_budget_remaining (paint_funcs, paint), >, 0);
|
||
|
||
g_assert_true (hb_draw_set_budget (draw_funcs, draw, HB_BUDGET_UNLIMITED));
|
||
g_assert_cmpint (hb_draw_get_budget_remaining (draw_funcs, draw), ==, HB_BUDGET_UNLIMITED);
|
||
g_assert_true (hb_paint_set_budget (paint_funcs, paint, HB_BUDGET_UNLIMITED));
|
||
g_assert_cmpint (hb_paint_get_budget_remaining (paint_funcs, paint), ==, HB_BUDGET_UNLIMITED);
|
||
|
||
hb_raster_paint_destroy (paint);
|
||
hb_raster_draw_destroy (draw);
|
||
hb_font_destroy (font);
|
||
hb_face_destroy (face);
|
||
}
|
||
|
||
/* ── Test 10: outline budget bounds a real COLR walk, apart from pixels ─ */
|
||
|
||
/* The paint session's outline and pixel budgets are separate. A 1x1
|
||
* surface makes the pixel budget effectively unbounded, so only the
|
||
* outline budget can bound a multi-layer COLR glyph here -- which
|
||
* requires the outline work of every layer to aggregate into one counter
|
||
* through the public seed/readback transfer. A broken transfer (no
|
||
* readback, or a re-armed counter) would leave the budget positive. */
|
||
static void
|
||
test_budget_colr_outline (void)
|
||
{
|
||
hb_face_t *face = hb_test_open_font_file ("fonts/COLRv0.extents.ttf");
|
||
hb_font_t *font = hb_font_create (face);
|
||
const hb_codepoint_t colr_glyph = 13; /* 5 COLR layers */
|
||
hb_raster_extents_t extents = {0, 0, 1, 1, 0};
|
||
|
||
/* Large outline budget: the walk completes, and real outline work is
|
||
* charged back (the counter drops below the configured cap). */
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
hb_raster_paint_set_extents (paint, &extents);
|
||
g_assert_true (hb_paint_set_budget (funcs, paint, 1 << 20));
|
||
hb_raster_paint_glyph (paint, font, colr_glyph);
|
||
int64_t remaining = hb_paint_get_budget_remaining (funcs, paint);
|
||
g_assert_cmpint (remaining, <, 1 << 20); /* outline work aggregated back */
|
||
g_assert_cmpint (remaining, >=, 0); /* not depleted at this budget */
|
||
hb_raster_paint_destroy (paint);
|
||
|
||
/* Tiny outline budget: the aggregate walk is bounded by it, not by the
|
||
* (unbounded) pixel budget of the 1x1 surface. */
|
||
paint = hb_raster_paint_create_or_fail ();
|
||
funcs = hb_raster_paint_get_funcs (paint);
|
||
hb_raster_paint_set_extents (paint, &extents);
|
||
g_assert_true (hb_paint_set_budget (funcs, paint, 1));
|
||
hb_raster_paint_glyph (paint, font, colr_glyph);
|
||
g_assert_cmpint (hb_paint_get_budget_remaining (funcs, paint), <, 0);
|
||
hb_raster_paint_destroy (paint);
|
||
|
||
hb_font_destroy (font);
|
||
hb_face_destroy (face);
|
||
}
|
||
|
||
/* ── Test 11: background color is premultiplied before filling ─────── */
|
||
|
||
/* hb_raster_paint_set_background() must store the premultiplied BGRA32
|
||
* pixel in the buffer, matching the format every other paint op in this
|
||
* file assumes (see hb-raster.hh's SRC_OVER: "premultiplied src over
|
||
* premultiplied dst"), not the raw unpremultiplied channel bytes. */
|
||
static void
|
||
test_background_premultiplied (void)
|
||
{
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
|
||
const unsigned width = 2, height = 2;
|
||
hb_raster_extents_t ext = {0, 0, width, height, 0};
|
||
hb_raster_paint_set_extents (paint, &ext);
|
||
|
||
/* Half-alpha opaque red: blue=0, green=0, red=255, alpha=128.
|
||
* Premultiplied: r = div255(255*128) = 128, a stays 128. */
|
||
hb_raster_paint_set_background (paint, HB_COLOR (0, 0, 255, 128));
|
||
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
hb_paint_push_clip_rectangle (funcs, paint, 0.f, 0.f, (float) width, (float) height);
|
||
hb_paint_pop_clip (funcs, paint);
|
||
|
||
hb_raster_image_t *img = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (img);
|
||
|
||
hb_raster_extents_t out_ext;
|
||
hb_raster_image_get_extents (img, &out_ext);
|
||
const uint8_t *buf = hb_raster_image_get_buffer (img);
|
||
|
||
for (unsigned y = 0; y < out_ext.height; y++)
|
||
{
|
||
const uint8_t *row = buf + (size_t) y * out_ext.stride;
|
||
for (unsigned x = 0; x < out_ext.width; x++)
|
||
{
|
||
const uint8_t *pixel = row + x * 4;
|
||
g_assert_cmphex (pixel[0], ==, 0x00);
|
||
g_assert_cmphex (pixel[1], ==, 0x00);
|
||
g_assert_cmphex (pixel[2], ==, 0x80);
|
||
g_assert_cmphex (pixel[3], ==, 0x80);
|
||
}
|
||
}
|
||
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_paint_destroy (paint);
|
||
}
|
||
|
||
/* ── Test 12: background pre-fill honors a stride wider than width*4 ── */
|
||
|
||
/* hb_raster_paint_set_background() must pre-fill every pixel of the
|
||
* output image with the premultiplied BGRA32 background color, honoring
|
||
* a caller-supplied stride wider than width * 4 bytes. */
|
||
static void
|
||
test_background_stride (void)
|
||
{
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
|
||
const unsigned width = 2, height = 4;
|
||
const unsigned stride = 9; /* wider than width * 4, but not word-aligned */
|
||
hb_raster_extents_t ext = {0, 0, width, height, stride};
|
||
hb_raster_paint_set_extents (paint, &ext);
|
||
|
||
/* Opaque red: blue=0, green=0, red=255, alpha=255. */
|
||
hb_raster_paint_set_background (paint, HB_COLOR (0, 0, 255, 255));
|
||
|
||
/* Trigger initialization without painting any pixels directly, so the
|
||
* only thing that can have colored a pixel is the background fill. */
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
hb_paint_push_clip_rectangle (funcs, paint, 0.f, 0.f, (float) width, (float) height);
|
||
hb_paint_pop_clip (funcs, paint);
|
||
|
||
hb_raster_image_t *img = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (img);
|
||
|
||
hb_raster_extents_t out_ext;
|
||
hb_raster_image_get_extents (img, &out_ext);
|
||
const uint8_t *buf = hb_raster_image_get_buffer (img);
|
||
|
||
for (unsigned y = 0; y < out_ext.height; y++)
|
||
{
|
||
const uint8_t *row = buf + (size_t) y * out_ext.stride;
|
||
for (unsigned x = 0; x < out_ext.width; x++)
|
||
{
|
||
const uint8_t *pixel = row + x * 4;
|
||
g_assert_cmphex (pixel[0], ==, 0x00); /* blue */
|
||
g_assert_cmphex (pixel[1], ==, 0x00); /* green */
|
||
g_assert_cmphex (pixel[2], ==, 0xff); /* red */
|
||
g_assert_cmphex (pixel[3], ==, 0xff); /* alpha */
|
||
}
|
||
}
|
||
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_paint_destroy (paint);
|
||
}
|
||
|
||
static void
|
||
test_paint_reset (void)
|
||
{
|
||
hb_raster_paint_t *fresh = hb_raster_paint_create_or_fail ();
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
g_assert_nonnull (fresh);
|
||
g_assert_nonnull (paint);
|
||
|
||
hb_color_t background = HB_COLOR (0, 255, 0, 255);
|
||
hb_raster_paint_set_background (paint, background);
|
||
hb_raster_paint_set_palette (paint, 7);
|
||
hb_raster_paint_clear (paint);
|
||
g_assert_cmphex (hb_raster_paint_get_background (paint), ==, background);
|
||
g_assert_cmpuint (hb_raster_paint_get_palette (paint), ==, 7);
|
||
|
||
/* Populate the image cache with output using the old background. */
|
||
hb_raster_extents_t ext = {0, 0, 1, 1, 0};
|
||
hb_raster_paint_set_extents (paint, &ext);
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
hb_paint_push_clip_rectangle (funcs, paint, 0.f, 0.f, 1.f, 1.f);
|
||
hb_paint_pop_clip (funcs, paint);
|
||
hb_raster_image_t *image = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (image);
|
||
g_assert_cmpuint (hb_raster_image_get_buffer (image)[3], ==, 255);
|
||
hb_raster_paint_recycle_image (paint, image);
|
||
|
||
hb_raster_paint_reset (paint);
|
||
g_assert_cmphex (hb_raster_paint_get_background (paint), ==,
|
||
hb_raster_paint_get_background (fresh));
|
||
g_assert_cmpuint (hb_raster_paint_get_palette (paint), ==,
|
||
hb_raster_paint_get_palette (fresh));
|
||
|
||
hb_raster_paint_set_extents (paint, &ext);
|
||
hb_paint_push_clip_rectangle (funcs, paint, 0.f, 0.f, 1.f, 1.f);
|
||
hb_paint_pop_clip (funcs, paint);
|
||
image = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (image);
|
||
g_assert_cmpuint (hb_raster_image_get_buffer (image)[3], ==, 0);
|
||
hb_raster_image_destroy (image);
|
||
hb_raster_paint_destroy (paint);
|
||
hb_raster_paint_destroy (fresh);
|
||
}
|
||
|
||
/* Changing extents while a paint is in progress must not shrink group
|
||
* surfaces below the root surface and initial clip they composite onto. */
|
||
static void
|
||
test_set_extents_while_painting (void)
|
||
{
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
g_assert_nonnull (paint);
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
|
||
hb_raster_extents_t big = {0, 0, 64, 64, 0};
|
||
hb_raster_extents_t small = {0, 0, 4, 4, 0};
|
||
hb_raster_paint_set_extents (paint, &big);
|
||
hb_paint_color (funcs, paint, true, HB_COLOR (255, 0, 0, 255));
|
||
|
||
hb_raster_paint_set_extents (paint, &small);
|
||
hb_paint_push_group (funcs, paint);
|
||
hb_paint_color (funcs, paint, true, HB_COLOR (0, 0, 255, 255));
|
||
hb_paint_pop_group (funcs, paint, HB_PAINT_COMPOSITE_MODE_SRC_OVER);
|
||
|
||
hb_raster_image_t *img = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (img);
|
||
|
||
hb_raster_extents_t out_ext;
|
||
hb_raster_image_get_extents (img, &out_ext);
|
||
g_assert_cmpuint (out_ext.width, ==, big.width);
|
||
g_assert_cmpuint (out_ext.height, ==, big.height);
|
||
|
||
const uint8_t *buf = hb_raster_image_get_buffer (img);
|
||
for (unsigned y = 0; y < out_ext.height; y++)
|
||
{
|
||
const uint8_t *row = buf + (size_t) y * out_ext.stride;
|
||
for (unsigned x = 0; x < out_ext.width; x++)
|
||
{
|
||
const uint8_t *pixel = row + x * 4;
|
||
g_assert_cmphex (pixel[0], ==, 0x00); /* blue */
|
||
g_assert_cmphex (pixel[1], ==, 0x00); /* green */
|
||
g_assert_cmphex (pixel[2], ==, 0xff); /* red */
|
||
g_assert_cmphex (pixel[3], ==, 0xff); /* alpha */
|
||
}
|
||
}
|
||
|
||
hb_raster_image_destroy (img);
|
||
/* The changed extents are cleared, not deferred to another render. */
|
||
g_assert_false (hb_raster_paint_get_extents (paint, nullptr));
|
||
g_assert_null (hb_raster_paint_render (paint));
|
||
hb_raster_paint_set_extents (paint, &small);
|
||
hb_paint_color (funcs, paint, true, HB_COLOR (0, 0, 255, 255));
|
||
img = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (img);
|
||
hb_raster_image_get_extents (img, &out_ext);
|
||
g_assert_cmpuint (out_ext.width, ==, small.width);
|
||
g_assert_cmpuint (out_ext.height, ==, small.height);
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_paint_destroy (paint);
|
||
}
|
||
|
||
static void
|
||
test_clip_rectangle_transformed (void)
|
||
{
|
||
const struct {
|
||
float xx, yx, xy, yy, dx, dy;
|
||
unsigned center_x;
|
||
} transforms[] = {
|
||
{1.f, 0.f, 0.2f, 1.f, 0.f, 0.f, 38},
|
||
{1.f, 0.f, 0.2f, -1.f, 0.f, 64.f, 38},
|
||
{0.f, 1.f, -1.f, 0.f, 64.f, 0.f, 32},
|
||
};
|
||
|
||
/* Cover both winding orders and intersecting with a rectangle or mask. */
|
||
for (const auto &t : transforms)
|
||
for (unsigned depth = 1; depth <= 2; depth++)
|
||
{
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
g_assert_nonnull (paint);
|
||
hb_raster_extents_t ext = {0, 0, 64, 64, 0};
|
||
hb_raster_paint_set_extents (paint, &ext);
|
||
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
hb_paint_push_transform (funcs, paint, t.xx, t.yx, t.xy, t.yy, t.dx, t.dy);
|
||
for (unsigned i = 0; i < depth; i++)
|
||
hb_paint_push_clip_rectangle (funcs, paint, 16.f, 16.f, 48.f, 48.f);
|
||
hb_paint_color (funcs, paint, true, HB_COLOR (0, 0, 0, 255));
|
||
for (unsigned i = 0; i < depth; i++)
|
||
hb_paint_pop_clip (funcs, paint);
|
||
hb_paint_pop_transform (funcs, paint);
|
||
|
||
hb_raster_image_t *image = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (image);
|
||
hb_raster_extents_t out_ext;
|
||
hb_raster_image_get_extents (image, &out_ext);
|
||
const uint8_t *buffer = hb_raster_image_get_buffer (image);
|
||
/* The transformed center is opaque; the corner is outside the clip. */
|
||
g_assert_cmpuint (buffer[32 * out_ext.stride + t.center_x * 4 + 3], ==, 255);
|
||
g_assert_cmpuint (buffer[3], ==, 0);
|
||
|
||
hb_raster_image_destroy (image);
|
||
hb_raster_paint_destroy (paint);
|
||
}
|
||
}
|
||
|
||
/* Raw BGRA input and SRC_OVER must use the same byte order, including
|
||
* on rows that are not word-aligned. */
|
||
static void
|
||
test_image_bgra (void)
|
||
{
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
hb_raster_extents_t ext = {0, 0, 2, 2, 9};
|
||
hb_raster_paint_set_extents (paint, &ext);
|
||
hb_raster_paint_set_background (paint, HB_COLOR (0, 0, 0, 255));
|
||
const char pixels[] = {16, 32, 48, (char) 128, 16, 32, 48, (char) 128,
|
||
16, 32, 48, (char) 128, 16, 32, 48, (char) 128};
|
||
hb_blob_t *blob = hb_blob_create (pixels, sizeof (pixels),
|
||
HB_MEMORY_MODE_READONLY, nullptr, nullptr);
|
||
hb_glyph_extents_t gext = {0, 1, 2, -2};
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
hb_paint_push_group (funcs, paint);
|
||
hb_paint_image (funcs, paint, blob, 2, 2,
|
||
HB_PAINT_IMAGE_FORMAT_BGRA, 0.f, &gext);
|
||
hb_paint_pop_group (funcs, paint, HB_PAINT_COMPOSITE_MODE_SRC_OVER);
|
||
hb_raster_image_t *img = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (img);
|
||
hb_raster_image_get_extents (img, &ext);
|
||
const uint8_t expected[] = {16, 32, 48, 255};
|
||
for (unsigned y = 0; y < ext.height; y++)
|
||
for (unsigned x = 0; x < ext.width; x++)
|
||
g_assert_cmpmem (hb_raster_image_get_buffer (img) + y * ext.stride + x * 4,
|
||
4, expected, 4);
|
||
hb_raster_image_destroy (img);
|
||
hb_blob_destroy (blob);
|
||
hb_raster_paint_destroy (paint);
|
||
}
|
||
|
||
static void
|
||
test_image_png_byte_order (void)
|
||
{
|
||
#ifndef HAVE_PNG
|
||
g_test_skip ("Built without PNG support.");
|
||
#else
|
||
/* A 1x1 RGBA PNG: red=96, green=64, blue=32, alpha=128. */
|
||
static const uint8_t data[] = {
|
||
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
|
||
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
|
||
0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0x15, 0xc4, 0x89, 0x00, 0x00, 0x00,
|
||
0x0d, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0x63, 0x48, 0x70, 0x50, 0x68,
|
||
0x00, 0x00, 0x03, 0x05, 0x01, 0x41, 0x9e, 0xec, 0x86, 0x30, 0x00, 0x00,
|
||
0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
|
||
};
|
||
hb_blob_t *png = hb_blob_create ((const char *) data, sizeof (data),
|
||
HB_MEMORY_MODE_READONLY, nullptr, nullptr);
|
||
hb_raster_image_t *img = hb_raster_image_create_or_fail ();
|
||
g_assert_nonnull (img);
|
||
g_assert_true (hb_raster_image_deserialize_from_png_or_fail (img, png));
|
||
hb_blob_destroy (png);
|
||
const uint8_t expected[] = {16, 32, 48, 128};
|
||
g_assert_cmpmem (hb_raster_image_get_buffer (img), 4, expected, 4);
|
||
|
||
png = hb_raster_image_serialize_to_png_or_fail (img);
|
||
g_assert_nonnull (png);
|
||
g_assert_true (hb_raster_image_deserialize_from_png_or_fail (img, png));
|
||
g_assert_cmpmem (hb_raster_image_get_buffer (img), 4, expected, 4);
|
||
hb_blob_destroy (png);
|
||
hb_raster_image_destroy (img);
|
||
#endif
|
||
}
|
||
|
||
/* Paint the middle of an opaque PNG image of the given width onto a 1x1
|
||
* surface; returns the resulting alpha, or -1 if built without PNG. */
|
||
static int
|
||
paint_png_image (unsigned width)
|
||
{
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
g_assert_nonnull (paint);
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
|
||
hb_raster_extents_t ext = {0, 0, width, 4, 0};
|
||
hb_raster_paint_set_extents (paint, &ext);
|
||
hb_paint_color (funcs, paint, false, HB_COLOR (0, 0, 0, 255));
|
||
hb_raster_image_t *img = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (img);
|
||
hb_blob_t *png = hb_raster_image_serialize_to_png_or_fail (img);
|
||
hb_raster_image_destroy (img);
|
||
if (!png)
|
||
{
|
||
hb_raster_paint_destroy (paint);
|
||
return -1;
|
||
}
|
||
|
||
ext.width = ext.height = 1;
|
||
hb_raster_paint_set_extents (paint, &ext);
|
||
hb_glyph_extents_t gext = {-2, 2, 4, -4};
|
||
hb_paint_image (funcs, paint, png, width, 4,
|
||
HB_PAINT_IMAGE_FORMAT_PNG, 0.f, &gext);
|
||
img = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (img);
|
||
int alpha = hb_raster_image_get_buffer (img)[3];
|
||
hb_raster_image_destroy (img);
|
||
|
||
hb_blob_destroy (png);
|
||
hb_raster_paint_destroy (paint);
|
||
return alpha;
|
||
}
|
||
|
||
/* The size of an embedded PNG is font data and the whole image is decoded
|
||
* whatever the size of the surface; one past the cap for surfaces sized
|
||
* from font data is not decoded at all. */
|
||
static void
|
||
test_image_png_size (void)
|
||
{
|
||
int alpha = paint_png_image (4096);
|
||
if (alpha == -1)
|
||
{
|
||
g_test_skip ("Built without PNG support.");
|
||
return;
|
||
}
|
||
g_assert_cmpint (alpha, ==, 255);
|
||
g_assert_cmpint (paint_png_image (4097), ==, 0);
|
||
}
|
||
|
||
/* The sweep costs edges times the rows they span, within the extents that
|
||
* are rendered: the fixed ones, or else those of the outline itself. The
|
||
* latter holds for the masks of a paint session too, whatever its surface. */
|
||
static void
|
||
test_budget_sweep (void)
|
||
{
|
||
hb_raster_extents_t extents = {0, 0, 1, 1, 0};
|
||
|
||
/* 20,000 edges of 4,096 rows each: over budget, so rendering fails. */
|
||
hb_raster_draw_t *rdr = hb_raster_draw_create_or_fail ();
|
||
for (unsigned i = 0; i < 10000; i++)
|
||
draw_rect (rdr, 0.f, 0.f, 1.f, 4096.f);
|
||
hb_raster_image_t *img = hb_raster_draw_render (rdr);
|
||
g_assert_null (img);
|
||
|
||
/* The same edges, clipped to one row. */
|
||
hb_raster_draw_set_extents (rdr, &extents);
|
||
for (unsigned i = 0; i < 10000; i++)
|
||
draw_rect (rdr, 0.f, 0.f, 1.f, 4096.f);
|
||
img = hb_raster_draw_render (rdr);
|
||
g_assert_nonnull (img);
|
||
g_assert_cmpint (pixel_at (img, 0, 0), ==, 255);
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_draw_destroy (rdr);
|
||
|
||
hb_raster_paint_t *paint = hb_raster_paint_create_or_fail ();
|
||
hb_paint_funcs_t *funcs = hb_raster_paint_get_funcs (paint);
|
||
hb_raster_paint_set_extents (paint, &extents);
|
||
void *draw_data;
|
||
hb_paint_push_clip_path_start (funcs, paint, &draw_data);
|
||
g_assert_nonnull (draw_data);
|
||
for (unsigned i = 0; i < 10000; i++)
|
||
draw_rect ((hb_raster_draw_t *) draw_data, 0.f, 0.f, 1.f, 4096.f);
|
||
hb_paint_push_clip_path_end (funcs, paint);
|
||
hb_paint_color (funcs, paint, false, HB_COLOR (0, 0, 0, 255));
|
||
hb_paint_pop_clip (funcs, paint);
|
||
img = hb_raster_paint_render (paint);
|
||
g_assert_nonnull (img);
|
||
g_assert_cmpuint (hb_raster_image_get_buffer (img)[3], ==, 0);
|
||
hb_raster_image_destroy (img);
|
||
hb_raster_paint_destroy (paint);
|
||
}
|
||
|
||
/* ── main ────────────────────────────────────────────────────────── */
|
||
|
||
int
|
||
main (int argc, char **argv)
|
||
{
|
||
hb_test_init (&argc, &argv);
|
||
|
||
hb_test_add (test_rectangle);
|
||
hb_test_add (test_accumulate);
|
||
hb_test_add (test_subpixel_edge);
|
||
hb_test_add (test_many_coincident_edges);
|
||
hb_test_add (test_transform);
|
||
hb_test_add (test_set_glyph_extents_with_transform);
|
||
hb_test_add (test_image_nonfinite_transform);
|
||
hb_test_add (test_set_glyph_extents_overflow);
|
||
hb_test_add (test_budget);
|
||
hb_test_add (test_budget_colr_outline);
|
||
hb_test_add (test_background_premultiplied);
|
||
hb_test_add (test_background_stride);
|
||
hb_test_add (test_paint_reset);
|
||
hb_test_add (test_set_extents_while_painting);
|
||
hb_test_add (test_clip_rectangle_transformed);
|
||
hb_test_add (test_image_bgra);
|
||
hb_test_add (test_image_png_byte_order);
|
||
hb_test_add (test_image_png_size);
|
||
hb_test_add (test_budget_sweep);
|
||
|
||
return hb_test_run ();
|
||
}
|