Premier commit
Cette révision appartient à :
révision
536792a769
62 fichiers modifiés
+6766
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1,274 @@
|
||||
// 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;
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur