forked from KolibriOS/kolibrios
174 lines
3.5 KiB
C
174 lines
3.5 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <config.h>
|
|
#include "pixman-private.h"
|
|
#include "pixman.h"
|
|
|
|
#define FALSE 0
|
|
#define TRUE 1
|
|
|
|
/* Randomly decide between 32 and 16 bit
|
|
*
|
|
* Allocate bits with random width, stride and height
|
|
*
|
|
* Then make up some random offset (dx, dy)
|
|
*
|
|
* Then make an image with those values.
|
|
*
|
|
* Do this for both source and destination
|
|
*
|
|
* Composite them together using OVER.
|
|
*
|
|
* The bits in the source and the destination should have
|
|
* recognizable colors so that the result can be verified.
|
|
*
|
|
* Ie., walk the bits and verify that they have been composited.
|
|
*/
|
|
|
|
static int
|
|
get_rand (int bound)
|
|
{
|
|
return rand () % bound;
|
|
}
|
|
|
|
static pixman_image_t *
|
|
make_image (int width, int height, pixman_bool_t src, int *rx, int *ry)
|
|
{
|
|
pixman_format_code_t format;
|
|
pixman_image_t *image;
|
|
pixman_region32_t region;
|
|
uint8_t *bits;
|
|
int stride;
|
|
int bpp;
|
|
int dx, dy;
|
|
int i, j;
|
|
|
|
if (src)
|
|
format = PIXMAN_a8r8g8b8;
|
|
else
|
|
format = PIXMAN_r5g6b5;
|
|
|
|
bpp = PIXMAN_FORMAT_BPP (format) / 8;
|
|
|
|
stride = width + get_rand (width);
|
|
stride += (stride & 1); /* Make it an even number */
|
|
|
|
bits = malloc (height * stride * bpp);
|
|
|
|
for (j = 0; j < height; ++j)
|
|
{
|
|
for (i = 0; i < width; ++i)
|
|
{
|
|
uint8_t *pixel = bits + (stride * j + i) * bpp;
|
|
|
|
if (src)
|
|
*(uint32_t *)pixel = 0x7f00007f;
|
|
else
|
|
*(uint16_t *)pixel = 0xf100;
|
|
}
|
|
}
|
|
|
|
dx = dy = 0;
|
|
|
|
dx = get_rand (500);
|
|
dy = get_rand (500);
|
|
|
|
if (!src)
|
|
{
|
|
/* Now simulate the bogus X server translations */
|
|
bits -= (dy * stride + dx) * bpp;
|
|
}
|
|
|
|
image = pixman_image_create_bits (
|
|
format, width, height, (uint32_t *)bits, stride * bpp);
|
|
|
|
if (!src)
|
|
{
|
|
/* And add the bogus clip region */
|
|
pixman_region32_init_rect (®ion, dx, dy, dx + width, dy + height);
|
|
|
|
pixman_image_set_clip_region32 (image, ®ion);
|
|
}
|
|
|
|
pixman_image_set_source_clipping (image, TRUE);
|
|
|
|
if (src)
|
|
{
|
|
pixman_transform_t trans;
|
|
|
|
pixman_transform_init_identity (&trans);
|
|
|
|
pixman_transform_translate (&trans,
|
|
NULL,
|
|
- pixman_int_to_fixed (width / 2),
|
|
- pixman_int_to_fixed (height / 2));
|
|
|
|
pixman_transform_scale (&trans,
|
|
NULL,
|
|
pixman_double_to_fixed (0.5),
|
|
pixman_double_to_fixed (0.5));
|
|
|
|
pixman_transform_translate (&trans,
|
|
NULL,
|
|
pixman_int_to_fixed (width / 2),
|
|
pixman_int_to_fixed (height / 2));
|
|
|
|
pixman_image_set_transform (image, &trans);
|
|
pixman_image_set_filter (image, PIXMAN_FILTER_BILINEAR, NULL, 0);
|
|
pixman_image_set_repeat (image, PIXMAN_REPEAT_PAD);
|
|
}
|
|
|
|
if (!src)
|
|
{
|
|
*rx = dx;
|
|
*ry = dy;
|
|
}
|
|
else
|
|
{
|
|
*rx = *ry = 0;
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
int
|
|
main ()
|
|
{
|
|
pixman_image_t *src, *dest;
|
|
int src_x, src_y, dest_x, dest_y;
|
|
int i, j;
|
|
int width = get_rand (499) + 1;
|
|
int height = get_rand (499) + 1;
|
|
|
|
src = make_image (width, height, TRUE, &src_x, &src_y);
|
|
dest = make_image (width, height, FALSE, &dest_x, &dest_y);
|
|
|
|
pixman_image_composite (
|
|
PIXMAN_OP_OVER, src, NULL, dest,
|
|
src_x, src_y,
|
|
-1, -1,
|
|
dest_x, dest_y,
|
|
width, height);
|
|
|
|
for (i = 0; i < height; ++i)
|
|
{
|
|
for (j = 0; j < width; ++j)
|
|
{
|
|
uint8_t *bits = (uint8_t *)dest->bits.bits;
|
|
int bpp = PIXMAN_FORMAT_BPP (dest->bits.format) / 8;
|
|
int stride = dest->bits.rowstride * 4;
|
|
|
|
uint8_t *pixel =
|
|
bits + (i + dest_y) * stride + (j + dest_x) * bpp;
|
|
|
|
if (*(uint16_t *)pixel != 0x788f)
|
|
{
|
|
printf ("bad pixel %x\n", *(uint16_t *)pixel);
|
|
assert (*(uint16_t *)pixel == 0x788f);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|