svn merge ^/branches/released .

14 files changed, 1508 insertions, 560 deletions

diff --git a/pixman/pixman/Makefile.win32 b/pixman/pixman/Makefile.win32
index a61f33f94..c5e8dfaf2 100644
--- a/pixman/pixman/Makefile.win32
+++ b/pixman/pixman/Makefile.win32
@@ -56,6 +56,8 @@ SOURCES =				\
 	pixman-general.c		\

 	$(NULL)

 

+BUILT_SOURCES = pixman-combine32.h pixman-combine32.c pixman-combine64.h pixman-combine64.c

+

 # MMX compilation flags

 ifeq ($(MMX_VAR),on)

 CFLAGS += $(MMX_CFLAGS)

@@ -122,7 +124,7 @@ endif
 endif

 

 # pixman compilation and linking

-$(CFG_VAR)/%.obj: %.c

+$(CFG_VAR)/%.obj: %.c $(BUILT_SOURCES)

 	@mkdir -p $(CFG_VAR)

 	@$(CC) -c $(CFLAGS) -Fo"$@" $<

 

@@ -141,4 +143,4 @@ pixman-combine64.h: pixman-combine.h.template make-combine.pl
 

 clean_r:

 	@rm -f $(CFG_VAR)/*.obj $(CFG_VAR)/*.lib $(CFG_VAR)/*.pdb $(CFG)/*.ilk || exit 0

-	@rm -f $(CFG)/*.obj $(CFG)/*.lib $(CFG)/*.pdb $(CFG)/*.ilk pixman-combine32.c pixman-combine64.c pixman-combine64.c pixman-combine64.h || exit 0

+	@rm -f $(CFG)/*.obj $(CFG)/*.lib $(CFG)/*.pdb $(CFG)/*.ilk $(BUILT_SOURCES) || exit 0

diff --git a/pixman/pixman/pixman-arm-neon-asm.S b/pixman/pixman/pixman-arm-neon-asm.S
index 617217beb..5804396a4 100644
--- a/pixman/pixman/pixman-arm-neon-asm.S
+++ b/pixman/pixman/pixman-arm-neon-asm.S
@@ -2391,3 +2391,200 @@ generate_composite_function_nearest_scanline \
     10,  /* dst_r_basereg */ \

     8,  /* src_basereg   */ \

     15  /* mask_basereg  */

+

+/******************************************************************************/

+

+/* Supplementary macro for setting function attributes */

+.macro pixman_asm_function fname

+    .func fname

+    .global fname

+#ifdef __ELF__

+    .hidden fname

+    .type fname, %function

+#endif

+fname:

+.endm

+

+.macro bilinear_interpolate_last_pixel

+    mov       TMP1, X, asr #16

+    mov       TMP2, X, asr #16

+    add       TMP1, TOP, TMP1, asl #2

+    add       TMP2, BOTTOM, TMP2, asl #2

+    vld1.32   {d0}, [TMP1]

+    vshr.u16  d30, d24, #8

+    vld1.32   {d1}, [TMP2]

+    vmull.u8  q1, d0, d28

+    vmlal.u8  q1, d1, d29

+    /* 5 cycles bubble */

+    vshll.u16 q0, d2, #8

+    vmlsl.u16 q0, d2, d30

+    vmlal.u16 q0, d3, d30

+    /* 5 cycles bubble */

+    vshrn.u32 d0, q0, #16

+    /* 3 cycles bubble */

+    vmovn.u16 d0, q0

+    /* 1 cycle bubble */

+    vst1.32   {d0[0]}, [OUT, :32]!

+.endm

+

+.macro bilinear_interpolate_two_pixels

+    mov       TMP1, X, asr #16

+    mov       TMP2, X, asr #16

+    add       X, X, UX

+    add       TMP1, TOP, TMP1, asl #2

+    add       TMP2, BOTTOM, TMP2, asl #2

+    vld1.32   {d0}, [TMP1]

+    vld1.32   {d1}, [TMP2]

+    vmull.u8  q1, d0, d28

+    vmlal.u8  q1, d1, d29

+    mov       TMP1, X, asr #16

+    mov       TMP2, X, asr #16

+    add       X, X, UX

+    add       TMP1, TOP, TMP1, asl #2

+    add       TMP2, BOTTOM, TMP2, asl #2

+    vld1.32   {d20}, [TMP1]

+    vld1.32   {d21}, [TMP2]

+    vmull.u8  q11, d20, d28

+    vmlal.u8  q11, d21, d29

+    vshr.u16  q15, q12, #8

+    vadd.u16  q12, q12, q13

+    vshll.u16 q0, d2, #8

+    vmlsl.u16 q0, d2, d30

+    vmlal.u16 q0, d3, d30

+    vshll.u16 q10, d22, #8

+    vmlsl.u16 q10, d22, d31

+    vmlal.u16 q10, d23, d31

+    vshrn.u32 d30, q0, #16

+    vshrn.u32 d31, q10, #16

+    vmovn.u16 d0, q15

+    vst1.32   {d0}, [OUT]!

+.endm

+

+.macro bilinear_interpolate_four_pixels

+    mov       TMP1, X, asr #16

+    mov       TMP2, X, asr #16

+    add       X, X, UX

+    add       TMP1, TOP, TMP1, asl #2

+    add       TMP2, BOTTOM, TMP2, asl #2

+    vld1.32   {d0}, [TMP1]

+    vld1.32   {d1}, [TMP2]

+    vmull.u8  q1, d0, d28

+    vmlal.u8  q1, d1, d29

+    mov       TMP1, X, asr #16

+    mov       TMP2, X, asr #16

+    add       X, X, UX

+    add       TMP1, TOP, TMP1, asl #2

+    add       TMP2, BOTTOM, TMP2, asl #2

+    vld1.32   {d20}, [TMP1]

+    vld1.32   {d21}, [TMP2]

+    vmull.u8  q11, d20, d28

+    vmlal.u8  q11, d21, d29

+    vshr.u16  q15, q12, #8

+    vadd.u16  q12, q12, q13

+    vshll.u16 q0, d2, #8

+    vmlsl.u16 q0, d2, d30

+    vmlal.u16 q0, d3, d30

+    vshll.u16 q10, d22, #8

+    vmlsl.u16 q10, d22, d31

+    vmlal.u16 q10, d23, d31

+    mov       TMP1, X, asr #16

+    mov       TMP2, X, asr #16

+    add       X, X, UX

+    add       TMP1, TOP, TMP1, asl #2

+    add       TMP2, BOTTOM, TMP2, asl #2

+    vld1.32   {d4}, [TMP1]

+    vld1.32   {d5}, [TMP2]

+    vmull.u8  q3, d4, d28

+    vmlal.u8  q3, d5, d29

+    mov       TMP1, X, asr #16

+    mov       TMP2, X, asr #16

+    add       X, X, UX

+    add       TMP1, TOP, TMP1, asl #2

+    add       TMP2, BOTTOM, TMP2, asl #2

+    vld1.32   {d16}, [TMP1]

+    vld1.32   {d17}, [TMP2]

+    vmull.u8  q9, d16, d28

+    vmlal.u8  q9, d17, d29

+    vshr.u16  q15, q12, #8

+    vadd.u16  q12, q12, q13

+    vshll.u16 q2, d6, #8

+    vmlsl.u16 q2, d6, d30

+    vmlal.u16 q2, d7, d30

+    vshll.u16 q8, d18, #8

+    vmlsl.u16 q8, d18, d31

+    vmlal.u16 q8, d19, d31

+    vshrn.u32 d0, q0, #16

+    vshrn.u32 d1, q10, #16

+    vshrn.u32 d4, q2, #16

+    vshrn.u32 d5, q8, #16

+    vmovn.u16 d0, q0

+    vmovn.u16 d1, q2

+    vst1.32   {d0, d1}, [OUT]!

+.endm

+

+

+/*

+ * pixman_scaled_bilinear_scanline_8888_8888_SRC (uint32_t *       out,

+ *                                                const uint32_t * top,

+ *                                                const uint32_t * bottom,

+ *                                                int              wt,

+ *                                                int              wb,

+ *                                                pixman_fixed_t   x,

+ *                                                pixman_fixed_t   ux,

+ *                                                int              width)

+ */

+

+pixman_asm_function pixman_scaled_bilinear_scanline_8888_8888_SRC_asm_neon

+    OUT       .req      r0

+    TOP       .req      r1

+    BOTTOM    .req      r2

+    WT        .req      r3

+    WB        .req      r4

+    X         .req      r5

+    UX        .req      r6

+    WIDTH     .req      ip

+    TMP1      .req      r3

+    TMP2      .req      r4

+

+    mov       ip, sp

+    push      {r4, r5, r6, r7}

+    ldmia     ip, {WB, X, UX, WIDTH}

+

+    cmp       WIDTH, #0

+    ble       3f

+    vdup.u16  q12, X

+    vdup.u16  q13, UX

+    vdup.u8   d28, WT

+    vdup.u8   d29, WB

+    vadd.u16  d25, d25, d26

+    vadd.u16  q13, q13, q13

+

+    subs      WIDTH, WIDTH, #4

+    blt       1f

+0:

+    bilinear_interpolate_four_pixels

+    subs      WIDTH, WIDTH, #4

+    bge       0b

+1:

+    tst       WIDTH, #2

+    beq       2f

+    bilinear_interpolate_two_pixels

+2:

+    tst       WIDTH, #1

+    beq       3f

+    bilinear_interpolate_last_pixel

+3:

+    pop       {r4, r5, r6, r7}

+    bx        lr

+

+    .unreq    OUT

+    .unreq    TOP

+    .unreq    BOTTOM

+    .unreq    WT

+    .unreq    WB

+    .unreq    X

+    .unreq    UX

+    .unreq    WIDTH

+    .unreq    TMP1

+    .unreq    TMP2

+.endfunc

diff --git a/pixman/pixman/pixman-arm-neon.c b/pixman/pixman/pixman-arm-neon.c
index 24a8b0886..f86a49c53 100644
--- a/pixman/pixman/pixman-arm-neon.c
+++ b/pixman/pixman/pixman-arm-neon.c
@@ -232,6 +232,47 @@ pixman_blt_neon (uint32_t *src_bits,
     }

 }

 

+void

+pixman_scaled_bilinear_scanline_8888_8888_SRC_asm_neon (uint32_t *       out,

+                                                        const uint32_t * top,

+                                                        const uint32_t * bottom,

+                                                        int              wt,

+                                                        int              wb,

+                                                        pixman_fixed_t   x,

+                                                        pixman_fixed_t   ux,

+                                                        int              width);

