mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-20 14:31:10 +01:00
* [raster] Bound embedded PNG dimensions before decoding hb_raster_paint_image() handed a font's embedded sbix/CBDT PNG to deserialize_from_png(), which allocated and filled the whole image at whatever size the PNG's IHDR declared (up to two buffers at the 1 GiB HB_RASTER_MAX_BUFFER_SIZE cap each), and only charged src_width * src_height against the pixel budget after the decode had finished. A 33 KB sbix font with a blank 16384x16384 1-bit PNG therefore made the raster backend allocate and touch ~2 GiB of memory per painted glyph, independent of the requested output size. Surfaces whose size comes from font data are already clamped to HB_RASTER_MAX_AUTO_DIMENSION (4096 per side); the PNG decoder was not. deserialize_from_png() gains a max_dimension parameter checked right after png_get_IHDR(), before any allocation, and the paint callback passes HB_RASTER_MAX_AUTO_DIMENSION. The public hb_raster_image_deserialize_from_png_or_fail() keeps its INT_MAX behaviour through the default argument, matching the limit's documented intent that explicitly requested sizes are not bounded. With the cap a decode is at most 16M pixels, whose cost fits the 2^26 pixel budget, so the later charge_work() is adequate. Behaviour change: sbix/CBDT PNG glyphs wider or taller than 4096 pixels are no longer painted by the raster backend (the callback returns false, as for any undecodable image). The cairo backend has the same weakness on a different code path and was already fixed separately (#6497). test_image_png_size() in test/api/test-raster.cc paints a 4096- and a 4097-pixel-wide PNG and checks that only the former lands; it fails on the unpatched library. Discovered by Anthropic's OSS Scanner, as vulnerability ANT-2026-ENME4ECM. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> * [raster] Charge the scanline sweep to the pixel budget hb_raster_draw_render() walks every active edge once per pixel row it spans, a product (edges times rows) that neither HB_RASTER_MAX_DRAW_EDGES (2^20) nor HB_RASTER_MAX_AUTO_DIMENSION (4096 rows) bounds, and that nothing charged: the outline budget only sees traversal and curve flattening. A 10 KB glyf font of 199,800 full-height straight edges therefore cost tens of seconds of CPU for a single render. PR #6244 added the precharge for the paint path but sized it by the paint *surface*, which comes from the font's declared glyph extents, while the mask rasterizer auto-sizes the mask from the outline itself; a 1x1 ClipBox or empty bounding box slipped the full-height sweep past it. The direct draw path had no check at all. This charges the sweep inside hb_raster_draw_render(), where the extents really rendered are known, estimating it with the existing hb_raster_draw_get_pixel_work() helper, now clamped to those extents (the fixed ones, else the 4096 auto cap) rather than taking them as arguments. The sweep is skipped when the estimate exceeds the per-session pixel allowance raster-paint already uses, max(HB_BUDGET_RASTER_PIXELS, HB_BUDGET_RASTER_PAINT_PASSES * width * height). The two paint callers now use the mask-relative estimate, and hb_raster_paint_attach_clip_rdr() seeds HB_BUDGET_UNLIMITED into the mask rasterizer when the paint policy is unlimited, so opting out of limits still disables the check. hb_raster_draw_get_pixel_work() is HB_INTERNAL, so dropping its two arguments changes no public API/ABI. Behaviour change: an over-budget render returns a blank image of the computed size (documented in the API comment) rather than NULL. Letting HB_BUDGET_UNLIMITED switch the check off matches the paint pixel budget's semantics and keeps the edge and dimension caps active; whether this bound should instead be an unconditional structural cap is a maintainer's choice. Testing: the finding's reproducer flips from BUG to OK, its attack render dropping from ~39 s to 0.05 s of CPU while the control is unchanged; the api suite passes under both the optimized and the ASan/UBSan build. test_budget_sweep in test/api/test-raster.cc covers the direct draw path with auto and fixed extents and the small-surface paint-clip path. Discovered by Anthropic's OSS Scanner, as vulnerability ANT-2026-8PTXE0MD. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
773 lines
28 KiB
C++
773 lines
28 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 uint32_t *row = (const uint32_t *) (buf + (size_t) y * out_ext.stride);
|
||
for (unsigned x = 0; x < out_ext.width; x++)
|
||
/* 0x80800000: alpha=0x80, premultiplied red=0x80, in BGRA memory
|
||
* order. The old HB_COLOR()-based reconstruction produces
|
||
* 0x0000ff80 instead (wrong byte layout, not premultiplied). */
|
||
g_assert_cmphex (row[x], ==, 0x80800000);
|
||
}
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
/* 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. */
|
||
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_nonnull (img);
|
||
g_assert_cmpint (pixel_at (img, 0, 0), ==, 0);
|
||
hb_raster_image_destroy (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_png_size);
|
||
hb_test_add (test_budget_sweep);
|
||
|
||
return hb_test_run ();
|
||
}
|