svn merge ^/branches/released .

1 files changed, 127 insertions, 9 deletions

diff --git a/pixman/test/scaling-test.c b/pixman/test/scaling-test.c
index 7b78017a3..2a0826a46 100644
--- a/pixman/test/scaling-test.c
+++ b/pixman/test/scaling-test.c
@@ -12,10 +12,10 @@
 #include <stdio.h>

 #include "utils.h"

 

-#define MAX_SRC_WIDTH  16

-#define MAX_SRC_HEIGHT 16

-#define MAX_DST_WIDTH  16

-#define MAX_DST_HEIGHT 16

+#define MAX_SRC_WIDTH  48

+#define MAX_SRC_HEIGHT 8

+#define MAX_DST_WIDTH  48

+#define MAX_DST_HEIGHT 8

 #define MAX_STRIDE     4

 

 /*

@@ -27,24 +27,32 @@ test_composite (int      testnum,
 {

     int                i;

     pixman_image_t *   src_img;

+    pixman_image_t *   mask_img;

     pixman_image_t *   dst_img;

     pixman_transform_t transform;

     pixman_region16_t  clip;

     int                src_width, src_height;

+    int                mask_width, mask_height;

     int                dst_width, dst_height;

-    int                src_stride, dst_stride;

+    int                src_stride, mask_stride, dst_stride;

     int                src_x, src_y;

+    int                mask_x, mask_y;

     int                dst_x, dst_y;

     int                src_bpp;

+    int                mask_bpp = 1;

     int                dst_bpp;

     int                w, h;

     pixman_fixed_t     scale_x = 65536, scale_y = 65536;

     pixman_fixed_t     translate_x = 0, translate_y = 0;

+    pixman_fixed_t     mask_scale_x = 65536, mask_scale_y = 65536;

+    pixman_fixed_t     mask_translate_x = 0, mask_translate_y = 0;

     pixman_op_t        op;

     pixman_repeat_t    repeat = PIXMAN_REPEAT_NONE;

+    pixman_repeat_t    mask_repeat = PIXMAN_REPEAT_NONE;

     pixman_format_code_t src_fmt, dst_fmt;

     uint32_t *         srcbuf;

     uint32_t *         dstbuf;

+    uint32_t *         maskbuf;

     uint32_t           crc32;

     FLOAT_REGS_CORRUPTION_DETECTOR_START ();

 

@@ -52,34 +60,68 @@ test_composite (int      testnum,
 

     src_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;

     dst_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;

-    op = (lcg_rand_n (2) == 0) ? PIXMAN_OP_SRC : PIXMAN_OP_OVER;

+    switch (lcg_rand_n (3))

+    {

+    case 0:

+	op = PIXMAN_OP_SRC;

+	break;

+    case 1:

+	op = PIXMAN_OP_OVER;

+	break;

+    default:

+	op = PIXMAN_OP_ADD;

+	break;

+    }

 

     src_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;

     src_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;

+

+    if (lcg_rand_n (2))

+    {

+	mask_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;

+	mask_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;

+    }

+    else

+    {

+	mask_width = mask_height = 1;

+    }

+

     dst_width = lcg_rand_n (MAX_DST_WIDTH) + 1;

     dst_height = lcg_rand_n (MAX_DST_HEIGHT) + 1;

     src_stride = src_width * src_bpp + lcg_rand_n (MAX_STRIDE) * src_bpp;

+    mask_stride = mask_width * mask_bpp + lcg_rand_n (MAX_STRIDE) * mask_bpp;

     dst_stride = dst_width * dst_bpp + lcg_rand_n (MAX_STRIDE) * dst_bpp;

 

     if (src_stride & 3)

 	src_stride += 2;

 

+    if (mask_stride & 1)

+	mask_stride += 1;

+    if (mask_stride & 2)

+	mask_stride += 2;

+

     if (dst_stride & 3)

 	dst_stride += 2;

 

     src_x = -(src_width / 4) + lcg_rand_n (src_width * 3 / 2);

     src_y = -(src_height / 4) + lcg_rand_n (src_height * 3 / 2);

+    mask_x = -(mask_width / 4) + lcg_rand_n (mask_width * 3 / 2);

+    mask_y = -(mask_height / 4) + lcg_rand_n (mask_height * 3 / 2);

     dst_x = -(dst_width / 4) + lcg_rand_n (dst_width * 3 / 2);

     dst_y = -(dst_height / 4) + lcg_rand_n (dst_height * 3 / 2);

     w = lcg_rand_n (dst_width * 3 / 2 - dst_x);

     h = lcg_rand_n (dst_height * 3 / 2 - dst_y);

 

     srcbuf = (uint32_t *)malloc (src_stride * src_height);

+    maskbuf = (uint32_t *)malloc (mask_stride * mask_height);

     dstbuf = (uint32_t *)malloc (dst_stride * dst_height);

 

     for (i = 0; i < src_stride * src_height; i++)

 	*((uint8_t *)srcbuf + i) = lcg_rand_n (256);

 

+    for (i = 0; i < mask_stride * mask_height; i++)

+	*((uint8_t *)maskbuf + i) = lcg_rand_n (256);

+

     for (i = 0; i < dst_stride * dst_height; i++)

 	*((uint8_t *)dstbuf + i) = lcg_rand_n (256);

 

@@ -92,13 +134,16 @@ test_composite (int      testnum,
     src_img = pixman_image_create_bits (

         src_fmt, src_width, src_height, srcbuf, src_stride);

 

+    mask_img = pixman_image_create_bits (

+        PIXMAN_a8, mask_width, mask_height, maskbuf, mask_stride);

+

     dst_img = pixman_image_create_bits (

         dst_fmt, dst_width, dst_height, dstbuf, dst_stride);

 

     image_endian_swap (src_img, src_bpp * 8);

     image_endian_swap (dst_img, dst_bpp * 8);

 

-    if (lcg_rand_n (8) > 0)

+    if (lcg_rand_n (4) > 0)

     {

 	scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);

 	scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);

@@ -109,6 +154,40 @@ test_composite (int      testnum,
 	pixman_image_set_transform (src_img, &transform);

     }

 

+    if (lcg_rand_n (2) > 0)

+    {

+	mask_scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);

+	mask_scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);

+	mask_translate_x = lcg_rand_N (65536);

+	mask_translate_y = lcg_rand_N (65536);

+	pixman_transform_init_scale (&transform, mask_scale_x, mask_scale_y);

+	pixman_transform_translate (&transform, NULL, mask_translate_x, mask_translate_y);

+	pixman_image_set_transform (mask_img, &transform);

+    }

+

+    switch (lcg_rand_n (4))

+    {

+    case 0:

+	mask_repeat = PIXMAN_REPEAT_NONE;

+	break;

+

+    case 1:

+	mask_repeat = PIXMAN_REPEAT_NORMAL;

+	break;

+

+    case 2:

+	mask_repeat = PIXMAN_REPEAT_PAD;

+	break;

+

+    case 3:

+	mask_repeat = PIXMAN_REPEAT_REFLECT;

+	break;

+

+    default:

+        break;

+    }

+    pixman_image_set_repeat (mask_img, mask_repeat);

+

     switch (lcg_rand_n (4))

     {

     case 0:

@@ -137,6 +216,11 @@ test_composite (int      testnum,
     else

 	pixman_image_set_filter (src_img, PIXMAN_FILTER_BILINEAR, NULL, 0);

 

+    if (lcg_rand_n (2))

+	pixman_image_set_filter (mask_img, PIXMAN_FILTER_NEAREST, NULL, 0);

+    else

+	pixman_image_set_filter (mask_img, PIXMAN_FILTER_BILINEAR, NULL, 0);

+

     if (verbose)

     {

 	printf ("src_fmt=%08X, dst_fmt=%08X\n", src_fmt, dst_fmt);

@@ -183,6 +267,34 @@ test_composite (int      testnum,
     {

 	pixman_box16_t clip_boxes[2];

 	int            n = lcg_rand_n (2) + 1;

+

+	for (i = 0; i < n; i++)

+	{

+	    clip_boxes[i].x1 = lcg_rand_n (mask_width);

+	    clip_boxes[i].y1 = lcg_rand_n (mask_height);

+	    clip_boxes[i].x2 =

+		clip_boxes[i].x1 + lcg_rand_n (mask_width - clip_boxes[i].x1);

+	    clip_boxes[i].y2 =

+		clip_boxes[i].y1 + lcg_rand_n (mask_height - clip_boxes[i].y1);

+

+	    if (verbose)

+	    {

+		printf ("mask clip box: [%d,%d-%d,%d]\n",

+		        clip_boxes[i].x1, clip_boxes[i].y1,

+		        clip_boxes[i].x2, clip_boxes[i].y2);

+	    }

+	}

+

+	pixman_region_init_rects (&clip, clip_boxes, n);

+	pixman_image_set_clip_region (mask_img, &clip);

+	pixman_image_set_source_clipping (mask_img, 1);

+	pixman_region_fini (&clip);

+    }

+

+    if (lcg_rand_n (8) == 0)

+    {

+	pixman_box16_t clip_boxes[2];

+	int            n = lcg_rand_n (2) + 1;

 	for (i = 0; i < n; i++)

 	{

 	    clip_boxes[i].x1 = lcg_rand_n (dst_width);

@@ -204,8 +316,12 @@ test_composite (int      testnum,
 	pixman_region_fini (&clip);

     }

 

-    pixman_image_composite (op, src_img, NULL, dst_img,

+    if (lcg_rand_n (2) == 0)

+	pixman_image_composite (op, src_img, NULL, dst_img,

                             src_x, src_y, 0, 0, dst_x, dst_y, w, h);

+    else

+	pixman_image_composite (op, src_img, mask_img, dst_img,

+                            src_x, src_y, mask_x, mask_y, dst_x, dst_y, w, h);

 

     if (dst_fmt == PIXMAN_x8r8g8b8)

     {

@@ -230,10 +346,12 @@ test_composite (int      testnum,
     }

 

     pixman_image_unref (src_img);

+    pixman_image_unref (mask_img);

     pixman_image_unref (dst_img);

 

     crc32 = compute_crc32 (0, dstbuf, dst_stride * dst_height);

     free (srcbuf);

+    free (maskbuf);

     free (dstbuf);

 

     FLOAT_REGS_CORRUPTION_DETECTOR_FINISH ();

@@ -245,6 +363,6 @@ main (int argc, const char *argv[])
 {

     pixman_disable_out_of_bounds_workaround ();

 

-    return fuzzer_test_main("scaling", 8000000, 0x7F1AB59F,

+    return fuzzer_test_main("scaling", 8000000, 0x80DF1CB2,

 			    test_composite, argc, argv);

 }