Fichiers
ui/test/test_raster_golden.cpp
T
2026-10-11 01:55:22 +02:00

275 lignes
9.5 KiB
C++

// test/test_raster_golden.cpp — VALIDATION DU PORTAGE DU RASTERIZER.
//
// Compare, octet par octet, la sortie du code porte (proj3) a une reference
// produite par le code d ORIGINE de Gastinel Write (tools/write_reference_dump.cpp).
// Une divergence est un bug de portage, pas une tolerance a accorder.
//
// Ce test tourne sur la machine de dev. Ni telephone, ni affichage.
//
// NOTE SUR LA LECTURE DE FICHIER. Le rasterizer et le parser ne lisent aucun
// fichier : c est l appelant qui fournit un tampon en memoire. C est le
// decouplage demande au chantier 5 (l original appelait fopen depuis
// TtfFont::load_from_file). Ici, l appelant est ce test, sur la cible hote,
// et il utilise donc stdio. Sur la cible embarquee, l appelant utilisera
// sys::open / sys::read. Aucune des deux voies ne traverse le rasterizer.
//
// Ce binaire lie proj3_newguard : si le portage avait laisse une allocation
// dynamique quelque part, il mourrait ici avec le code 71.
#include <cstdio>
#include "proj3/font/ttf.hpp"
#include "proj3/mem/system.hpp"
#include "proj3/render/rasterizer.hpp"
#include "proj3/sys/panic.hpp"
using namespace proj3;
namespace {
int g_failures = 0;
int g_lines = 0;
// Lecture d un fichier entier dans une arene. stdio est autorise ici (cible
// hote) ; fread n alloue pas via operator new, le garde-fou reste satisfait.
u8* read_all(const char* path, mem::Arena& a, usize& out_size) {
std::FILE* f = std::fopen(path, "rb");
if (!f) return nullptr;
std::fseek(f, 0, SEEK_END);
const long n = std::ftell(f);
std::fseek(f, 0, SEEK_SET);
if (n <= 0) {
std::fclose(f);
return nullptr;
}
u8* buf = a.alloc_array<u8>(static_cast<usize>(n) + 1);
const usize got = std::fread(buf, 1, static_cast<usize>(n), f);
std::fclose(f);
if (got != static_cast<usize>(n)) return nullptr;
buf[n] = 0;
out_size = static_cast<usize>(n);
return buf;
}
// --- Analyse lexicale minimale du fichier golden ---------------------------
struct Cursor {
const char* p;
const char* end;
};
void skip_spaces(Cursor& c) {
while (c.p < c.end && (*c.p == ' ' || *c.p == '\t')) ++c.p;
}
bool parse_u32(Cursor& c, u32& out) {
skip_spaces(c);
if (c.p >= c.end || *c.p < '0' || *c.p > '9') return false;
u32 v = 0;
while (c.p < c.end && *c.p >= '0' && *c.p <= '9') v = v * 10u + static_cast<u32>(*c.p++ - '0');
out = v;
return true;
}
bool parse_i32(Cursor& c, i32& out) {
skip_spaces(c);
bool neg = false;
if (c.p < c.end && *c.p == '-') {
neg = true;
++c.p;
}
u32 v = 0;
if (!parse_u32(c, v)) return false;
out = neg ? -static_cast<i32>(v) : static_cast<i32>(v);
return true;
}
// Les tailles sont ecrites par %g et sont toutes entieres dans le jeu de test.
// On accepte quand meme une partie fractionnaire, pour que le format ne se
// referme pas sur une hypothese.
bool parse_f32(Cursor& c, f32& out) {
skip_spaces(c);
i32 whole = 0;
if (!parse_i32(c, whole)) return false;
f32 v = static_cast<f32>(whole);
if (c.p < c.end && *c.p == '.') {
++c.p;
f32 scale = 0.1f;
while (c.p < c.end && *c.p >= '0' && *c.p <= '9') {
v += static_cast<f32>(*c.p++ - '0') * scale;
scale *= 0.1f;
}
}
out = v;
return true;
}
i32 hex_digit(char ch) {
if (ch >= '0' && ch <= '9') return ch - '0';
if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
return -1;
}
void fail(const char* what, u32 cp, f32 px) {
++g_failures;
err_write("ECHEC ");
err_write(what);
err_write(" codepoint=");
err_write_hex(cp);
err_write(" taille=");
err_write_i64(static_cast<i64>(px));
err_write("\n");
}
} // namespace
int main(int argc, char** argv) {
if (argc < 3) {
err_write("usage: proj3_test_raster <police.ttf> <golden_write.txt>\n");
return 2;
}
static mem::System sys;
if (!mem::system_init(sys)) {
err_write("acquisition memoire impossible\n");
return 2;
}
// Les deux fichiers vivent dans l arene de scanout, qui est la plus grande
// et n a aucun usage a ce stade des chantiers. C est un detournement
// assume et local a ce test.
usize ttf_size = 0, golden_size = 0;
const u8* ttf = read_all(argv[1], sys.scanout, ttf_size);
if (ttf == nullptr) {
err_write("police illisible\n");
return 2;
}
const u8* golden = read_all(argv[2], sys.scanout, golden_size);
if (golden == nullptr) {
err_write("fichier golden illisible : lancer d abord proj3_write_reference\n");
return 2;
}
font::TtfFont f;
const char* err = nullptr;
if (!f.load(ttf, ttf_size, sys.atlas, err)) {
err_write("chargement TTF : ");
err_write(err);
err_write("\n");
return 2;
}
err_write("police chargee : upem=");
err_write_i64(f.units_per_em());
err_write(" glyphes=");
err_write_i64(f.num_glyphs());
err_write(" entrees cmap=");
err_write_i64(f.cmap_size());
err_write("\n\n");
font::GlyphBuilder builder;
builder.init(sys.atlas);
Cursor c{reinterpret_cast<const char*>(golden),
reinterpret_cast<const char*>(golden) + golden_size};
while (c.p < c.end) {
// Une ligne a la fois.
const char* line_end = c.p;
while (line_end < c.end && *line_end != '\n') ++line_end;
Cursor line{c.p, line_end};
c.p = (line_end < c.end) ? line_end + 1 : c.end;
skip_spaces(line);
if (line.p >= line.end || *line.p == '#' || *line.p == '\r') continue;
u32 cp = 0, gid_ref = 0, ok_ref = 0;
f32 px = 0.0f;
i32 w_ref = 0, h_ref = 0, bx_ref = 0, by_ref = 0, adv_ref = 0;
if (!parse_u32(line, cp) || !parse_f32(line, px) || !parse_u32(line, gid_ref) ||
!parse_u32(line, ok_ref) || !parse_i32(line, w_ref) || !parse_i32(line, h_ref) ||
!parse_i32(line, bx_ref) || !parse_i32(line, by_ref) || !parse_i32(line, adv_ref)) {
err_write("ECHEC ligne golden malformee\n");
++g_failures;
continue;
}
skip_spaces(line);
const char* hex = line.p;
usize hex_len = 0;
while (line.p < line.end && hex_digit(*line.p) >= 0) {
++line.p;
++hex_len;
}
++g_lines;
// --- Cote proj3 -----------------------------------------------------
const u16 gid = f.glyph_index_for_codepoint(cp);
if (static_cast<u32>(gid) != gid_ref) {
fail("index de glyphe different (cmap)", cp, px);
continue;
}
font::Glyph g;
f.load_glyph(gid, builder, g);
const usize m_atlas = sys.atlas.mark();
const usize m_geo = sys.geometry.mark();
render::RasterizedGlyph rg;
const bool ok = render::rasterize_glyph(g, f.units_per_em(), px, sys.atlas,
sys.geometry, rg);
if (ok != (ok_ref != 0)) {
fail("rasterize_glyph : succes/echec different", cp, px);
} else if (!ok) {
// Glyphe vide : seule l avance a un sens, et elle doit coincider.
if (rg.advance != adv_ref) fail("avance differente (glyphe vide)", cp, px);
} else {
if (rg.coverage.width != w_ref || rg.coverage.height != h_ref) {
fail("dimensions du bitmap differentes", cp, px);
} else if (rg.bearing_x != bx_ref || rg.bearing_y != by_ref) {
fail("bearing different", cp, px);
} else if (rg.advance != adv_ref) {
fail("avance differente", cp, px);
} else if (hex_len != rg.coverage.size_bytes() * 2) {
fail("longueur de couverture differente", cp, px);
} else {
// Comparaison octet par octet. Aucun epsilon : la couverture
// est binaire, l egalite doit etre exacte.
usize bad = rg.coverage.size_bytes();
for (usize i = 0; i < rg.coverage.size_bytes(); ++i) {
const i32 hi = hex_digit(hex[i * 2]);
const i32 lo = hex_digit(hex[i * 2 + 1]);
const u8 expect = static_cast<u8>((hi << 4) | lo);
if (rg.coverage.pixels[i] != expect) {
bad = i;
break;
}
}
if (bad != rg.coverage.size_bytes()) {
fail("pixel divergent", cp, px);
err_write(" premier octet divergent a l offset ");
err_write_i64(static_cast<i64>(bad));
err_write(" (x=");
err_write_i64(static_cast<i64>(bad % static_cast<usize>(w_ref)));
err_write(" y=");
err_write_i64(static_cast<i64>(bad / static_cast<usize>(w_ref)));
err_write(") attendu=");
err_write_hex(static_cast<u64>((hex_digit(hex[bad * 2]) << 4) |
hex_digit(hex[bad * 2 + 1])));
err_write(" obtenu=");
err_write_hex(rg.coverage.pixels[bad]);
err_write("\n");
}
}
}
sys.geometry.rewind_to(m_geo);
sys.atlas.rewind_to(m_atlas);
}
err_write("\nlignes comparees : ");
err_write_i64(g_lines);
err_write("\nechecs : ");
err_write_i64(g_failures);
err_write("\n");
return g_failures == 0 ? 0 : 1;
}