+

+static force_inline void

+scaled_bilinear_scanline_neon_8888_8888_SRC (uint32_t *       dst,

+					     const uint32_t * mask,

+					     const uint32_t * src_top,

+					     const uint32_t * src_bottom,

+					     int32_t          w,

+					     int              wt,

+					     int              wb,

+					     pixman_fixed_t   vx,

+					     pixman_fixed_t   unit_x,

+					     pixman_fixed_t   max_vx,

+					     pixman_bool_t    zero_src)

+{

+    pixman_scaled_bilinear_scanline_8888_8888_SRC_asm_neon (dst, src_top,

+                                                            src_bottom, wt, wb,

+                                                            vx, unit_x, w);

+}

+

+FAST_BILINEAR_MAINLOOP_COMMON (neon_8888_8888_cover_SRC,

+			       scaled_bilinear_scanline_neon_8888_8888_SRC,

+			       uint32_t, uint32_t, uint32_t,

+			       COVER, FALSE, FALSE)

+FAST_BILINEAR_MAINLOOP_COMMON (neon_8888_8888_pad_SRC,

+			       scaled_bilinear_scanline_neon_8888_8888_SRC,

+			       uint32_t, uint32_t, uint32_t,

+			       PAD, FALSE, FALSE)

+FAST_BILINEAR_MAINLOOP_COMMON (neon_8888_8888_none_SRC,

+			       scaled_bilinear_scanline_neon_8888_8888_SRC,

+			       uint32_t, uint32_t, uint32_t,

+			       NONE, FALSE, FALSE)

+

 static const pixman_fast_path_t arm_neon_fast_paths[] =

 {

     PIXMAN_STD_FAST_PATH (SRC,  r5g6b5,   null,     r5g6b5,   neon_composite_src_0565_0565),

@@ -343,6 +384,10 @@ static const pixman_fast_path_t arm_neon_fast_paths[] =
     PIXMAN_ARM_SIMPLE_NEAREST_A8_MASK_FAST_PATH (OVER, r5g6b5, r5g6b5, neon_0565_8_0565),

     PIXMAN_ARM_SIMPLE_NEAREST_A8_MASK_FAST_PATH (OVER, b5g6r5, b5g6r5, neon_0565_8_0565),

 

+    SIMPLE_BILINEAR_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8, neon_8888_8888),

+    SIMPLE_BILINEAR_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8, neon_8888_8888),

+    SIMPLE_BILINEAR_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8, neon_8888_8888),

+

     { PIXMAN_OP_NONE },

 };

 

diff --git a/pixman/pixman/pixman-fast-path.h b/pixman/pixman/pixman-fast-path.h
index b5f524353..89b25be88 100644
--- a/pixman/pixman/pixman-fast-path.h
+++ b/pixman/pixman/pixman-fast-path.h
@@ -587,4 +587,436 @@ fast_composite_scaled_nearest  ## scale_func_name (pixman_implementation_t *imp,
     SIMPLE_NEAREST_SOLID_MASK_FAST_PATH_NONE (op,s,d,func),		\

     SIMPLE_NEAREST_SOLID_MASK_FAST_PATH_PAD (op,s,d,func)

 

+/*****************************************************************************/

+

+/*

+ * Identify 5 zones in each scanline for bilinear scaling. Depending on

+ * whether 2 pixels to be interpolated are fetched from the image itself,

+ * from the padding area around it or from both image and padding area.

+ */

+static force_inline void

+bilinear_pad_repeat_get_scanline_bounds (int32_t         source_image_width,

+					 pixman_fixed_t  vx,

+					 pixman_fixed_t  unit_x,

+					 int32_t *       left_pad,

+					 int32_t *       left_tz,

+					 int32_t *       width,

+					 int32_t *       right_tz,

+					 int32_t *       right_pad)

+{

+	int width1 = *width, left_pad1, right_pad1;

+	int width2 = *width, left_pad2, right_pad2;

+

+	pad_repeat_get_scanline_bounds (source_image_width, vx, unit_x,

+					&width1, &left_pad1, &right_pad1);

+	pad_repeat_get_scanline_bounds (source_image_width, vx + pixman_fixed_1,

+					unit_x, &width2, &left_pad2, &right_pad2);

+

+	*left_pad = left_pad2;

+	*left_tz = left_pad1 - left_pad2;

+	*right_tz = right_pad2 - right_pad1;

+	*right_pad = right_pad1;

+	*width -= *left_pad + *left_tz + *right_tz + *right_pad;

+}

+

+/*

+ * Main loop template for single pass bilinear scaling. It needs to be

+ * provided with 'scanline_func' which should do the compositing operation.

+ * The needed function has the following prototype:

+ *

+ *	scanline_func (dst_type_t *       dst,

+ *		       const mask_type_ * mask,

+ *		       const src_type_t * src_top,

+ *		       const src_type_t * src_bottom,

+ *		       int32_t            width,

+ *		       int                weight_top,

+ *		       int                weight_bottom,

+ *		       pixman_fixed_t     vx,

+ *		       pixman_fixed_t     unit_x,

+ *		       pixman_fixed_t     max_vx,

+ *		       pixman_bool_t      zero_src)

+ *

+ * Where:

+ *  dst                 - destination scanline buffer for storing results

+ *  mask                - mask buffer (or single value for solid mask)

+ *  src_top, src_bottom - two source scanlines

+ *  width               - number of pixels to process

+ *  weight_top          - weight of the top row for interpolation

+ *  weight_bottom       - weight of the bottom row for interpolation

+ *  vx                  - initial position for fetching the first pair of

+ *                        pixels from the source buffer

+ *  unit_x              - position increment needed to move to the next pair

+ *                        of pixels

+ *  max_vx              - image size as a fixed point value, can be used for

+ *                        implementing NORMAL repeat (when it is supported)

+ *  zero_src            - boolean hint variable, which is set to TRUE when

+ *                        all source pixels are fetched from zero padding

+ *                        zone for NONE repeat

+ *

+ * Note: normally the sum of 'weight_top' and 'weight_bottom' is equal to 256,

+ *       but sometimes it may be less than that for NONE repeat when handling

+ *       fuzzy antialiased top or bottom image edges. Also both top and

+ *       bottom weight variables are guaranteed to have value in 0-255

+ *       range and can fit into unsigned byte or be used with 8-bit SIMD

+ *       multiplication instructions.

+ */

+#define FAST_BILINEAR_MAINLOOP_INT(scale_func_name, scanline_func, src_type_t, mask_type_t,	\

+				  dst_type_t, repeat_mode, have_mask, mask_is_solid)		\

+static void											\

+fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,		\

+						   pixman_op_t              op,			\

+						   pixman_image_t *         src_image,		\

+						   pixman_image_t *         mask_image,		\

+						   pixman_image_t *         dst_image,		\

+						   int32_t                  src_x,		\

+						   int32_t                  src_y,		\

+						   int32_t                  mask_x,		\

+						   int32_t                  mask_y,		\

+						   int32_t                  dst_x,		\

+						   int32_t                  dst_y,		\

+						   int32_t                  width,		\

+						   int32_t                  height)		\

+{												\

+    dst_type_t *dst_line;									\

+    mask_type_t *mask_line;									\

+    src_type_t *src_first_line;									\

+    int       y1, y2;										\

+    pixman_fixed_t max_vx = INT32_MAX; /* suppress uninitialized variable warning */		\

+    pixman_vector_t v;										\

+    pixman_fixed_t vx, vy;									\

+    pixman_fixed_t unit_x, unit_y;								\

+    int32_t left_pad, left_tz, right_tz, right_pad;						\

+												\

+    dst_type_t *dst;										\

+    mask_type_t solid_mask;									\

+    const mask_type_t *mask = &solid_mask;							\

+    int src_stride, mask_stride, dst_stride;							\

+												\

+    PIXMAN_IMAGE_GET_LINE (dst_image, dst_x, dst_y, dst_type_t, dst_stride, dst_line, 1);	\

+    if (have_mask)										\

+    {												\

+	if (mask_is_solid)									\

+	{											\

+	    solid_mask = _pixman_image_get_solid (imp, mask_image, dst_image->bits.format);	\

+	    mask_stride = 0;									\

+	}											\

+	else											\

+	{											\

+	    PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, mask_type_t,			\

+				   mask_stride, mask_line, 1);					\

+	}											\

+    }												\

+    /* pass in 0 instead of src_x and src_y because src_x and src_y need to be			\

+     * transformed from destination space to source space */					\

+    PIXMAN_IMAGE_GET_LINE (src_image, 0, 0, src_type_t, src_stride, src_first_line, 1);		\

+												\

+    /* reference point is the center of the pixel */						\

+    v.vector[0] = pixman_int_to_fixed (src_x) + pixman_fixed_1 / 2;				\

+    v.vector[1] = pixman_int_to_fixed (src_y) + pixman_fixed_1 / 2;				\

+    v.vector[2] = pixman_fixed_1;								\

+												\

+    if (!pixman_transform_point_3d (src_image->common.transform, &v))				\

+	return;											\

+												\

+    unit_x = src_image->common.transform->matrix[0][0];						\

+    unit_y = src_image->common.transform->matrix[1][1];						\

+												\

+    v.vector[0] -= pixman_fixed_1 / 2;								\

+    v.vector[1] -= pixman_fixed_1 / 2;								\

+												\

+    vy = v.vector[1];										\

+												\

+    if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_PAD ||					\

+	PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_NONE)					\

+    {												\

+	bilinear_pad_repeat_get_scanline_bounds (src_image->bits.width, v.vector[0], unit_x,	\

+					&left_pad, &left_tz, &width, &right_tz, &right_pad);	\

+	if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_PAD)					\

+	{											\

+	    /* PAD repeat does not need special handling for 'transition zones' and */		\

+	    /* they can be combined with 'padding zones' safely */				\

+	    left_pad += left_tz;								\

+	    right_pad += right_tz;								\

+	    left_tz = right_tz = 0;								\

+	}											\

+	v.vector[0] += left_pad * unit_x;							\

+    }												\

+												\

+    while (--height >= 0)									\

+    {												\

+	int weight1, weight2;									\

+	dst = dst_line;										\

+	dst_line += dst_stride;									\

+	vx = v.vector[0];									\

+	if (have_mask && !mask_is_solid)							\

+	{											\

+	    mask = mask_line;									\

+	    mask_line += mask_stride;								\

+	}											\

+												\

+	y1 = pixman_fixed_to_int (vy);								\

+	weight2 = (vy >> 8) & 0xff;								\

+	if (weight2)										\

+	{											\

+	    /* normal case, both row weights are in 0-255 range and fit unsigned byte */	\

+	    y2 = y1 + 1;									\

+	    weight1 = 256 - weight2;								\

+	}											\

+	else											\

+	{											\

+	    /* set both top and bottom row to the same scanline, and weights to 128+128 */	\

+	    y2 = y1;										\

+	    weight1 = weight2 = 128;								\

+	}											\

+	vy += unit_y;										\

+	if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_PAD)					\

+	{											\

+	    src_type_t *src1, *src2;								\

+	    src_type_t buf1[2];									\

+	    src_type_t buf2[2];									\

+	    repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height);				\

+	    repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height);				\

+	    src1 = src_first_line + src_stride * y1;						\

+	    src2 = src_first_line + src_stride * y2;						\

+												\

+	    if (left_pad > 0)									\

+	    {											\

+		buf1[0] = buf1[1] = src1[0];							\

+		buf2[0] = buf2[1] = src2[0];							\

+		scanline_func (dst, mask,							\

+			       buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, FALSE);		\

+		dst += left_pad;								\

+		if (have_mask && !mask_is_solid)						\

+		    mask += left_pad;								\

+	    }											\

+	    if (width > 0)									\

+	    {											\

+		scanline_func (dst, mask,							\

+			       src1, src2, width, weight1, weight2, vx, unit_x, 0, FALSE);	\

+		dst += width;									\

+		if (have_mask && !mask_is_solid)						\

+		    mask += width;								\

+	    }											\

+	    if (right_pad > 0)									\

+	    {											\

+		buf1[0] = buf1[1] = src1[src_image->bits.width - 1];				\

+		buf2[0] = buf2[1] = src2[src_image->bits.width - 1];				\

+		scanline_func (dst, mask,							\

+			       buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, FALSE);	\

+	    }											\

+	}											\

+	else if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_NONE)				\

+	{											\

+	    src_type_t *src1, *src2;								\

+	    src_type_t buf1[2];									\

+	    src_type_t buf2[2];									\

+	    /* handle top/bottom zero padding by just setting weights to 0 if needed */		\

+	    if (y1 < 0)										\

+	    {											\

+		weight1 = 0;									\

+		y1 = 0;										\

+	    }											\

+	    if (y1 >= src_image->bits.height)							\

+	    {											\

+		weight1 = 0;									\

+		y1 = src_image->bits.height - 1;						\

+	    }											\

+	    if (y2 < 0)										\

+	    {											\

+		weight2 = 0;									\

+		y2 = 0;										\

+	    }											\

+	    if (y2 >= src_image->bits.height)							\

+	    {											\

+		weight2 = 0;									\

+		y2 = src_image->bits.height - 1;						\

+	    }											\

+	    src1 = src_first_line + src_stride * y1;						\

+	    src2 = src_first_line + src_stride * y2;						\

+												\

+	    if (left_pad > 0)									\

+	    {											\

+		buf1[0] = buf1[1] = 0;								\

+		buf2[0] = buf2[1] = 0;								\

+		scanline_func (dst, mask,							\

+			       buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, TRUE);		\

+		dst += left_pad;								\

+		if (have_mask && !mask_is_solid)						\

+		    mask += left_pad;								\

+	    }											\

+	    if (left_tz > 0)									\

+	    {											\

+		buf1[0] = 0;									\

+		buf1[1] = src1[0];								\

+		buf2[0] = 0;									\

+		buf2[1] = src2[0];								\

+		scanline_func (dst, mask,							\

+			       buf1, buf2, left_tz, weight1, weight2,				\

+			       pixman_fixed_frac (vx), unit_x, 0, FALSE);			\

+		dst += left_tz;									\

+		if (have_mask && !mask_is_solid)						\

+		    mask += left_tz;								\

+		vx += left_tz * unit_x;								\

+	    }											\

+	    if (width > 0)									\

+	    {											\

+		scanline_func (dst, mask,							\

+			       src1, src2, width, weight1, weight2, vx, unit_x, 0, FALSE);	\

+		dst += width;									\

+		if (have_mask && !mask_is_solid)						\

+		    mask += width;								\

+		vx += width * unit_x;								\

+	    }											\

+	    if (right_tz > 0)									\

+	    {											\

+		buf1[0] = src1[src_image->bits.width - 1];					\

+		buf1[1] = 0;									\

+		buf2[0] = src2[src_image->bits.width - 1];					\

+		buf2[1] = 0;									\

+		scanline_func (dst, mask,							\

+			       buf1, buf2, right_tz, weight1, weight2,				\

+			       pixman_fixed_frac (vx), unit_x, 0, FALSE);			\

+		dst += right_tz;								\

+		if (have_mask && !mask_is_solid)						\

+		    mask += right_tz;								\

+	    }											\

+	    if (right_pad > 0)									\

+	    {											\

+		buf1[0] = buf1[1] = 0;								\

+		buf2[0] = buf2[1] = 0;								\

+		scanline_func (dst, mask,							\

+			       buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, TRUE);		\

+	    }											\

+	}											\

+	else											\

+	{											\

+	    scanline_func (dst, mask, src_first_line + src_stride * y1,				\

+			   src_first_line + src_stride * y2, width,				\

+			   weight1, weight2, vx, unit_x, max_vx, FALSE);			\

+	}											\

+    }												\

+}

+

+/* A workaround for old sun studio, see: https://bugs.freedesktop.org/show_bug.cgi?id=32764 */

+#define FAST_BILINEAR_MAINLOOP_COMMON(scale_func_name, scanline_func, src_type_t, mask_type_t,	\

+				  dst_type_t, repeat_mode, have_mask, mask_is_solid)		\

+	FAST_BILINEAR_MAINLOOP_INT(_ ## scale_func_name, scanline_func, src_type_t, mask_type_t,\

+				  dst_type_t, repeat_mode, have_mask, mask_is_solid)

+

+#define SCALED_BILINEAR_FLAGS						\

+    (FAST_PATH_SCALE_TRANSFORM	|					\

+     FAST_PATH_NO_ALPHA_MAP	|					\

+     FAST_PATH_BILINEAR_FILTER	|					\

+     FAST_PATH_NO_ACCESSORS	|					\

+     FAST_PATH_NARROW_FORMAT)

+

+#define SIMPLE_BILINEAR_FAST_PATH_PAD(op,s,d,func)			\

+    {   PIXMAN_OP_ ## op,						\

+	PIXMAN_ ## s,							\

+	(SCALED_BILINEAR_FLAGS		|				\

+	 FAST_PATH_PAD_REPEAT		|				\

+	 FAST_PATH_X_UNIT_POSITIVE),					\

+	PIXMAN_null, 0,							\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				\

+	fast_composite_scaled_bilinear_ ## func ## _pad ## _ ## op,	\

+    }

+

+#define SIMPLE_BILINEAR_FAST_PATH_NONE(op,s,d,func)			\

+    {   PIXMAN_OP_ ## op,						\

+	PIXMAN_ ## s,							\

+	(SCALED_BILINEAR_FLAGS		|				\

+	 FAST_PATH_NONE_REPEAT		|				\

+	 FAST_PATH_X_UNIT_POSITIVE),					\

+	PIXMAN_null, 0,							\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				\

+	fast_composite_scaled_bilinear_ ## func ## _none ## _ ## op,	\

+    }

+

+#define SIMPLE_BILINEAR_FAST_PATH_COVER(op,s,d,func)			\

+    {   PIXMAN_OP_ ## op,						\

+	PIXMAN_ ## s,							\

+	SCALED_BILINEAR_FLAGS | FAST_PATH_SAMPLES_COVER_CLIP,		\

+	PIXMAN_null, 0,							\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				\

+	fast_composite_scaled_bilinear_ ## func ## _cover ## _ ## op,	\

+    }

+

+#define SIMPLE_BILINEAR_A8_MASK_FAST_PATH_PAD(op,s,d,func)		\

+    {   PIXMAN_OP_ ## op,						\

+	PIXMAN_ ## s,							\

+	(SCALED_BILINEAR_FLAGS		|				\

+	 FAST_PATH_PAD_REPEAT		|				\

+	 FAST_PATH_X_UNIT_POSITIVE),					\

+	PIXMAN_a8, MASK_FLAGS (a8, FAST_PATH_UNIFIED_ALPHA),		\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				\

+	fast_composite_scaled_bilinear_ ## func ## _pad ## _ ## op,	\

+    }

+

+#define SIMPLE_BILINEAR_A8_MASK_FAST_PATH_NONE(op,s,d,func)		\

+    {   PIXMAN_OP_ ## op,						\

+	PIXMAN_ ## s,							\

+	(SCALED_BILINEAR_FLAGS		|				\

+	 FAST_PATH_NONE_REPEAT		|				\

+	 FAST_PATH_X_UNIT_POSITIVE),					\

+	PIXMAN_a8, MASK_FLAGS (a8, FAST_PATH_UNIFIED_ALPHA),		\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				\

+	fast_composite_scaled_bilinear_ ## func ## _none ## _ ## op,	\

+    }

+

+#define SIMPLE_BILINEAR_A8_MASK_FAST_PATH_COVER(op,s,d,func)		\

+    {   PIXMAN_OP_ ## op,						\

+	PIXMAN_ ## s,							\

+	SCALED_BILINEAR_FLAGS | FAST_PATH_SAMPLES_COVER_CLIP,		\

+	PIXMAN_a8, MASK_FLAGS (a8, FAST_PATH_UNIFIED_ALPHA),		\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				\

+	fast_composite_scaled_bilinear_ ## func ## _cover ## _ ## op,	\

+    }

+

+#define SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_PAD(op,s,d,func)		\

+    {   PIXMAN_OP_ ## op,						\

+	PIXMAN_ ## s,							\

+	(SCALED_BILINEAR_FLAGS		|				\

+	 FAST_PATH_PAD_REPEAT		|				\

+	 FAST_PATH_X_UNIT_POSITIVE),					\

+	PIXMAN_solid, MASK_FLAGS (solid, FAST_PATH_UNIFIED_ALPHA),	\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				\

+	fast_composite_scaled_bilinear_ ## func ## _pad ## _ ## op,	\

+    }

+

+#define SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_NONE(op,s,d,func)		\

+    {   PIXMAN_OP_ ## op,						\

+	PIXMAN_ ## s,							\

+	(SCALED_BILINEAR_FLAGS		|				\

+	 FAST_PATH_NONE_REPEAT		|				\

+	 FAST_PATH_X_UNIT_POSITIVE),					\

+	PIXMAN_solid, MASK_FLAGS (solid, FAST_PATH_UNIFIED_ALPHA),	\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				\

+	fast_composite_scaled_bilinear_ ## func ## _none ## _ ## op,	\

+    }

+

+#define SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_COVER(op,s,d,func)		\

+    {   PIXMAN_OP_ ## op,						\

+	PIXMAN_ ## s,							\

+	SCALED_BILINEAR_FLAGS | FAST_PATH_SAMPLES_COVER_CLIP,		\

+	PIXMAN_solid, MASK_FLAGS (solid, FAST_PATH_UNIFIED_ALPHA),	\

+	PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,				\

+	fast_composite_scaled_bilinear_ ## func ## _cover ## _ ## op,	\

+    }

+

+/* Prefer the use of 'cover' variant, because it is faster */

+#define SIMPLE_BILINEAR_FAST_PATH(op,s,d,func)				\

+    SIMPLE_BILINEAR_FAST_PATH_COVER (op,s,d,func),			\

+    SIMPLE_BILINEAR_FAST_PATH_NONE (op,s,d,func),			\

+    SIMPLE_BILINEAR_FAST_PATH_PAD (op,s,d,func)

+

+#define SIMPLE_BILINEAR_A8_MASK_FAST_PATH(op,s,d,func)			\

+    SIMPLE_BILINEAR_A8_MASK_FAST_PATH_COVER (op,s,d,func),		\

+    SIMPLE_BILINEAR_A8_MASK_FAST_PATH_NONE (op,s,d,func),		\

+    SIMPLE_BILINEAR_A8_MASK_FAST_PATH_PAD (op,s,d,func)

+

+#define SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH(op,s,d,func)		\

+    SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_COVER (op,s,d,func),		\

+    SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_NONE (op,s,d,func),		\

+    SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_PAD (op,s,d,func)

+

 #endif

diff --git a/pixman/pixman/pixman-general.c b/pixman/pixman/pixman-general.c
index 16ea3a457..1e0091094 100644
--- a/pixman/pixman/pixman-general.c
+++ b/pixman/pixman/pixman-general.c
@@ -1,313 +1,311 @@
-/*
- * Copyright © 2009 Red Hat, Inc.
- * Copyright © 2000 SuSE, Inc.
- * Copyright © 2007 Red Hat, Inc.
- * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
- *             2005 Lars Knoll & Zack Rusin, Trolltech
- *             2008 Aaron Plattner, NVIDIA Corporation
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Red Hat not be used in advertising or
- * publicity pertaining to distribution of the software without specific,
- * written prior permission.  Red Hat makes no representations about the
- * suitability of this software for any purpose.  It is provided "as is"
- * without express or implied warranty.
- *
- * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
- * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
- * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
- * SOFTWARE.
- */
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "pixman-private.h"
-#include "pixman-combine32.h"
-#include "pixman-private.h"
-
-static void
-general_src_iter_init (pixman_implementation_t *imp,
-		       pixman_iter_t *iter,
-		       pixman_image_t *image,
-		       int x, int y, int width, int height,
-		       uint8_t *buffer, iter_flags_t flags)
-{
-    iter->image = image;
-    iter->x = x;
-    iter->y = y;
-    iter->width = width;
-    iter->buffer = (uint32_t *)buffer;
-
-    if (image->type == SOLID)
-    {
-	_pixman_solid_fill_iter_init (
-	    image, iter, x, y, width, height, buffer, flags);
-    }
-    else if (image->type == LINEAR)
-    {
-	_pixman_linear_gradient_iter_init (
-	    image, iter, x, y, width, height, buffer, flags);
-    }
-    else if (image->type == RADIAL)
-    {
-	_pixman_radial_gradient_iter_init (
-	    image, iter, x, y, width, height, buffer, flags);
-    }
-    else if (image->type == CONICAL)
-    {
-	_pixman_conical_gradient_iter_init (
-	    image, iter, x, y, width, height, buffer, flags);
-    }
-    else if (image->type == BITS)
-    {
-	_pixman_bits_image_src_iter_init (
-	    image, iter, x, y, width, height, buffer, flags);
-    }
-    else
-    {
-	_pixman_log_error (FUNC, "Pixman bug: unknown image type\n");
-    }
-}
-
-static void
-general_dest_iter_init (pixman_implementation_t *imp,
-			pixman_iter_t *iter,
-			pixman_image_t *image,
-			int x, int y, int width, int height,
-			uint8_t *buffer, iter_flags_t flags)
-{
-    iter->image = image;
-    iter->x = x;
-    iter->y = y;
-    iter->width = width;
-    iter->buffer = (uint32_t *)buffer;
-
-    if (image->type == BITS)
-    {
-	_pixman_bits_image_dest_iter_init (
-	    image, iter, x, y, width, height, buffer, flags);
-    }
-    else
-    {
-	_pixman_log_error (FUNC, "Trying to write to a non-writable image");
-    }
-}
-
-typedef struct op_info_t op_info_t;
-struct op_info_t
-{
-    uint8_t src, dst;
-};
-
-#define ITER_IGNORE_BOTH						\
-    (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB | ITER_LOCALIZED_ALPHA)
-
-static const op_info_t op_flags[PIXMAN_N_OPERATORS] =
-{
-    /* Src                   Dst                   */
-    { ITER_IGNORE_BOTH,      ITER_IGNORE_BOTH      }, /* CLEAR */
-    { ITER_LOCALIZED_ALPHA,  ITER_IGNORE_BOTH      }, /* SRC */
-    { ITER_IGNORE_BOTH,      ITER_LOCALIZED_ALPHA  }, /* DST */
-    { 0,                     ITER_LOCALIZED_ALPHA  }, /* OVER */
-    { ITER_LOCALIZED_ALPHA,  0                     }, /* OVER_REVERSE */
-    { ITER_LOCALIZED_ALPHA,  ITER_IGNORE_RGB       }, /* IN */
-    { ITER_IGNORE_RGB,       ITER_LOCALIZED_ALPHA  }, /* IN_REVERSE */
-    { ITER_LOCALIZED_ALPHA,  ITER_IGNORE_RGB       }, /* OUT */
-    { ITER_IGNORE_RGB,       ITER_LOCALIZED_ALPHA  }, /* OUT_REVERSE */
-    { 0,                     0                     }, /* ATOP */
-    { 0,                     0                     }, /* ATOP_REVERSE */
-    { 0,                     0                     }, /* XOR */
-    { ITER_LOCALIZED_ALPHA,  ITER_LOCALIZED_ALPHA  }, /* ADD */
-    { 0,                     0                     }, /* SATURATE */
-};
-
-#define SCANLINE_BUFFER_LENGTH 8192
-
-static void
-general_composite_rect  (pixman_implementation_t *imp,
-                         pixman_op_t              op,
-                         pixman_image_t *         src,
-                         pixman_image_t *         mask,
-                         pixman_image_t *         dest,
-                         int32_t                  src_x,
-                         int32_t                  src_y,
-                         int32_t                  mask_x,
-                         int32_t                  mask_y,
-                         int32_t                  dest_x,
-                         int32_t                  dest_y,
-                         int32_t                  width,
-                         int32_t                  height)
-{
-    uint64_t stack_scanline_buffer[(SCANLINE_BUFFER_LENGTH * 3 + 7) / 8];
-    uint8_t *scanline_buffer = (uint8_t *) stack_scanline_buffer;
-    uint8_t *src_buffer, *mask_buffer, *dest_buffer;
-    pixman_iter_t src_iter, mask_iter, dest_iter;
-    pixman_combine_32_func_t compose;
-    pixman_bool_t component_alpha;
-    iter_flags_t narrow, src_flags;
-    int Bpp;
-    int i;
-
-    if ((src->common.flags & FAST_PATH_NARROW_FORMAT)		&&
-	(!mask || mask->common.flags & FAST_PATH_NARROW_FORMAT)	&&
-	(dest->common.flags & FAST_PATH_NARROW_FORMAT))
-    {
-	narrow = ITER_NARROW;
-	Bpp = 4;
-    }
-    else
-    {
-	narrow = 0;
-	Bpp = 8;
-    }
-
-    if (width * Bpp > SCANLINE_BUFFER_LENGTH)
-    {
-	scanline_buffer = pixman_malloc_abc (width, 3, Bpp);
-
-	if (!scanline_buffer)
-	    return;
-    }
-
-    src_buffer = scanline_buffer;
-    mask_buffer = src_buffer + width * Bpp;
-    dest_buffer = mask_buffer + width * Bpp;
-
-    /* src iter */
-    src_flags = narrow | op_flags[op].src;
-
-    _pixman_implementation_src_iter_init (imp->toplevel, &src_iter, src,
-					  src_x, src_y, width, height,
-					  src_buffer, src_flags);
-
-    /* mask iter */
-    if ((src_flags & (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB)) ==
-	(ITER_IGNORE_ALPHA | ITER_IGNORE_RGB))
-    {
-	/* If it doesn't matter what the source is, then it doesn't matter
-	 * what the mask is
-	 */
-	mask = NULL;
-    }
-
-    component_alpha =
-        mask                            &&
-        mask->common.type == BITS       &&
-        mask->common.component_alpha    &&
-        PIXMAN_FORMAT_RGB (mask->bits.format);
-
-    _pixman_implementation_src_iter_init (
-	imp->toplevel, &mask_iter, mask, mask_x, mask_y, width, height,
-	mask_buffer, narrow | (component_alpha? 0 : ITER_IGNORE_RGB));
-
-    /* dest iter */
-    _pixman_implementation_dest_iter_init (imp->toplevel, &dest_iter, dest,
-					   dest_x, dest_y, width, height,
-					   dest_buffer,
-					   narrow | op_flags[op].dst);
-
-    if (narrow)
-    {
-	if (component_alpha)
-	    compose = _pixman_implementation_combine_32_ca;
-	else
-	    compose = _pixman_implementation_combine_32;
-    }
-    else
-    {
-	if (component_alpha)
-	    compose = (pixman_combine_32_func_t)_pixman_implementation_combine_64_ca;
-	else
-	    compose = (pixman_combine_32_func_t)_pixman_implementation_combine_64;
-    }
-
-    if (!compose)
-	return;
-
-    for (i = 0; i < height; ++i)
-    {
-	uint32_t *s, *m, *d;
-
-	m = mask_iter.get_scanline (&mask_iter, NULL);
-	s = src_iter.get_scanline (&src_iter, m);
-	d = dest_iter.get_scanline (&dest_iter, NULL);
-
-	compose (imp->toplevel, op, d, s, m, width);
-
-	dest_iter.write_back (&dest_iter);
-    }
-
-    if (scanline_buffer != (uint8_t *) stack_scanline_buffer)
-	free (scanline_buffer);
-}
-
-static const pixman_fast_path_t general_fast_path[] =
-{
-    { PIXMAN_OP_any, PIXMAN_any, 0, PIXMAN_any,	0, PIXMAN_any, 0, general_composite_rect },
-    { PIXMAN_OP_NONE }
-};
-
-static pixman_bool_t
-general_blt (pixman_implementation_t *imp,
-             uint32_t *               src_bits,
-             uint32_t *               dst_bits,
-             int                      src_stride,
-             int                      dst_stride,
-             int                      src_bpp,
-             int                      dst_bpp,
-             int                      src_x,
-             int                      src_y,
-             int                      dst_x,
-             int                      dst_y,
-             int                      width,
-             int                      height)
-{
-    /* We can't blit unless we have sse2 or mmx */
-
-    return FALSE;
-}
-
-static pixman_bool_t
-general_fill (pixman_implementation_t *imp,
-              uint32_t *               bits,
-              int                      stride,
-              int                      bpp,
-              int                      x,
-              int                      y,
-              int                      width,
-              int                      height,
-              uint32_t xor)
-{
-    return FALSE;
-}
-
-pixman_implementation_t *
-_pixman_implementation_create_general (void)
-{
-    pixman_implementation_t *imp = _pixman_implementation_create (NULL, general_fast_path);
-
-    _pixman_setup_combiner_functions_32 (imp);
-    _pixman_setup_combiner_functions_64 (imp);
-
-    imp->blt = general_blt;
-    imp->fill = general_fill;
-    imp->src_iter_init = general_src_iter_init;
-    imp->dest_iter_init = general_dest_iter_init;
-
-    return imp;
-}
-
+/*

+ * Copyright © 2009 Red Hat, Inc.

+ * Copyright © 2000 SuSE, Inc.

+ * Copyright © 2007 Red Hat, Inc.

+ * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.

+ *             2005 Lars Knoll & Zack Rusin, Trolltech

+ *             2008 Aaron Plattner, NVIDIA Corporation

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Red Hat not be used in advertising or

+ * publicity pertaining to distribution of the software without specific,

+ * written prior permission.  Red Hat makes no representations about the

+ * suitability of this software for any purpose.  It is provided "as is"

+ * without express or implied warranty.

+ *

+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY

+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN

+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

+ * SOFTWARE.

+ */

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include <stdlib.h>

+#include <string.h>

+#include <math.h>

+#include <limits.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include "pixman-private.h"

+

+static void

+general_src_iter_init (pixman_implementation_t *imp,

+		       pixman_iter_t *iter,

+		       pixman_image_t *image,

+		       int x, int y, int width, int height,

+		       uint8_t *buffer, iter_flags_t flags)

+{

+    iter->image = image;

+    iter->x = x;

+    iter->y = y;

+    iter->width = width;

+    iter->buffer = (uint32_t *)buffer;

+

+    if (image->type == SOLID)

+    {

+	_pixman_solid_fill_iter_init (

+	    image, iter, x, y, width, height, buffer, flags);

+    }

+    else if (image->type == LINEAR)

+    {

+	_pixman_linear_gradient_iter_init (

+	    image, iter, x, y, width, height, buffer, flags);

+    }

+    else if (image->type == RADIAL)

+    {

+	_pixman_radial_gradient_iter_init (

+	    image, iter, x, y, width, height, buffer, flags);

+    }

+    else if (image->type == CONICAL)

+    {

+	_pixman_conical_gradient_iter_init (

+	    image, iter, x, y, width, height, buffer, flags);

+    }

+    else if (image->type == BITS)

+    {

+	_pixman_bits_image_src_iter_init (

+	    image, iter, x, y, width, height, buffer, flags);

+    }

+    else

+    {

+	_pixman_log_error (FUNC, "Pixman bug: unknown image type\n");

+    }

+}

+

+static void

+general_dest_iter_init (pixman_implementation_t *imp,

+			pixman_iter_t *iter,

+			pixman_image_t *image,

+			int x, int y, int width, int height,

+			uint8_t *buffer, iter_flags_t flags)

+{

+    iter->image = image;

+    iter->x = x;

+    iter->y = y;

+    iter->width = width;

+    iter->buffer = (uint32_t *)buffer;

+

+    if (image->type == BITS)

+    {

+	_pixman_bits_image_dest_iter_init (

+	    image, iter, x, y, width, height, buffer, flags);

+    }

+    else

+    {

+	_pixman_log_error (FUNC, "Trying to write to a non-writable image");

+    }

+}

+

+typedef struct op_info_t op_info_t;

+struct op_info_t

+{

+    uint8_t src, dst;

+};

+

+#define ITER_IGNORE_BOTH						\

+    (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB | ITER_LOCALIZED_ALPHA)

+

+static const op_info_t op_flags[PIXMAN_N_OPERATORS] =

+{

+    /* Src                   Dst                   */

+    { ITER_IGNORE_BOTH,      ITER_IGNORE_BOTH      }, /* CLEAR */

+    { ITER_LOCALIZED_ALPHA,  ITER_IGNORE_BOTH      }, /* SRC */

+    { ITER_IGNORE_BOTH,      ITER_LOCALIZED_ALPHA  }, /* DST */

+    { 0,                     ITER_LOCALIZED_ALPHA  }, /* OVER */

+    { ITER_LOCALIZED_ALPHA,  0                     }, /* OVER_REVERSE */

+    { ITER_LOCALIZED_ALPHA,  ITER_IGNORE_RGB       }, /* IN */

+    { ITER_IGNORE_RGB,       ITER_LOCALIZED_ALPHA  }, /* IN_REVERSE */

+    { ITER_LOCALIZED_ALPHA,  ITER_IGNORE_RGB       }, /* OUT */

+    { ITER_IGNORE_RGB,       ITER_LOCALIZED_ALPHA  }, /* OUT_REVERSE */

+    { 0,                     0                     }, /* ATOP */

+    { 0,                     0                     }, /* ATOP_REVERSE */

+    { 0,                     0                     }, /* XOR */

+    { ITER_LOCALIZED_ALPHA,  ITER_LOCALIZED_ALPHA  }, /* ADD */

+    { 0,                     0                     }, /* SATURATE */

+};

+

+#define SCANLINE_BUFFER_LENGTH 8192

+

+static void

+general_composite_rect  (pixman_implementation_t *imp,

+                         pixman_op_t              op,

+                         pixman_image_t *         src,

+                         pixman_image_t *         mask,

+                         pixman_image_t *         dest,

+                         int32_t                  src_x,

+                         int32_t                  src_y,

+                         int32_t                  mask_x,

+                         int32_t                  mask_y,

+                         int32_t                  dest_x,

+                         int32_t                  dest_y,

+                         int32_t                  width,

+                         int32_t                  height)

+{

+    uint64_t stack_scanline_buffer[(SCANLINE_BUFFER_LENGTH * 3 + 7) / 8];

+    uint8_t *scanline_buffer = (uint8_t *) stack_scanline_buffer;

+    uint8_t *src_buffer, *mask_buffer, *dest_buffer;

+    pixman_iter_t src_iter, mask_iter, dest_iter;

+    pixman_combine_32_func_t compose;

+    pixman_bool_t component_alpha;

+    iter_flags_t narrow, src_flags;

+    int Bpp;

+    int i;

+

+    if ((src->common.flags & FAST_PATH_NARROW_FORMAT)		&&

+	(!mask || mask->common.flags & FAST_PATH_NARROW_FORMAT)	&&

+	(dest->common.flags & FAST_PATH_NARROW_FORMAT))

+    {

+	narrow = ITER_NARROW;

+	Bpp = 4;

+    }

+    else

+    {

+	narrow = 0;

+	Bpp = 8;

+    }

+

+    if (width * Bpp > SCANLINE_BUFFER_LENGTH)

+    {

+	scanline_buffer = pixman_malloc_abc (width, 3, Bpp);

+

+	if (!scanline_buffer)

+	    return;

+    }

+

+    src_buffer = scanline_buffer;

+    mask_buffer = src_buffer + width * Bpp;

+    dest_buffer = mask_buffer + width * Bpp;

+

+    /* src iter */

+    src_flags = narrow | op_flags[op].src;

+

+    _pixman_implementation_src_iter_init (imp->toplevel, &src_iter, src,

+					  src_x, src_y, width, height,

+					  src_buffer, src_flags);

+

+    /* mask iter */

+    if ((src_flags & (ITER_IGNORE_ALPHA | ITER_IGNORE_RGB)) ==

+	(ITER_IGNORE_ALPHA | ITER_IGNORE_RGB))

+    {

+	/* If it doesn't matter what the source is, then it doesn't matter

+	 * what the mask is

+	 */

+	mask = NULL;

+    }

+

+    component_alpha =

+        mask                            &&

+        mask->common.type == BITS       &&

+        mask->common.component_alpha    &&

+        PIXMAN_FORMAT_RGB (mask->bits.format);

+

+    _pixman_implementation_src_iter_init (

+	imp->toplevel, &mask_iter, mask, mask_x, mask_y, width, height,

+	mask_buffer, narrow | (component_alpha? 0 : ITER_IGNORE_RGB));

+

+    /* dest iter */

+    _pixman_implementation_dest_iter_init (imp->toplevel, &dest_iter, dest,

+					   dest_x, dest_y, width, height,

+					   dest_buffer,

+					   narrow | op_flags[op].dst);

+

+    if (narrow)

+    {

+	if (component_alpha)

+	    compose = _pixman_implementation_combine_32_ca;

+	else

+	    compose = _pixman_implementation_combine_32;

+    }

+    else

+    {

+	if (component_alpha)

+	    compose = (pixman_combine_32_func_t)_pixman_implementation_combine_64_ca;

+	else

+	    compose = (pixman_combine_32_func_t)_pixman_implementation_combine_64;

+    }

+

+    if (!compose)

+	return;

+

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

+    {

+	uint32_t *s, *m, *d;

+

+	m = mask_iter.get_scanline (&mask_iter, NULL);

+	s = src_iter.get_scanline (&src_iter, m);

+	d = dest_iter.get_scanline (&dest_iter, NULL);

+

+	compose (imp->toplevel, op, d, s, m, width);

+

+	dest_iter.write_back (&dest_iter);

+    }

+

+    if (scanline_buffer != (uint8_t *) stack_scanline_buffer)

+	free (scanline_buffer);

+}

