// 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 #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(static_cast(n) + 1); const usize got = std::fread(buf, 1, static_cast(n), f); std::fclose(f); if (got != static_cast(n)) return nullptr; buf[n] = 0; out_size = static_cast(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(*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(v) : static_cast(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(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(*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(px)); err_write("\n"); } } // namespace int main(int argc, char** argv) { if (argc < 3) { err_write("usage: proj3_test_raster \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(golden), reinterpret_cast(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(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((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(bad)); err_write(" (x="); err_write_i64(static_cast(bad % static_cast(w_ref))); err_write(" y="); err_write_i64(static_cast(bad / static_cast(w_ref))); err_write(") attendu="); err_write_hex(static_cast((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; }