static void
subdraw (cairo_t *cr, int width, int height)
{
size_t i = 0;
cairo_operator_t op;
cairo_t *bgcr, *fgcr;
cairo_surface_t *bg, *fg;
bg = cairo_surface_create_similar (cairo_get_target (cr),
CAIRO_CONTENT_COLOR_ALPHA, SIZE * STEPS, SIZE * STEPS);
fg = cairo_surface_create_similar (cairo_get_target (cr),
CAIRO_CONTENT_COLOR_ALPHA, SIZE * STEPS, SIZE * STEPS);
bgcr = cairo_create (bg);
fgcr = cairo_create (fg);
cairo_scale (bgcr, SIZE, SIZE);
cairo_scale (fgcr, SIZE, SIZE);
create_patterns (bgcr, fgcr);
cairo_destroy (bgcr);
cairo_destroy (fgcr);
for (op = START_OPERATOR; op <= STOP_OPERATOR; op++, i++) {
cairo_save (cr);
cairo_translate (cr,
SIZE * (STEPS + 1) * (i % COUNT),
SIZE * (STEPS + 1) * (i / COUNT));
cairo_rectangle (cr, 0, 0, SIZE * (STEPS + 1), SIZE * (STEPS+1));
cairo_clip (cr);
do_composite (cr, op, bg, fg);
cairo_restore (cr);
}
cairo_surface_destroy (fg);
cairo_surface_destroy (bg);
}
GlyphToType3::GlyphToType3(TTStreamWriter& stream, struct TTFONT *font, int charindex, bool embedded /* = false */)
{
BYTE *glyph;
tt_flags = NULL;
xcoor = NULL;
ycoor = NULL;
epts_ctr = NULL;
area_ctr = NULL;
check_ctr = NULL;
ctrset = NULL;
stack_depth = 0;
pdf_mode = font->target_type < 0;
/* Get a pointer to the data. */
glyph = find_glyph_data( font, charindex );
/* If the character is blank, it has no bounding box, */
/* otherwise read the bounding box. */
if ( glyph == (BYTE*)NULL )
{
llx=lly=urx=ury=0; /* A blank char has an all zero BoundingBox */
num_ctr=0; /* Set this for later if()s */
}
else
{
/* Read the number of contours. */
num_ctr = getSHORT(glyph);
/* Read PostScript bounding box. */
llx = getFWord(glyph + 2);
lly = getFWord(glyph + 4);
urx = getFWord(glyph + 6);
ury = getFWord(glyph + 8);
/* Advance the pointer. */
glyph += 10;
}
/* If it is a simple character, load its data. */
if (num_ctr > 0)
{
load_char(font, glyph);
}
else
{
num_pts=0;
}
/* Consult the horizontal metrics table to determine */
/* the character width. */
if ( charindex < font->numberOfHMetrics )
{
advance_width = getuFWord( font->hmtx_table + (charindex * 4) );
}
else
{
advance_width = getuFWord( font->hmtx_table + ((font->numberOfHMetrics-1) * 4) );
}
/* Execute setcachedevice in order to inform the font machinery */
/* of the character bounding box and advance width. */
stack(stream, 7);
if (pdf_mode)
{
if (!embedded) {
stream.printf("%d 0 %d %d %d %d d1\n",
topost(advance_width),
topost(llx), topost(lly), topost(urx), topost(ury) );
}
}
else if (font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.printf("pop gsave .001 .001 scale %d 0 %d %d %d %d setcachedevice\n",
topost(advance_width),
topost(llx), topost(lly), topost(urx), topost(ury) );
}
else
{
stream.printf("%d 0 %d %d %d %d _sc\n",
topost(advance_width),
topost(llx), topost(lly), topost(urx), topost(ury) );
}
/* If it is a simple glyph, convert it, */
/* otherwise, close the stack business. */
if ( num_ctr > 0 ) /* simple */
{
PSConvert(stream);
}
else if ( num_ctr < 0 ) /* composite */
{
do_composite(stream, font, glyph);
}
if (font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.printf("\ngrestore\n");
}
stack_end(stream);
}
/* Test a composite of a given operation, source, and destination picture. */
Bool
blend_test(Display *dpy, picture_info *win, picture_info *dst,
const int *op, int num_op,
const picture_info **src_color, int num_src,
const picture_info **dst_color, int num_dst)
{
color4d expected, tested, tdst;
char testname[20];
int i, j, k, y, iter;
int page, num_pages;
/* If the window is smaller than the number of sources to test,
* we need to break the sources up into pages.
*
* We however assume that the window will always be wider than num_ops.
*/
num_pages = num_src / win_height + 1;
k = y = 0;
while (k < num_dst) {
XImage *image;
int k0 = k, k1 = k;
int this_src, rem_src;
rem_src = num_src;
for (page = 0; page < num_pages; page++) {
this_src = rem_src / (num_pages - page);
for (iter = 0; iter < pixmap_move_iter; iter++) {
k1 = k0;
y = 0;
while (k1 < num_dst && y + this_src <= win_height) {
XRenderComposite(dpy, PictOpSrc,
dst_color[k1++]->pict, 0, dst->pict,
0, 0,
0, 0,
0, y,
num_op, this_src);
for (j = 0; j < this_src; j++) {
for (i = 0; i < num_op; i++) {
XRenderComposite(dpy, ops[op[i]].op,
src_color[j]->pict, 0, dst->pict,
0, 0,
0, 0,
i, y,
1, 1);
}
y++;
}
}
}
image = XGetImage(dpy, dst->d,
0, 0, num_ops, y,
0xffffffff, ZPixmap);
copy_pict_to_win(dpy, dst, win, win_width, win_height);
y = 0;
for (k = k0; k < k1; k++) {
XRenderDirectFormat dst_acc;
accuracy(&dst_acc,
&dst->format->direct,
&dst_color[k]->format->direct);
tdst = dst_color[k]->color;
color_correct(dst, &tdst);
for (j = 0; j < this_src; j++) {
XRenderDirectFormat acc;
accuracy(&acc, &src_color[j]->format->direct, &dst_acc);
for (i = 0; i < num_op; i++) {
get_pixel_from_image(image, dst, i, y, &tested);
do_composite(ops[op[i]].op,
&src_color[j]->color,
NULL,
&tdst,
&expected,
FALSE);
color_correct(dst, &expected);
if (eval_diff(&acc, &expected, &tested) > 3.) {
char *srcformat;
snprintf(testname, 20, "%s blend", ops[op[i]].name);
describe_format(&srcformat, NULL, src_color[j]->format);
print_fail(testname, &expected, &tested, 0, 0,
eval_diff(&acc, &expected, &tested));
printf("src color: %.2f %.2f %.2f %.2f (%s)\n"
"dst color: %.2f %.2f %.2f %.2f\n",
src_color[j]->color.r, src_color[j]->color.g,
src_color[j]->color.b, src_color[j]->color.a,
srcformat,
dst_color[k]->color.r,
dst_color[k]->color.g,
dst_color[k]->color.b,
dst_color[k]->color.a);
printf("src: %s, dst: %s\n", src_color[j]->name, dst->name);
free(srcformat);
return FALSE;
}
}
y++;
}
}
XDestroyImage(image);
rem_src -= this_src;
}
}
return TRUE;
}
static pixman_bool_t
verify (int test_no,
pixman_op_t op,
pixman_image_t *source,
pixman_image_t *mask,
pixman_image_t *dest,
pixman_image_t *orig_dest,
int x, int y,
int width, int height,
pixman_bool_t component_alpha)
{
pixel_checker_t dest_checker, src_checker, mask_checker;
int i, j;
pixel_checker_init (&src_checker, source->bits.format);
pixel_checker_init (&dest_checker, dest->bits.format);
pixel_checker_init (&mask_checker, mask->bits.format);
assert (dest->bits.format == orig_dest->bits.format);
for (j = y; j < y + height; ++j)
{
for (i = x; i < x + width; ++i)
{
color_t src_color, mask_color, orig_dest_color, result;
uint32_t dest_pixel, orig_dest_pixel, src_pixel, mask_pixel;
access (dest, i, j, &dest_pixel);
get_color (&src_checker,
source, i - x, j - y,
&src_color, &src_pixel);
get_color (&mask_checker,
mask, i - x, j - y,
&mask_color, &mask_pixel);
get_color (&dest_checker,
orig_dest, i, j,
&orig_dest_color, &orig_dest_pixel);
do_composite (op,
&src_color, &mask_color, &orig_dest_color,
&result, component_alpha);
if (!pixel_checker_check (&dest_checker, dest_pixel, &result))
{
int a, r, g, b;
printf ("--------- Test 0x%x failed ---------\n", test_no);
printf (" operator: %s (%s alpha)\n", operator_name (op),
component_alpha? "component" : "unified");
printf (" dest_x, dest_y: %d %d\n", x, y);
printf (" width, height: %d %d\n", width, height);
printf (" source: format: %-14s size: %2d x %2d\n",
format_name (source->bits.format),
source->bits.width, source->bits.height);
printf (" mask: format: %-14s size: %2d x %2d\n",
format_name (mask->bits.format),
mask->bits.width, mask->bits.height);
printf (" dest: format: %-14s size: %2d x %2d\n",
format_name (dest->bits.format),
dest->bits.width, dest->bits.height);
printf (" -- Failed pixel: (%d, %d) --\n", i, j);
printf (" source ARGB: %f %f %f %f (pixel: %x)\n",
src_color.a, src_color.r, src_color.g, src_color.b,
src_pixel);
printf (" mask ARGB: %f %f %f %f (pixel: %x)\n",
mask_color.a, mask_color.r, mask_color.g, mask_color.b,
mask_pixel);
printf (" dest ARGB: %f %f %f %f (pixel: %x)\n",
orig_dest_color.a, orig_dest_color.r, orig_dest_color.g, orig_dest_color.b,
orig_dest_pixel);
printf (" expected ARGB: %f %f %f %f\n",
result.a, result.r, result.g, result.b);
pixel_checker_get_min (&dest_checker, &result, &a, &r, &g, &b);
printf (" min acceptable: %8d %8d %8d %8d\n", a, r, g, b);
pixel_checker_split_pixel (&dest_checker, dest_pixel, &a, &r, &g, &b);
printf (" got: %8d %8d %8d %8d (pixel: %x)\n", a, r, g, b, dest_pixel);
pixel_checker_get_max (&dest_checker, &result, &a, &r, &g, &b);
printf (" max acceptable: %8d %8d %8d %8d\n", a, r, g, b);
printf ("\n");
printf (" { %s,\n", operator_name (op));
printf (" PIXMAN_%s,\t0x%x,\n", format_name (source->bits.format), src_pixel);
printf (" PIXMAN_%s,\t0x%x,\n", format_name (mask->bits.format), mask_pixel);
printf (" PIXMAN_%s,\t0x%x\n", format_name (dest->bits.format), orig_dest_pixel);
printf (" },\n");
return FALSE;
}
}
}
return TRUE;
}
static pixman_bool_t
verify (int test_no, const pixel_combination_t *combination, int size)
{
pixman_image_t *src, *dest;
pixel_checker_t src_checker, dest_checker;
color_t source_color, dest_color, reference_color;
pixman_bool_t result = TRUE;
int i, j;
/* Compute reference color */
pixel_checker_init (&src_checker, combination->src_format);
pixel_checker_init (&dest_checker, combination->dest_format);
pixel_checker_convert_pixel_to_color (
&src_checker, combination->src_pixel, &source_color);
pixel_checker_convert_pixel_to_color (
&dest_checker, combination->dest_pixel, &dest_color);
do_composite (combination->op,
&source_color, NULL, &dest_color,
&reference_color, FALSE);
src = pixman_image_create_bits (
combination->src_format, size, size, NULL, -1);
dest = pixman_image_create_bits (
combination->dest_format, size, size, NULL, -1);
fill (src, combination->src_pixel);
fill (dest, combination->dest_pixel);
pixman_image_composite32 (
combination->op, src, NULL, dest, 0, 0, 0, 0, 0, 0, size, size);
for (j = 0; j < size; ++j)
{
for (i = 0; i < size; ++i)
{
uint32_t computed = access (dest, i, j);
int32_t a, r, g, b;
if (!pixel_checker_check (&dest_checker, computed, &reference_color))
{
printf ("----------- Test %d failed ----------\n", test_no);
printf (" operator: %s\n", operator_name (combination->op));
printf (" src format: %s\n", format_name (combination->src_format));
printf (" dest format: %s\n", format_name (combination->dest_format));
printf (" - source ARGB: %f %f %f %f (pixel: %8x)\n",
source_color.a, source_color.r, source_color.g, source_color.b,
combination->src_pixel);
pixel_checker_split_pixel (&src_checker, combination->src_pixel,
&a, &r, &g, &b);
printf (" %8d %8d %8d %8d\n", a, r, g, b);
printf (" - dest ARGB: %f %f %f %f (pixel: %8x)\n",
dest_color.a, dest_color.r, dest_color.g, dest_color.b,
combination->dest_pixel);
pixel_checker_split_pixel (&dest_checker, combination->dest_pixel,
&a, &r, &g, &b);
printf (" %8d %8d %8d %8d\n", a, r, g, b);
pixel_checker_split_pixel (&dest_checker, computed, &a, &r, &g, &b);
printf (" - expected ARGB: %f %f %f %f\n",
reference_color.a, reference_color.r, reference_color.g, reference_color.b);
pixel_checker_get_min (&dest_checker, &reference_color, &a, &r, &g, &b);
printf (" min acceptable: %8d %8d %8d %8d\n", a, r, g, b);
pixel_checker_split_pixel (&dest_checker, computed, &a, &r, &g, &b);
printf (" got: %8d %8d %8d %8d (pixel: %8x)\n", a, r, g, b, computed);
pixel_checker_get_max (&dest_checker, &reference_color, &a, &r, &g, &b);
printf (" max acceptable: %8d %8d %8d %8d\n", a, r, g, b);
result = FALSE;
goto done;
}
}
}
done:
pixman_image_unref (src);
pixman_image_unref (dest);
return result;
}