+

+static const pixman_fast_path_t general_fast_path[] =

+{

+    { PIXMAN_OP_any, PIXMAN_any, 0, PIXMAN_any,	0, PIXMAN_any, 0, general_composite_rect },

+    { PIXMAN_OP_NONE }

+};

+

+static pixman_bool_t

+general_blt (pixman_implementation_t *imp,

+             uint32_t *               src_bits,

+             uint32_t *               dst_bits,

+             int                      src_stride,

+             int                      dst_stride,

+             int                      src_bpp,

+             int                      dst_bpp,

+             int                      src_x,

+             int                      src_y,

+             int                      dst_x,

+             int                      dst_y,

+             int                      width,

+             int                      height)

+{

+    /* We can't blit unless we have sse2 or mmx */

+

+    return FALSE;

+}

+

+static pixman_bool_t

+general_fill (pixman_implementation_t *imp,

+              uint32_t *               bits,

+              int                      stride,

+              int                      bpp,

+              int                      x,

+              int                      y,

+              int                      width,

+              int                      height,

+              uint32_t xor)

+{

+    return FALSE;

+}

+

+pixman_implementation_t *

+_pixman_implementation_create_general (void)

+{

+    pixman_implementation_t *imp = _pixman_implementation_create (NULL, general_fast_path);

+

+    _pixman_setup_combiner_functions_32 (imp);

+    _pixman_setup_combiner_functions_64 (imp);

+

+    imp->blt = general_blt;

+    imp->fill = general_fill;

+    imp->src_iter_init = general_src_iter_init;

+    imp->dest_iter_init = general_dest_iter_init;

+

+    return imp;

+}

+

diff --git a/pixman/pixman/pixman-image.c b/pixman/pixman/pixman-image.c
index 306692fe0..584150dca 100644
--- a/pixman/pixman/pixman-image.c
+++ b/pixman/pixman/pixman-image.c
@@ -30,7 +30,6 @@
 #include <assert.h>

 

 #include "pixman-private.h"

-#include "pixman-combine32.h"

 

 pixman_bool_t

 _pixman_init_gradient (gradient_t *                  gradient,

diff --git a/pixman/pixman/pixman-sse2.c b/pixman/pixman/pixman-sse2.c
index e7ecc8733..a983164d4 100644
--- a/pixman/pixman/pixman-sse2.c
+++ b/pixman/pixman/pixman-sse2.c
@@ -5567,6 +5567,114 @@ FAST_NEAREST_MAINLOOP_COMMON (sse2_8888_n_8888_none_OVER,
 			      scaled_nearest_scanline_sse2_8888_n_8888_OVER,

 			      uint32_t, uint32_t, uint32_t, NONE, TRUE, TRUE)

 

+static void

+bilinear_interpolate_line_sse2 (uint32_t *       out,

+                                const uint32_t * top,

+                                const uint32_t * bottom,

+                                int              wt,

+                                int              wb,

+                                pixman_fixed_t   x,

+                                pixman_fixed_t   ux,

+                                int              width)

+{

+    const __m128i xmm_wt = _mm_set_epi16 (wt, wt, wt, wt, wt, wt, wt, wt);

+    const __m128i xmm_wb = _mm_set_epi16 (wb, wb, wb, wb, wb, wb, wb, wb);

+    const __m128i xmm_xorc = _mm_set_epi16 (0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff);

+    const __m128i xmm_addc = _mm_set_epi16 (0, 0, 0, 0, 1, 1, 1, 1);

+    const __m128i xmm_ux = _mm_set_epi16 (ux, ux, ux, ux, ux, ux, ux, ux);

+    const __m128i xmm_zero = _mm_setzero_si128 ();

+    __m128i xmm_x = _mm_set_epi16 (x, x, x, x, x, x, x, x);

+    uint32_t pix1, pix2, pix3, pix4;

+

+    #define INTERPOLATE_ONE_PIXEL(pix)						\

+    do {									\

+	__m128i xmm_wh, xmm_lo, xmm_hi, a;					\

+	/* fetch 2x2 pixel block into sse2 register */				\

+	uint32_t tl = top [pixman_fixed_to_int (x)];				\

+	uint32_t tr = top [pixman_fixed_to_int (x) + 1];			\

+	uint32_t bl = bottom [pixman_fixed_to_int (x)];				\

+	uint32_t br = bottom [pixman_fixed_to_int (x) + 1];			\

+	a = _mm_set_epi32 (tr, tl, br, bl);					\

+        x += ux;								\

+	/* vertical interpolation */						\

+	a = _mm_add_epi16 (_mm_mullo_epi16 (_mm_unpackhi_epi8 (a, xmm_zero),	\

+					    xmm_wt),				\

+			   _mm_mullo_epi16 (_mm_unpacklo_epi8 (a, xmm_zero),	\

+					    xmm_wb));				\

+	/* calculate horizontal weights */					\

+	xmm_wh = _mm_add_epi16 (xmm_addc,					\

+				_mm_xor_si128 (xmm_xorc,			\

+					       _mm_srli_epi16 (xmm_x, 8)));	\

+	xmm_x = _mm_add_epi16 (xmm_x, xmm_ux);					\

+	/* horizontal interpolation */						\

+	xmm_lo = _mm_mullo_epi16 (a, xmm_wh);					\

+	xmm_hi = _mm_mulhi_epu16 (a, xmm_wh);					\

+	a = _mm_add_epi32 (_mm_unpacklo_epi16 (xmm_lo, xmm_hi),			\

+			   _mm_unpackhi_epi16 (xmm_lo, xmm_hi));		\

+	/* shift and pack the result */						\

+	a = _mm_srli_epi32 (a, 16);						\

+	a = _mm_packs_epi32 (a, a);						\

+	a = _mm_packus_epi16 (a, a);						\

+	pix = _mm_cvtsi128_si32 (a);						\

+    } while (0)

+

+    while ((width -= 4) >= 0)

+    {

+	INTERPOLATE_ONE_PIXEL (pix1);

+	INTERPOLATE_ONE_PIXEL (pix2);

+	INTERPOLATE_ONE_PIXEL (pix3);

+	INTERPOLATE_ONE_PIXEL (pix4);

+	*out++ = pix1;

+	*out++ = pix2;

+	*out++ = pix3;

+	*out++ = pix4;

+    }

+    if (width & 2)

+    {

+	INTERPOLATE_ONE_PIXEL (pix1);

+	INTERPOLATE_ONE_PIXEL (pix2);

+	*out++ = pix1;

+	*out++ = pix2;

+    }

+    if (width & 1)

+    {

+	INTERPOLATE_ONE_PIXEL (pix1);

+	*out = pix1;

+    }

+

+    #undef INTERPOLATE_ONE_PIXEL

+}

+

+static force_inline void

+scaled_bilinear_scanline_sse2_8888_8888_SRC (uint32_t *       dst,

+					     const uint32_t * mask,

+					     const uint32_t * src_top,

+					     const uint32_t * src_bottom,

+					     int32_t          w,

+					     int              wt,

+					     int              wb,

+					     pixman_fixed_t   vx,

+					     pixman_fixed_t   unit_x,

+					     pixman_fixed_t   max_vx,

+					     pixman_bool_t    zero_src)

+{

+    bilinear_interpolate_line_sse2 (dst, src_top, src_bottom,

+				    wt, wb, vx, unit_x, w);

+}

+

+FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_cover_SRC,

+			       scaled_bilinear_scanline_sse2_8888_8888_SRC,

+			       uint32_t, uint32_t, uint32_t,

+			       COVER, FALSE, FALSE)

+FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_pad_SRC,

+			       scaled_bilinear_scanline_sse2_8888_8888_SRC,

+			       uint32_t, uint32_t, uint32_t,

+			       PAD, FALSE, FALSE)

+FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_none_SRC,

+			       scaled_bilinear_scanline_sse2_8888_8888_SRC,

+			       uint32_t, uint32_t, uint32_t,

+			       NONE, FALSE, FALSE)

+

 static const pixman_fast_path_t sse2_fast_paths[] =

 {

     /* PIXMAN_OP_OVER */

@@ -5668,6 +5776,10 @@ static const pixman_fast_path_t sse2_fast_paths[] =
     SIMPLE_NEAREST_SOLID_MASK_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, sse2_8888_n_8888),

     SIMPLE_NEAREST_SOLID_MASK_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, sse2_8888_n_8888),

 

+    SIMPLE_BILINEAR_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8, sse2_8888_8888),

+    SIMPLE_BILINEAR_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8, sse2_8888_8888),

+    SIMPLE_BILINEAR_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8, sse2_8888_8888),

+

     { PIXMAN_OP_NONE },

 };

 

diff --git a/pixman/test/Makefile.am b/pixman/test/Makefile.am
index f05b99918..d785c2c2e 100644
--- a/pixman/test/Makefile.am
+++ b/pixman/test/Makefile.am
@@ -13,6 +13,7 @@ TESTPROGRAMS =			\
 	trap-crasher		\

 	alpha-loop		\

 	scaling-crash-test	\

+	scaling-helpers-test	\

 	gradient-crash-test	\

 	alphamap		\

 	stress-test		\

@@ -33,6 +34,7 @@ alpha_loop_SOURCES = alpha-loop.c utils.c utils.h
 composite_SOURCES = composite.c utils.c utils.h

 gradient_crash_test_SOURCES = gradient-crash-test.c utils.c utils.h

 stress_test_SOURCES = stress-test.c utils.c utils.h

+scaling_helpers_test_SOURCES = scaling-helpers-test.c utils.c utils.h

 

 # Benchmarks

 

