static void fill_rect(struct test_display *dpy, Picture p, uint8_t op,
int x, int y, int w, int h,
uint8_t s_red, uint8_t s_green, uint8_t s_blue, uint8_t s_alpha,
uint8_t m_red, uint8_t m_green, uint8_t m_blue, uint8_t m_alpha)
{
XRenderColor render_color;
Picture source, mask;
render_color.red = s_red * s_alpha;
render_color.green = s_green * s_alpha;
render_color.blue = s_blue * s_alpha;
render_color.alpha = s_alpha << 8 | s_alpha;
source = XRenderCreateSolidFill(dpy->dpy, &render_color);
render_color.red = m_red * m_alpha;
render_color.green = m_green * m_alpha;
render_color.blue = m_blue * m_alpha;
render_color.alpha = m_alpha << 8 | m_alpha;
mask = XRenderCreateSolidFill(dpy->dpy, &render_color);
XRenderComposite(dpy->dpy, op, source, mask, p, 0, 0, 0, 0, x, y, w,h);
XRenderFreePicture(dpy->dpy, mask);
XRenderFreePicture(dpy->dpy, source);
}
static void fill_rect(struct test_display *dpy, Picture p, uint8_t op,
int x, int y, int w, int h,
int dx, int dy, enum mask mask,
uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)
{
XRenderColor render_color;
XTrapezoid trap;
Picture src;
render_color.red = red * alpha;
render_color.green = green * alpha;
render_color.blue = blue * alpha;
render_color.alpha = alpha << 8;
trap.left.p1.x = trap.left.p2.x = (x << 16) + dx;
trap.top = trap.left.p1.y = trap.right.p1.y = (y << 16) + dy;
trap.right.p1.x = trap.right.p2.x = ((x + w) << 16) + dx;
trap.bottom = trap.left.p2.y = trap.right.p2.y = ((y + h) << 16) + dy;
src = XRenderCreateSolidFill(dpy->dpy, &render_color);
XRenderCompositeTrapezoids(dpy->dpy,
op, src, p, mask_format(dpy->dpy, mask),
0, 0, &trap, 1);
XRenderFreePicture(dpy->dpy, src);
}
static void edge_test(struct test *t,
enum mask mask,
enum edge edge,
enum target target)
{
struct test_target out, ref;
XRenderColor white = { 0xffff, 0xffff, 0xffff, 0xffff };
Picture src_ref, src_out;
XTriangle tri;
unsigned step, max;
test_target_create_render(&t->out, target, &out);
set_edge(t->out.dpy, out.picture, edge);
src_out = XRenderCreateSolidFill(t->out.dpy, &white);
test_target_create_render(&t->ref, target, &ref);
set_edge(t->ref.dpy, ref.picture, edge);
src_ref = XRenderCreateSolidFill(t->ref.dpy, &white);
printf("Testing edges (with mask %s and %s edges) (%s): ",
mask_name(mask),
edge_name(edge),
test_target_name(target));
fflush(stdout);
max = 2*(out.width + 128 + out.height+128);
step = 0;
for (step = 0; step <= max; step++) {
char buf[80];
step_to_point(step, out.width, out.height, &tri.p1);
step_to_point(step + out.width + 128,
out.width, out.height,
&tri.p2);
step_to_point(step + out.height + 128 + 2*(out.width + 128),
out.width, out.height,
&tri.p3);
sprintf(buf,
"tri=((%d, %d), (%d, %d), (%d, %d))\n",
tri.p1.x >> 16, tri.p1.y >> 16,
tri.p2.x >> 16, tri.p2.y >> 16,
tri.p3.x >> 16, tri.p3.y >> 16);
clear(&t->out, &out);
XRenderCompositeTriangles(t->out.dpy,
PictOpSrc,
src_out,
out.picture,
mask_format(t->out.dpy, mask),
0, 0,
&tri, 1);
clear(&t->ref, &ref);
XRenderCompositeTriangles(t->ref.dpy,
PictOpSrc,
src_ref,
ref.picture,
mask_format(t->ref.dpy, mask),
0, 0,
&tri, 1);
test_compare(t,
out.draw, out.format,
ref.draw, ref.format,
0, 0, out.width, out.height,
buf);
}
XRenderFreePicture(t->out.dpy, src_out);
test_target_destroy_render(&t->out, &out);
XRenderFreePicture(t->ref.dpy, src_ref);
test_target_destroy_render(&t->ref, &ref);
printf("pass\n");
}
static Picture source_solid(struct test_display *t, struct test_target *target)
{
XRenderColor render_color = { 0x8000, 0x8000, 0x8000, 0x8000 };
return XRenderCreateSolidFill(t->dpy, &render_color);
}
static bool glyph_iter_next(struct glyph_iter *gi)
{
restart:
if (gi->stage == GLYPHS) {
if (++gi->glyph_format == PictStandardNUM)
return false;
if (gi->out.glyphset)
XRenderFreeGlyphSet(gi->out.dpy->dpy,
gi->out.glyphset);
gi->out.glyphset = create_glyphs(gi->out.dpy->dpy,
gi->glyph_format);
if (gi->ref.glyphset)
XRenderFreeGlyphSet(gi->ref.dpy->dpy,
gi->ref.glyphset);
gi->ref.glyphset = create_glyphs(gi->ref.dpy->dpy,
gi->glyph_format);
gi->stage++;
}
if (gi->stage == OP) {
do {
if (++gi->op == 255)
goto reset_op;
} while (!check_op(gi->out.dpy, gi->op, &gi->out.tt) ||
!check_op(gi->ref.dpy, gi->op, &gi->ref.tt));
gi->stage++;
}
if (gi->stage == DST) {
if (++gi->dst_color == ARRAY_SIZE(colors))
goto reset_dst;
gi->stage++;
}
if (gi->stage == SRC) {
if (++gi->src_color == ARRAY_SIZE(colors))
goto reset_src;
if (gi->ref.src)
XRenderFreePicture(gi->ref.dpy->dpy, gi->ref.src);
gi->ref.src = XRenderCreateSolidFill(gi->ref.dpy->dpy,
&colors[gi->src_color]);
if (gi->out.src)
XRenderFreePicture(gi->out.dpy->dpy, gi->out.src);
gi->out.src = XRenderCreateSolidFill(gi->out.dpy->dpy,
&colors[gi->src_color]);
gi->stage++;
}
if (gi->stage == MASK) {
if (++gi->mask_format > PictStandardNUM)
goto reset_mask;
if (gi->mask_format == PictStandardRGB24)
gi->mask_format++;
if (gi->mask_format < PictStandardNUM) {
gi->out.mask_format = XRenderFindStandardFormat(gi->out.dpy->dpy,
gi->mask_format);
gi->ref.mask_format = XRenderFindStandardFormat(gi->ref.dpy->dpy,
gi->mask_format);
} else {
gi->out.mask_format = NULL;
gi->ref.mask_format = NULL;
}
gi->stage++;
}
if (gi->stage == CLIP) {
if (++gi->clip == ARRAY_SIZE(clips))
goto reset_clip;
gi->stage++;
}
gi->stage--;
return true;
reset_op:
gi->op = -1;
reset_dst:
gi->dst_color = -1;
reset_src:
gi->src_color = -1;
reset_mask:
gi->mask_format = -1;
reset_clip:
gi->clip = -1;
gi->stage--;
goto restart;
}
static void trap_tests(struct test *t,
enum mask mask,
enum trapezoid trapezoid,
int reps, int sets,
enum target target)
{
struct test_target real, ref;
XTrapezoid *traps;
int max_traps = 65536;
int r, s, n;
traps = malloc(sizeof(*traps) * max_traps);
if (traps == NULL)
return;
printf("Testing trapezoids (%s with mask %s) (%s): ",
trapezoid_name(trapezoid),
mask_name(mask),
test_target_name(target));
fflush(stdout);
test_target_create_render(&t->real, target, &real);
clear(&t->real, &real);
test_target_create_render(&t->ref, target, &ref);
clear(&t->ref, &ref);
for (s = 0; s < sets; s++) {
for (r = 0; r < reps; r++) {
XRenderColor render_color;
int op = ops[rand() % sizeof(ops)];
int red = rand() % 0xff;
int green = rand() % 0xff;
int blue = rand() % 0xff;
int alpha = rand() % 0xff;
int num_traps = rand() % max_traps;
Picture src;
for (n = 0; n < num_traps; n++)
random_trapezoid(&traps[n], 0,
0, 0, real.width, real.height);
render_color.red = red * alpha;
render_color.green = green * alpha;
render_color.blue = blue * alpha;
render_color.alpha = alpha << 8;
src = XRenderCreateSolidFill(t->real.dpy,
&render_color);
XRenderCompositeTrapezoids(t->real.dpy,
op, src, real.picture,
mask_format(t->real.dpy, mask),
0, 0, traps, num_traps);
XRenderFreePicture(t->real.dpy, src);
src = XRenderCreateSolidFill(t->ref.dpy,
&render_color);
XRenderCompositeTrapezoids(t->ref.dpy,
op, src, ref.picture,
mask_format(t->ref.dpy, mask),
0, 0, traps, num_traps);
XRenderFreePicture(t->ref.dpy, src);
}
test_compare(t,
real.draw, real.format,
ref.draw, ref.format,
0, 0, real.width, real.height,
"");
}
printf("passed [%d iterations x %d]\n", reps, sets);
test_target_destroy_render(&t->real, &real);
test_target_destroy_render(&t->ref, &ref);
free(traps);
}
static void edge_test(struct test *t,
enum mask mask,
enum edge edge,
enum target target)
{
struct test_target out, ref;
XRenderColor white = { 0xffff, 0xffff, 0xffff, 0xffff };
Picture src_ref, src_out;
XTrapezoid trap;
int left_or_right, p;
test_target_create_render(&t->out, target, &out);
set_edge(t->out.dpy, out.picture, edge);
src_out = XRenderCreateSolidFill(t->out.dpy, &white);
test_target_create_render(&t->ref, target, &ref);
set_edge(t->ref.dpy, ref.picture, edge);
src_ref = XRenderCreateSolidFill(t->ref.dpy, &white);
printf("Testing edges (with mask %s and %s edges) (%s): ",
mask_name(mask),
edge_name(edge),
test_target_name(target));
fflush(stdout);
for (left_or_right = 0; left_or_right <= 1; left_or_right++) {
for (p = -64; p <= out.width + 64; p++) {
char buf[80];
if (left_or_right) {
trap.left.p1.x = 0;
trap.left.p1.y = 0;
trap.left.p2.x = 0;
trap.left.p2.y = out.height << 16;
trap.right.p1.x = p << 16;
trap.right.p1.y = 0;
trap.right.p2.x = out.width << 16;
trap.right.p2.y = out.height << 16;
} else {
trap.right.p1.x = out.width << 16;
trap.right.p1.y = 0;
trap.right.p2.x = out.width << 16;
trap.right.p2.y = out.height << 16;
trap.left.p1.x = 0;
trap.left.p1.y = 0;
trap.left.p2.x = p << 16;
trap.left.p2.y = out.height << 16;
}
trap.top = 0;
trap.bottom = out.height << 16;
sprintf(buf,
"trap=((%d, %d), (%d, %d)), ((%d, %d), (%d, %d))\n",
trap.left.p1.x >> 16, trap.left.p1.y >> 16,
trap.left.p2.x >> 16, trap.left.p2.y >> 16,
trap.right.p1.x >> 16, trap.right.p1.y >> 16,
trap.right.p2.x >> 16, trap.right.p2.y >> 16);
clear(&t->out, &out);
XRenderCompositeTrapezoids(t->out.dpy,
PictOpSrc,
src_out,
out.picture,
mask_format(t->out.dpy, mask),
0, 0,
&trap, 1);
clear(&t->ref, &ref);
XRenderCompositeTrapezoids(t->ref.dpy,
PictOpSrc,
src_ref,
ref.picture,
mask_format(t->ref.dpy, mask),
0, 0,
&trap, 1);
test_compare(t,
out.draw, out.format,
ref.draw, ref.format,
0, 0, out.width, out.height,
buf);
}
}
XRenderFreePicture(t->out.dpy, src_out);
test_target_destroy_render(&t->out, &out);
XRenderFreePicture(t->ref.dpy, src_ref);
test_target_destroy_render(&t->ref, &ref);
printf("pass\n");
}