diff --git a/pixman/test/Makefile.win32 b/pixman/test/Makefile.win32
new file mode 100644
index 000000000..c71afe187
--- /dev/null
+++ b/pixman/test/Makefile.win32
@@ -0,0 +1,73 @@
+CC   = cl
+LINK = link
+
+CFG_VAR = $(CFG)
+ifeq ($(CFG_VAR),)
+CFG_VAR=release
+endif
+
+CFLAGS     = -MD -nologo -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE -D_BIND_TO_CURRENT_VCLIBS_VERSION -D_MT -I../pixman -I. -I../
+TEST_LDADD = ../pixman/$(CFG_VAR)/pixman-1.lib
+INCLUDES = -I../pixman -I$(top_builddir)/pixman
+
+# optimization flags
+ifeq ($(CFG_VAR),debug)
+CFLAGS += -Od -Zi
+else
+CFLAGS += -O2
+endif
+
+SOURCES =			\
+	a1-trap-test.c		\
+	pdf-op-test.c		\
+	region-test.c		\
+	region-translate-test.c	\
+	fetch-test.c		\
+	oob-test.c		\
+	trap-crasher.c		\
+	alpha-loop.c		\
+	scaling-crash-test.c	\
+	gradient-crash-test.c	\
+	alphamap.c		\
+	stress-test.c		\
+	composite-traps-test.c	\
+	blitters-test.c		\
+	scaling-test.c		\
+	affine-test.c		\
+	composite.c		\
+	utils.c
+
+TESTS =						\
+	$(CFG_VAR)/a1-trap-test.exe		\
+	$(CFG_VAR)/pdf-op-test.exe		\
+	$(CFG_VAR)/region-test.exe		\
+	$(CFG_VAR)/region-translate-test.exe	\
+	$(CFG_VAR)/fetch-test.exe		\
+	$(CFG_VAR)/oob-test.exe			\
+	$(CFG_VAR)/trap-crasher.exe		\
+	$(CFG_VAR)/alpha-loop.exe		\
+	$(CFG_VAR)/scaling-crash-test.exe	\
+	$(CFG_VAR)/gradient-crash-test.exe	\
+	$(CFG_VAR)/alphamap.exe			\
+	$(CFG_VAR)/stress-test.exe		\
+	$(CFG_VAR)/composite-traps-test.exe	\
+	$(CFG_VAR)/blitters-test.exe		\
+	$(CFG_VAR)/scaling-test.exe		\
+	$(CFG_VAR)/affine-test.exe		\
+	$(CFG_VAR)/composite.exe
+
+
+OBJECTS     = $(patsubst %.c, $(CFG_VAR)/%.obj, $(SOURCES))
+
+$(CFG_VAR)/%.obj: %.c
+	@mkdir -p $(CFG_VAR)
+	@$(CC) -c $(CFLAGS) -Fo"$@" $<
+
+$(CFG_VAR)/%.exe: $(CFG_VAR)/%.obj
+	$(LINK) /NOLOGO /OUT:$@ $< $(CFG_VAR)/utils.obj $(TEST_LDADD)
+
+all: $(OBJECTS) $(TESTS)
+	@exit 0
+
+clean:
+	@rm -f $(CFG_VAR)/*.obj $(CFG_VAR)/*.pdb || exit 0
diff --git a/pixman/test/composite.c b/pixman/test/composite.c
index 8b8a8f540..50a3c0644 100644
--- a/pixman/test/composite.c
+++ b/pixman/test/composite.c
@@ -426,6 +426,7 @@ calc_op (pixman_op_t op, double src, double dst, double srca, double dsta)
     case PIXMAN_OP_HSL_LUMINOSITY:

     default:

 	abort();

+	return 0; /* silence MSVC */

     }

 #undef mult_chan

 }

@@ -617,18 +618,18 @@ eval_diff (color_t *expected, color_t *test, pixman_format_code_t format)
 }

 

 static char *

-describe_image (image_t *info, char *buf, int buflen)

+describe_image (image_t *info, char *buf)

 {

     if (info->size)

     {

-	snprintf (buf, buflen, "%s %dx%d%s",

-		  info->format->name,

-		  info->size, info->size,

-		  info->repeat ? "R" :"");

+	sprintf (buf, "%s %dx%d%s",

+		 info->format->name,

+		 info->size, info->size,

+		 info->repeat ? "R" :"");

     }

     else

     {

-	snprintf (buf, buflen, "solid");

+	sprintf (buf, "solid");

     }

 

     return buf;

@@ -710,10 +711,9 @@ composite_test (image_t *dst,
     {

 	char buf[40];

 

-	snprintf (buf, sizeof (buf),

-		  "%s %scomposite",

-		  op->name,

-		  component_alpha ? "CA " : "");

+	sprintf (buf, "%s %scomposite",

+		 op->name,

+		 component_alpha ? "CA " : "");

 

 	printf ("%s test error of %.4f --\n"

 		"           R    G    B    A\n"

@@ -735,9 +735,9 @@ composite_test (image_t *dst,
 		    mask->color->b, mask->color->a,

 		    dst->color->r, dst->color->g,

 		    dst->color->b, dst->color->a);

-	    printf ("src: %s, ", describe_image (src, buf, sizeof (buf)));

-	    printf ("mask: %s, ", describe_image (mask, buf, sizeof (buf)));

-	    printf ("dst: %s\n\n", describe_image (dst, buf, sizeof (buf)));

+	    printf ("src: %s, ", describe_image (src, buf));

+	    printf ("mask: %s, ", describe_image (mask, buf));

+	    printf ("dst: %s\n\n", describe_image (dst, buf));

 	}

 	else

 	{

@@ -747,8 +747,8 @@ composite_test (image_t *dst,
 		    src->color->b, src->color->a,

 		    dst->color->r, dst->color->g,

 		    dst->color->b, dst->color->a);

-	    printf ("src: %s, ", describe_image (src, buf, sizeof (buf)));

-	    printf ("dst: %s\n\n", describe_image (dst, buf, sizeof (buf)));

+	    printf ("src: %s, ", describe_image (src, buf));

+	    printf ("dst: %s\n\n", describe_image (dst, buf));

 	}

 

 	success = FALSE;

diff --git a/pixman/test/fetch-test.c b/pixman/test/fetch-test.c
index 2ca16ddbf..4554f9f9b 100644
--- a/pixman/test/fetch-test.c
+++ b/pixman/test/fetch-test.c
@@ -1,201 +1,196 @@
-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "pixman.h"
-#include <config.h>
-
-#define SIZE 1024
-
-static pixman_indexed_t mono_palette =
-{
-    .rgba = { 0x00000000, 0x00ffffff },
-};
-
-
-typedef struct {
-    pixman_format_code_t format;
-    int width, height;
-    int stride;
-    uint32_t src[SIZE];
-    uint32_t dst[SIZE];
-    pixman_indexed_t *indexed;
-} testcase_t;
-
-static testcase_t testcases[] =
-{
-    {
-	.format = PIXMAN_a8r8g8b8,
-	.width = 2, .height = 2,
-	.stride = 8,
-	.src = { 0x00112233, 0x44556677,
-	         0x8899aabb, 0xccddeeff },
-	.dst = { 0x00112233, 0x44556677,
-	         0x8899aabb, 0xccddeeff },
-	.indexed = NULL,
-    },
-    {
-	.format = PIXMAN_g1,
-	.width = 8, .height = 2,
-	.stride = 4,
-#ifdef WORDS_BIGENDIAN
-	.src =
-	{
-	    0xaa000000,
-	    0x55000000
-	},
-#else
-	.src =
-	{
-	    0x00000055,
-	    0x000000aa
-	},
-#endif
-	.dst =
-	{
-	    0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000,
-	    0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff
-	},
-	.indexed = &mono_palette,
-    },
-#if 0
-    {
-	.format = PIXMAN_g8,
-	.width = 4, .height = 2,
-	.stride = 4,
-	.src = { 0x01234567,
-	         0x89abcdef },
-	.dst = { 0x00010101, 0x00232323, 0x00454545, 0x00676767,
-	         0x00898989, 0x00ababab, 0x00cdcdcd, 0x00efefef, },
-    },
-#endif
-    /* FIXME: make this work on big endian */
-    {
-	.format = PIXMAN_yv12,
-	.width = 8, .height = 2,
-	.stride = 8,
-#ifdef WORDS_BIGENDIAN
-	.src =
-	{
-	    0x00ff00ff, 0x00ff00ff,
-	    0xff00ff00, 0xff00ff00,
-	    0x80ff8000,
-	    0x800080ff
-	},
-#else
-	.src =
-	{
-	    0xff00ff00, 0xff00ff00,
-	    0x00ff00ff, 0x00ff00ff,
-	    0x0080ff80,
-	    0xff800080
-	},
-#endif
-	.dst =
-	{
-	    0xff000000, 0xffffffff, 0xffb80000, 0xffffe113,
-	    0xff000000, 0xffffffff, 0xff0023ee, 0xff4affff,
-	    0xffffffff, 0xff000000, 0xffffe113, 0xffb80000,
-	    0xffffffff, 0xff000000, 0xff4affff, 0xff0023ee,
-	},
-    },
-};
-
-int n_test_cases = sizeof(testcases)/sizeof(testcases[0]);
-
-
-static uint32_t
-reader (const void *src, int size)
-{
-    switch (size)
-    {
-    case 1:
-	return *(uint8_t *)src;
-    case 2:
-	return *(uint16_t *)src;
-    case 4:
-	return *(uint32_t *)src;
-    default:
-	assert(0);
-    }
-}
-
-
-static void
-writer (void *src, uint32_t value, int size)
-{
-    switch (size)
-    {
-    case 1:
-	*(uint8_t *)src = value;
-	break;
-    case 2:
-	*(uint16_t *)src = value;
-	break;
-    case 4:
-	*(uint32_t *)src = value;
-	break;
-    default:
-	assert(0);
-    }
-}
-
-
-int
-main (int argc, char **argv)
-{
-    uint32_t dst[SIZE];
-    pixman_image_t *src_img;
-    pixman_image_t *dst_img;
-    int i, j, x, y;
-    int ret = 0;
-
-    for (i = 0; i < n_test_cases; ++i)
-    {
-	for (j = 0; j < 2; ++j)
-	{
-	    src_img = pixman_image_create_bits (testcases[i].format,
-						testcases[i].width,
-						testcases[i].height,
-						testcases[i].src,
-						testcases[i].stride);
-	    pixman_image_set_indexed(src_img, testcases[i].indexed);
-
-	    dst_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,
-						testcases[i].width,
-						testcases[i].height,
-						dst,
-						testcases[i].width*4);
-
-	    if (j)
-	    {
-		pixman_image_set_accessors (src_img, reader, writer);
-		pixman_image_set_accessors (dst_img, reader, writer);
-	    }
-
-	    pixman_image_composite (PIXMAN_OP_SRC, src_img, NULL, dst_img,
-				    0, 0, 0, 0, 0, 0, testcases[i].width, testcases[i].height);
-
-	    pixman_image_unref (src_img);
-	    pixman_image_unref (dst_img);
-
-	    for (y = 0; y < testcases[i].height; ++y)
-	    {
-		for (x = 0; x < testcases[i].width; ++x)
-		{
-		    int offset = y * testcases[i].width + x;
-
-		    if (dst[offset] != testcases[i].dst[offset])
-		    {
-			printf ("test %i%c: pixel mismatch at (x=%d,y=%d): %08x expected, %08x obtained\n",
-			        i + 1, 'a' + j,
-			        x, y,
-			        testcases[i].dst[offset], dst[offset]);
-			ret = 1;
-		    }
-		}
-	    }
-	}
-    }
-
-    return ret;
-}
+#include <assert.h>

+#include <stdlib.h>

+#include <stdio.h>

+#include "pixman.h"

+#include <config.h>

+

+#define SIZE 1024

+

+static pixman_indexed_t mono_palette =

+{

+    0, { 0x00000000, 0x00ffffff },

+};

+

+

+typedef struct {

+    pixman_format_code_t format;

+    int width, height;

+    int stride;

+    uint32_t src[SIZE];

+    uint32_t dst[SIZE];

+    pixman_indexed_t *indexed;

+} testcase_t;

+

+static testcase_t testcases[] =

+{

+    {

+	PIXMAN_a8r8g8b8,

+	2, 2,

+	8,

+	{ 0x00112233, 0x44556677,

+	  0x8899aabb, 0xccddeeff },

+	{ 0x00112233, 0x44556677,

+	  0x8899aabb, 0xccddeeff },

+	NULL,

+    },

+    {

+	PIXMAN_g1,

+	8, 2,

+	4,

+#ifdef WORDS_BIGENDIAN

+	{

+	    0xaa000000,

+	    0x55000000

+	},

+#else

+	{

+	    0x00000055,

+	    0x000000aa

+	},

+#endif

+	{

+	    0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000,

+	    0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff

+	},

+	&mono_palette,

+    },

+#if 0

+    {

+	PIXMAN_g8,

+	4, 2,

+	4,

+	{ 0x01234567,

+	  0x89abcdef },

+	{ 0x00010101, 0x00232323, 0x00454545, 0x00676767,

+	  0x00898989, 0x00ababab, 0x00cdcdcd, 0x00efefef, },

+    },

+#endif

+    /* FIXME: make this work on big endian */

+    {

+	PIXMAN_yv12,

+	8, 2,

+	8,

+#ifdef WORDS_BIGENDIAN

+	{

+	    0x00ff00ff, 0x00ff00ff,

+	    0xff00ff00, 0xff00ff00,

+	    0x80ff8000,

+	    0x800080ff

+	},

+#else

+	{

+	    0xff00ff00, 0xff00ff00,

+	    0x00ff00ff, 0x00ff00ff,

+	    0x0080ff80,

+	    0xff800080

+	},

+#endif

+	{

+	    0xff000000, 0xffffffff, 0xffb80000, 0xffffe113,

+	    0xff000000, 0xffffffff, 0xff0023ee, 0xff4affff,

+	    0xffffffff, 0xff000000, 0xffffe113, 0xffb80000,

+	    0xffffffff, 0xff000000, 0xff4affff, 0xff0023ee,

+	},

+    },

+};

+

+int n_test_cases = sizeof(testcases)/sizeof(testcases[0]);

+

+

+static uint32_t

+reader (const void *src, int size)

+{

+    switch (size)

+    {

+    case 1:

+	return *(uint8_t *)src;

+    case 2:

+	return *(uint16_t *)src;

+    case 4:

+	return *(uint32_t *)src;

+    default:

+	assert(0);

+	return 0; /* silence MSVC */

+    }

+}

+

+

+static void

+writer (void *src, uint32_t value, int size)

+{

+    switch (size)

+    {

+    case 1:

+	*(uint8_t *)src = value;

+	break;

+    case 2:

+	*(uint16_t *)src = value;

+	break;

+    case 4:

+	*(uint32_t *)src = value;

+	break;

+    default:

+	assert(0);

+    }

+}

+

+

+int

+main (int argc, char **argv)

+{

+    uint32_t dst[SIZE];

+    pixman_image_t *src_img;

+    pixman_image_t *dst_img;

+    int i, j, x, y;

+    int ret = 0;

+

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

+    {

+	for (j = 0; j < 2; ++j)

+	{

+	    src_img = pixman_image_create_bits (testcases[i].format,

+						testcases[i].width,

+						testcases[i].height,

+						testcases[i].src,

+						testcases[i].stride);

+	    pixman_image_set_indexed(src_img, testcases[i].indexed);

+

+	    dst_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,

+						testcases[i].width,

+						testcases[i].height,

+						dst,

+						testcases[i].width*4);

+

+	    if (j)

+	    {

+		pixman_image_set_accessors (src_img, reader, writer);

+		pixman_image_set_accessors (dst_img, reader, writer);

+	    }

+

+	    pixman_image_composite (PIXMAN_OP_SRC, src_img, NULL, dst_img,

+				    0, 0, 0, 0, 0, 0, testcases[i].width, testcases[i].height);

+

+	    pixman_image_unref (src_img);

+	    pixman_image_unref (dst_img);

+

+	    for (y = 0; y < testcases[i].height; ++y)

+	    {

+		for (x = 0; x < testcases[i].width; ++x)

+		{

+		    int offset = y * testcases[i].width + x;

+

+		    if (dst[offset] != testcases[i].dst[offset])

+		    {

+			printf ("test %i%c: pixel mismatch at (x=%d,y=%d): %08x expected, %08x obtained\n",

+			        i + 1, 'a' + j,

+			        x, y,

+			        testcases[i].dst[offset], dst[offset]);

+			ret = 1;

+		    }

+		}

+	    }

+	}

+    }

+

+    return ret;

+}

diff --git a/pixman/test/scaling-helpers-test.c b/pixman/test/scaling-helpers-test.c
new file mode 100644
index 000000000..c1861389b
--- /dev/null
+++ b/pixman/test/scaling-helpers-test.c
@@ -0,0 +1,93 @@
+#include <config.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include "utils.h"
+#include "pixman-fast-path.h"
+
+/* A trivial reference implementation for
+ * 'bilinear_pad_repeat_get_scanline_bounds'
+ */
+static void
+bilinear_pad_repeat_get_scanline_bounds_ref (int32_t        source_image_width,
+					     pixman_fixed_t vx_,
+					     pixman_fixed_t unit_x,
+					     int32_t *      left_pad,
+					     int32_t *      left_tz,
+					     int32_t *      width,
+					     int32_t *      right_tz,
+					     int32_t *      right_pad)
+{
+    int w = *width;
+    *left_pad = 0;
+    *left_tz = 0;
+    *width = 0;
+    *right_tz = 0;
+    *right_pad = 0;
+    int64_t vx = vx_;
+    while (--w >= 0)
+    {
+	if (vx < 0)
+	{
+	    if (vx + pixman_fixed_1 < 0)
+		*left_pad += 1;
+	    else
+		*left_tz += 1;
+	}
+	else if (vx + pixman_fixed_1 >= pixman_int_to_fixed (source_image_width))
+	{
+	    if (vx >= pixman_int_to_fixed (source_image_width))
+		*right_pad += 1;
+	    else
+		*right_tz += 1;
+	}
+	else
+	{
+	    *width += 1;
+	}
+	vx += unit_x;
+    }
+}
+
+int
+main (void)
+{
+    int i;
+    for (i = 0; i < 10000; i++)
+    {
+	int32_t left_pad1, left_tz1, width1, right_tz1, right_pad1;
+	int32_t left_pad2, left_tz2, width2, right_tz2, right_pad2;
+	pixman_fixed_t vx = lcg_rand_N(10000 << 16) - (3000 << 16);
+	int32_t width = lcg_rand_N(10000);
+	int32_t source_image_width = lcg_rand_N(10000) + 1;
+	pixman_fixed_t unit_x = lcg_rand_N(10 << 16) + 1;
+	width1 = width2 = width;
+
+	bilinear_pad_repeat_get_scanline_bounds_ref (source_image_width,
+						     vx,
+						     unit_x,
+						     &left_pad1,
+						     &left_tz1,
+						     &width1,
+						     &right_tz1,
+						     &right_pad1);
+
+	bilinear_pad_repeat_get_scanline_bounds (source_image_width,
+						 vx,
+						 unit_x,
+						 &left_pad2,
+						 &left_tz2,
+						 &width2,
+						 &right_tz2,
+						 &right_pad2);
+
+	assert (left_pad1 == left_pad2);
+	assert (left_tz1 == left_tz2);
+	assert (width1 == width2);
+	assert (right_tz1 == right_tz2);
+	assert (right_pad1 == right_pad2);
+    }
+
+    return 0;
+}
diff --git a/pixman/test/stress-test.c b/pixman/test/stress-test.c
index 0a89a52e9..a51737ea0 100644
--- a/pixman/test/stress-test.c
+++ b/pixman/test/stress-test.c
@@ -128,7 +128,7 @@ real_reader (const void *src, int size)
 	return *(uint32_t *)src;

     default:

 	assert (0);

-	break;

+	return 0; /* silence MSVC */

     }

 }

 

diff --git a/pixman/test/trap-crasher.c b/pixman/test/trap-crasher.c
index 42b82f674..96f3b0bab 100644
--- a/pixman/test/trap-crasher.c
+++ b/pixman/test/trap-crasher.c
@@ -1,27 +1,27 @@
-#include <stdlib.h>
-#include <pixman.h>
-
-int
-main()
-{
-    pixman_image_t *dst;
-    pixman_trapezoid_t traps[1] = {
-	{
-	    .top = 2147483646,
-	    .bottom = 2147483647,
-	    .left = {
-		.p1 = { .x = 0, .y = 0 },
-		.p2 = { .x = 0, .y = 2147483647 }
-	    },
-	    .right = {
-		.p1 = { .x = 65536, .y = 0 },
-		.p2 = { .x = 0, .y = 2147483647 }
-	    }
-	},
-    };
-    
-    dst = pixman_image_create_bits (PIXMAN_a8, 1, 1, NULL, -1);
-    
-    pixman_add_trapezoids (dst, 0, 0, sizeof (traps)/sizeof (traps[0]), traps);
-    return (0);
-}
+#include <stdlib.h>

+#include <pixman.h>

+

+int

+main()

+{

+    pixman_image_t *dst;

+    pixman_trapezoid_t traps[1] = {

+	{

+	    2147483646,

+	    2147483647,

+	    {

+		{ 0, 0 },

+		{ 0, 2147483647 }

+	    },

+	    {

+		{ 65536, 0 },

+		{ 0, 2147483647 }

+	    }

+	},

+    };

+

+    dst = pixman_image_create_bits (PIXMAN_a8, 1, 1, NULL, -1);

+

+    pixman_add_trapezoids (dst, 0, 0, sizeof (traps)/sizeof (traps[0]), traps);

+    return (0);

+}