projects / platform / upstream / pixman.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 6aceb76)
Replace instances of "dst_*" with "dest_*"
authorSøren Sandmann Pedersen <ssp@redhat.com>
Fri, 25 Mar 2011 18:17:08 +0000 (14:17 -0400)
committerSøren Sandmann Pedersen <ssp@redhat.com>
Sun, 12 Jun 2011 20:45:57 +0000 (16:45 -0400)
The variables in question were dst_x, dst_y, dst_image. The majority
of _x and _y uses were already dest_x and dest_y, while the majority
of _image uses were dst_image.

pixman/pixman-arm-common.h patch | blob | history
pixman/pixman-arm-neon.c patch | blob | history
pixman/pixman-fast-path.c patch | blob | history
pixman/pixman-fast-path.h patch | blob | history
pixman/pixman-general.c patch | blob | history
pixman/pixman-implementation.c patch | blob | history
pixman/pixman-mmx.c patch | blob | history
pixman/pixman-private.h patch | blob | history
pixman/pixman-sse2.c patch | blob | history
pixman/pixman.c patch | blob | history
pixman/pixman.h patch | blob | history

diff --git a/pixman/pixman-arm-common.h b/pixman/pixman-arm-common.h
index 6cd8be5..4bf84e0 100644 (file)
--- a/pixman/pixman-arm-common.h
+++ b/pixman/pixman-arm-common.h
@@ -66,7 +66,7 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
                             pixman_op_t              op,                \
                             pixman_image_t *         src_image,         \
                             pixman_image_t *         mask_image,        \
-                            pixman_image_t *         dst_image,         \
+                            pixman_image_t *         dest_image,        \
                             int32_t                  src_x,             \
                             int32_t                  src_y,             \
                             int32_t                  mask_x,            \
@@ -82,7 +82,7 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
                                                                         \
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, src_type,           \
                            src_stride, src_line, src_cnt);              \
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, dst_type,         \
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type,        \
                            dst_stride, dst_line, dst_cnt);              \
                                                                         \
     pixman_composite_##name##_asm_##cputype (width, height,             \
@@ -104,7 +104,7 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
                             pixman_op_t              op,                \
                             pixman_image_t *         src_image,         \
                             pixman_image_t *         mask_image,        \
-                            pixman_image_t *         dst_image,         \
+                            pixman_image_t *         dest_image,        \
                             int32_t                  src_x,             \
                             int32_t                  src_y,             \
                             int32_t                  mask_x,            \
@@ -119,12 +119,12 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
     uint32_t   src;                                                     \
                                                                         \
     src = _pixman_image_get_solid (                                    \
-       imp, src_image, dst_image->bits.format);                        \
+       imp, src_image, dest_image->bits.format);                       \
                                                                         \
     if ((flags & SKIP_ZERO_SRC) && src == 0)                            \
        return;                                                         \
                                                                         \
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, dst_type,         \
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type,        \
                            dst_stride, dst_line, dst_cnt);              \
                                                                         \
     pixman_composite_##name##_asm_##cputype (width, height,             \
@@ -150,7 +150,7 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
                             pixman_op_t              op,                \
                             pixman_image_t *         src_image,         \
                             pixman_image_t *         mask_image,        \
-                            pixman_image_t *         dst_image,         \
+                            pixman_image_t *         dest_image,        \
                             int32_t                  src_x,             \
                             int32_t                  src_y,             \
                             int32_t                  mask_x,            \
@@ -166,12 +166,12 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
     uint32_t   src;                                                     \
                                                                         \
     src = _pixman_image_get_solid (                                    \
-       imp, src_image, dst_image->bits.format);                        \
+       imp, src_image, dest_image->bits.format);                       \
                                                                         \
     if ((flags & SKIP_ZERO_SRC) && src == 0)                            \
        return;                                                         \
                                                                         \
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, dst_type,         \
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type,        \
                            dst_stride, dst_line, dst_cnt);              \
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, mask_type,       \
                            mask_stride, mask_line, mask_cnt);           \
@@ -199,7 +199,7 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
                             pixman_op_t              op,                \
                             pixman_image_t *         src_image,         \
                             pixman_image_t *         mask_image,        \
-                            pixman_image_t *         dst_image,         \
+                            pixman_image_t *         dest_image,        \
                             int32_t                  src_x,             \
                             int32_t                  src_y,             \
                             int32_t                  mask_x,            \
@@ -215,12 +215,12 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
     uint32_t   mask;                                                    \
                                                                         \
     mask = _pixman_image_get_solid (                                   \
-       imp, mask_image, dst_image->bits.format);                       \
+       imp, mask_image, dest_image->bits.format);                      \
                                                                         \
     if ((flags & SKIP_ZERO_MASK) && mask == 0)                          \
        return;                                                         \
                                                                         \
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, dst_type,         \
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type,        \
                            dst_stride, dst_line, dst_cnt);              \
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, src_type,           \
                            src_stride, src_line, src_cnt);              \
@@ -250,7 +250,7 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
                             pixman_op_t              op,                \
                             pixman_image_t *         src_image,         \
                             pixman_image_t *         mask_image,        \
-                            pixman_image_t *         dst_image,         \
+                            pixman_image_t *         dest_image,        \
                             int32_t                  src_x,             \
                             int32_t                  src_y,             \
                             int32_t                  mask_x,            \
@@ -265,7 +265,7 @@ cputype##_composite_##name (pixman_implementation_t *imp,               \
     mask_type *mask_line;                                               \
     int32_t    dst_stride, src_stride, mask_stride;                     \
                                                                         \
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, dst_type,         \
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type,        \
                            dst_stride, dst_line, dst_cnt);              \
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, src_type,           \
                            src_stride, src_line, src_cnt);              \
diff --git a/pixman/pixman-arm-neon.c b/pixman/pixman-arm-neon.c
index e5127a6..1e01d13 100644 (file)
--- a/pixman/pixman-arm-neon.c
+++ b/pixman/pixman-arm-neon.c
@@ -229,8 +229,8 @@ pixman_blt_neon (uint32_t *src_bits,
                  int       dst_bpp,
                  int       src_x,
                  int       src_y,
-                 int       dst_x,
-                 int       dst_y,
+                 int       dest_x,
+                 int       dest_y,
                  int       width,
                  int       height)
 {
@@ -243,7 +243,7 @@ pixman_blt_neon (uint32_t *src_bits,
        pixman_composite_src_0565_0565_asm_neon (
                width, height,
                (uint16_t *)(((char *) dst_bits) +
-               dst_y * dst_stride * 4 + dst_x * 2), dst_stride * 2,
+               dest_y * dst_stride * 4 + dest_x * 2), dst_stride * 2,
                (uint16_t *)(((char *) src_bits) +
                src_y * src_stride * 4 + src_x * 2), src_stride * 2);
        return TRUE;
@@ -251,7 +251,7 @@ pixman_blt_neon (uint32_t *src_bits,
        pixman_composite_src_8888_8888_asm_neon (
                width, height,
                (uint32_t *)(((char *) dst_bits) +
-               dst_y * dst_stride * 4 + dst_x * 4), dst_stride,
+               dest_y * dst_stride * 4 + dest_x * 4), dst_stride,
                (uint32_t *)(((char *) src_bits) +
                src_y * src_stride * 4 + src_x * 4), src_stride);
        return TRUE;
@@ -418,20 +418,20 @@ arm_neon_blt (pixman_implementation_t *imp,
               int                      dst_bpp,
               int                      src_x,
               int                      src_y,
-              int                      dst_x,
-              int                      dst_y,
+              int                      dest_x,
+              int                      dest_y,
               int                      width,
               int                      height)
 {
     if (!pixman_blt_neon (
             src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
-            src_x, src_y, dst_x, dst_y, width, height))
+            src_x, src_y, dest_x, dest_y, width, height))
 
     {
        return _pixman_implementation_blt (
            imp->delegate,
            src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
-           src_x, src_y, dst_x, dst_y, width, height);
+           src_x, src_y, dest_x, dest_y, width, height);
     }
 
     return TRUE;
diff --git a/pixman/pixman-fast-path.c b/pixman/pixman-fast-path.c
index 92f0308..21998f1 100644 (file)
--- a/pixman/pixman-fast-path.c
+++ b/pixman/pixman-fast-path.c
@@ -111,7 +111,7 @@ fast_composite_over_x888_8_8888 (pixman_implementation_t *imp,
                                  pixman_op_t              op,
                                  pixman_image_t *         src_image,
                                  pixman_image_t *         mask_image,
-                                 pixman_image_t *         dst_image,
+                                 pixman_image_t *         dest_image,
                                  int32_t                  src_x,
                                  int32_t                  src_y,
                                  int32_t                  mask_x,
@@ -129,7 +129,7 @@ fast_composite_over_x888_8_8888 (pixman_implementation_t *imp,
     uint32_t s, d;
     int32_t w;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
@@ -296,7 +296,7 @@ fast_composite_over_n_8_8888 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -312,13 +312,13 @@ fast_composite_over_n_8_8888 (pixman_implementation_t *imp,
     int dst_stride, mask_stride;
     int32_t w;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
     while (height--)
@@ -354,7 +354,7 @@ fast_composite_add_n_8888_8888_ca (pixman_implementation_t *imp,
                                   pixman_op_t              op,
                                   pixman_image_t *         src_image,
                                   pixman_image_t *         mask_image,
-                                  pixman_image_t *         dst_image,
+                                  pixman_image_t *         dest_image,
                                   int32_t                  src_x,
                                   int32_t                  src_y,
                                   int32_t                  mask_x,
@@ -370,12 +370,12 @@ fast_composite_add_n_8888_8888_ca (pixman_implementation_t *imp,
     int dst_stride, mask_stride;
     int32_t w;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
 
     while (height--)
@@ -410,7 +410,7 @@ fast_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
                                     pixman_op_t              op,
                                     pixman_image_t *         src_image,
                                     pixman_image_t *         mask_image,
-                                    pixman_image_t *         dst_image,
+                                    pixman_image_t *         dest_image,
                                     int32_t                  src_x,
                                     int32_t                  src_y,
                                     int32_t                  mask_x,
@@ -426,13 +426,13 @@ fast_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
     int dst_stride, mask_stride;
     int32_t w;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
 
     while (height--)
@@ -476,7 +476,7 @@ fast_composite_over_n_8_0888 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -493,13 +493,13 @@ fast_composite_over_n_8_0888 (pixman_implementation_t *imp,
     int dst_stride, mask_stride;
     int32_t w;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
     while (height--)
@@ -541,7 +541,7 @@ fast_composite_over_n_8_0565 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -558,13 +558,13 @@ fast_composite_over_n_8_0565 (pixman_implementation_t *imp,
     int dst_stride, mask_stride;
     int32_t w;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
     while (height--)
@@ -607,7 +607,7 @@ fast_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
                                     pixman_op_t              op,
                                     pixman_image_t *         src_image,
                                     pixman_image_t *         mask_image,
-                                    pixman_image_t *         dst_image,
+                                    pixman_image_t *         dest_image,
                                     int32_t                  src_x,
                                     int32_t                  src_y,
                                     int32_t                  mask_x,
@@ -625,7 +625,7 @@ fast_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
     int dst_stride, mask_stride;
     int32_t w;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
@@ -633,7 +633,7 @@ fast_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
 
     src16 = CONVERT_8888_TO_0565 (src);
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
 
     while (height--)
@@ -684,7 +684,7 @@ fast_composite_over_8888_8888 (pixman_implementation_t *imp,
                                pixman_op_t              op,
                                pixman_image_t *         src_image,
                                pixman_image_t *         mask_image,
-                               pixman_image_t *         dst_image,
+                               pixman_image_t *         dest_image,
                                int32_t                  src_x,
                                int32_t                  src_y,
                                int32_t                  mask_x,
@@ -700,7 +700,7 @@ fast_composite_over_8888_8888 (pixman_implementation_t *imp,
     uint8_t a;
     int32_t w;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
     while (height--)
@@ -729,7 +729,7 @@ fast_composite_src_x888_8888 (pixman_implementation_t *imp,
                              pixman_op_t              op,
                              pixman_image_t *         src_image,
                              pixman_image_t *         mask_image,
-                             pixman_image_t *         dst_image,
+                             pixman_image_t *         dest_image,
                              int32_t                  src_x,
                              int32_t                  src_y,
                              int32_t                  mask_x,
@@ -744,7 +744,7 @@ fast_composite_src_x888_8888 (pixman_implementation_t *imp,
     int dst_stride, src_stride;
     int32_t w;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
     while (height--)
@@ -766,7 +766,7 @@ fast_composite_over_8888_0888 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -783,7 +783,7 @@ fast_composite_over_8888_0888 (pixman_implementation_t *imp,
     int dst_stride, src_stride;
     int32_t w;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 3);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
     while (height--)
@@ -818,7 +818,7 @@ fast_composite_over_8888_0565 (pixman_implementation_t *imp,
                                pixman_op_t              op,
                                pixman_image_t *         src_image,
                                pixman_image_t *         mask_image,
-                               pixman_image_t *         dst_image,
+                               pixman_image_t *         dest_image,
                                int32_t                  src_x,
                                int32_t                  src_y,
                                int32_t                  mask_x,
@@ -836,7 +836,7 @@ fast_composite_over_8888_0565 (pixman_implementation_t *imp,
     int32_t w;
 
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
 
     while (height--)
     {
@@ -873,7 +873,7 @@ fast_composite_src_x888_0565 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -889,7 +889,7 @@ fast_composite_src_x888_0565 (pixman_implementation_t *imp,
     int32_t w;
 
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
 
     while (height--)
     {
@@ -913,7 +913,7 @@ fast_composite_add_8_8 (pixman_implementation_t *imp,
                        pixman_op_t              op,
                        pixman_image_t *         src_image,
                        pixman_image_t *         mask_image,
-                       pixman_image_t *         dst_image,
+                       pixman_image_t *         dest_image,
                        int32_t                  src_x,
                        int32_t                  src_y,
                        int32_t                  mask_x,
@@ -931,7 +931,7 @@ fast_composite_add_8_8 (pixman_implementation_t *imp,
     uint16_t t;
 
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
 
     while (height--)
     {
@@ -964,7 +964,7 @@ fast_composite_add_8888_8888 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -981,7 +981,7 @@ fast_composite_add_8888_8888 (pixman_implementation_t *imp,
     uint32_t s, d;
 
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
 
     while (height--)
     {
@@ -1014,7 +1014,7 @@ fast_composite_add_n_8_8 (pixman_implementation_t *imp,
                          pixman_op_t              op,
                          pixman_image_t *         src_image,
                          pixman_image_t *         mask_image,
-                         pixman_image_t *         dst_image,
+                         pixman_image_t *         dest_image,
                          int32_t                  src_x,
                          int32_t                  src_y,
                          int32_t                  mask_x,
@@ -1031,9 +1031,9 @@ fast_composite_add_n_8_8 (pixman_implementation_t *imp,
     uint32_t src;
     uint8_t sa;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     sa = (src >> 24);
 
     while (height--)
@@ -1080,7 +1080,7 @@ fast_composite_add_1000_1000 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -1097,7 +1097,7 @@ fast_composite_add_1000_1000 (pixman_implementation_t *imp,
 
     PIXMAN_IMAGE_GET_LINE (src_image, 0, src_y, uint32_t,
                            src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, 0, dest_y, uint32_t,
+    PIXMAN_IMAGE_GET_LINE (dest_image, 0, dest_y, uint32_t,
                            dst_stride, dst_line, 1);
 
     while (height--)
@@ -1125,7 +1125,7 @@ fast_composite_over_n_1_8888 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -1145,12 +1145,12 @@ fast_composite_over_n_1_8888 (pixman_implementation_t *imp,
     if (width <= 0)
        return;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     srca = src >> 24;
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t,
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t,
                            dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,
                            mask_stride, mask_line, 1);
@@ -1217,7 +1217,7 @@ fast_composite_over_n_1_0565 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -1239,12 +1239,12 @@ fast_composite_over_n_1_0565 (pixman_implementation_t *imp,
     if (width <= 0)
        return;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
     srca = src >> 24;
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t,
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t,
                            dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, 0, mask_y, uint32_t,
                            mask_stride, mask_line, 1);
@@ -1319,7 +1319,7 @@ fast_composite_solid_fill (pixman_implementation_t *imp,
                            pixman_op_t              op,
                            pixman_image_t *         src_image,
                            pixman_image_t *         mask_image,
-                           pixman_image_t *         dst_image,
+                           pixman_image_t *         dest_image,
                            int32_t                  src_x,
                            int32_t                  src_y,
                            int32_t                  mask_x,
@@ -1331,24 +1331,24 @@ fast_composite_solid_fill (pixman_implementation_t *imp,
 {
     uint32_t src;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
-    if (dst_image->bits.format == PIXMAN_a1)
+    if (dest_image->bits.format == PIXMAN_a1)
     {
        src = src >> 31;
     }
-    else if (dst_image->bits.format == PIXMAN_a8)
+    else if (dest_image->bits.format == PIXMAN_a8)
     {
        src = src >> 24;
     }
-    else if (dst_image->bits.format == PIXMAN_r5g6b5 ||
-             dst_image->bits.format == PIXMAN_b5g6r5)
+    else if (dest_image->bits.format == PIXMAN_r5g6b5 ||
+             dest_image->bits.format == PIXMAN_b5g6r5)
     {
        src = CONVERT_8888_TO_0565 (src);
     }
 
-    pixman_fill (dst_image->bits.bits, dst_image->bits.rowstride,
-                 PIXMAN_FORMAT_BPP (dst_image->bits.format),
+    pixman_fill (dest_image->bits.bits, dest_image->bits.rowstride,
+                 PIXMAN_FORMAT_BPP (dest_image->bits.format),
                  dest_x, dest_y,
                  width, height,
                  src);
@@ -1359,7 +1359,7 @@ fast_composite_src_memcpy (pixman_implementation_t *imp,
                           pixman_op_t              op,
                           pixman_image_t *         src_image,
                           pixman_image_t *         mask_image,
-                          pixman_image_t *         dst_image,
+                          pixman_image_t *         dest_image,
                           int32_t                  src_x,
                           int32_t                  src_y,
                           int32_t                  mask_x,
@@ -1369,17 +1369,17 @@ fast_composite_src_memcpy (pixman_implementation_t *imp,
                           int32_t                  width,
                           int32_t                  height)
 {
-    int bpp = PIXMAN_FORMAT_BPP (dst_image->bits.format) / 8;
+    int bpp = PIXMAN_FORMAT_BPP (dest_image->bits.format) / 8;
     uint32_t n_bytes = width * bpp;
     int dst_stride, src_stride;
     uint8_t    *dst;
     uint8_t    *src;
 
     src_stride = src_image->bits.rowstride * 4;
-    dst_stride = dst_image->bits.rowstride * 4;
+    dst_stride = dest_image->bits.rowstride * 4;
 
     src = (uint8_t *)src_image->bits.bits + src_y * src_stride + src_x * bpp;
-    dst = (uint8_t *)dst_image->bits.bits + dest_y * dst_stride + dest_x * bpp;
+    dst = (uint8_t *)dest_image->bits.bits + dest_y * dst_stride + dest_x * bpp;
 
     while (height--)
     {
@@ -1500,7 +1500,7 @@ fast_composite_scaled_nearest (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -1520,7 +1520,7 @@ fast_composite_scaled_nearest (pixman_implementation_t *imp,
     pixman_vector_t v;
     pixman_fixed_t vy;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_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
      */
@@ -1816,7 +1816,7 @@ fast_composite_rotate_90_##suffix (pixman_implementation_t *imp,              \
                                   pixman_op_t              op,               \
                                   pixman_image_t *         src_image,        \
                                   pixman_image_t *         mask_image,       \
-                                  pixman_image_t *         dst_image,        \
+                                  pixman_image_t *         dest_image,        \
                                   int32_t                  src_x,            \
                                   int32_t                  src_y,            \
                                   int32_t                  mask_x,           \
@@ -1831,7 +1831,7 @@ fast_composite_rotate_90_##suffix (pixman_implementation_t *imp,              \
     int             dst_stride, src_stride;                                   \
     int             src_x_t, src_y_t;                                         \
                                                                               \
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, pix_type,               \
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, pix_type,               \
                           dst_stride, dst_line, 1);                          \
     src_x_t = -src_y + pixman_fixed_to_int (                                  \
                                src_image->common.transform->matrix[0][2] +   \
@@ -1850,7 +1850,7 @@ fast_composite_rotate_270_##suffix (pixman_implementation_t *imp,             \
                                    pixman_op_t              op,              \
                                    pixman_image_t *         src_image,       \
                                    pixman_image_t *         mask_image,      \
-                                   pixman_image_t *         dst_image,       \
+                                   pixman_image_t *         dest_image,       \
                                    int32_t                  src_x,           \
                                    int32_t                  src_y,           \
                                    int32_t                  mask_x,          \
@@ -1865,7 +1865,7 @@ fast_composite_rotate_270_##suffix (pixman_implementation_t *imp,             \
     int             dst_stride, src_stride;                                   \
     int             src_x_t, src_y_t;                                         \
                                                                               \
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, pix_type,               \
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, pix_type,               \
                           dst_stride, dst_line, 1);                          \
     src_x_t = src_y + pixman_fixed_to_int (                                   \
                                src_image->common.transform->matrix[0][2] +   \
diff --git a/pixman/pixman-fast-path.h b/pixman/pixman-fast-path.h
index 1885d47..e75f18c 100644 (file)
--- a/pixman/pixman-fast-path.h
+++ b/pixman/pixman-fast-path.h
@@ -256,13 +256,13 @@ fast_composite_scaled_nearest  ## 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,          \
+                                                  pixman_image_t *         dest_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                  dest_x,             \
+                                                  int32_t                  dest_y,             \
                                                   int32_t                  width,              \
                                                   int32_t                  height)             \
 {                                                                                              \
@@ -283,11 +283,11 @@ fast_composite_scaled_nearest  ## scale_func_name (pixman_implementation_t *imp,
     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);      \
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_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);     \
+           solid_mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format);    \
        else                                                                                    \
            PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, mask_type_t,                     \
                                   mask_stride, mask_line, 1);                                  \
@@ -667,13 +667,13 @@ 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,          \
+                                                  pixman_image_t *         dest_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                  dest_x,             \
+                                                  int32_t                  dest_y,             \
                                                   int32_t                  width,              \
                                                   int32_t                  height)             \
 {                                                                                              \
@@ -692,12 +692,12 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
     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);      \
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_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);     \
+           solid_mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format);    \
            mask_stride = 0;                                                                    \
        }                                                                                       \
        else                                                                                    \
diff --git a/pixman/pixman-general.c b/pixman/pixman-general.c
index 727affc..8db4d05 100644 (file)
--- a/pixman/pixman-general.c
+++ b/pixman/pixman-general.c
@@ -233,8 +233,8 @@ general_blt (pixman_implementation_t *imp,
              int                      dst_bpp,
              int                      src_x,
              int                      src_y,
-             int                      dst_x,
-             int                      dst_y,
+             int                      dest_x,
+             int                      dest_y,
              int                      width,
              int                      height)
 {
diff --git a/pixman/pixman-implementation.c b/pixman/pixman-implementation.c
index 81c740b..2b7b19d 100644 (file)
--- a/pixman/pixman-implementation.c
+++ b/pixman/pixman-implementation.c
@@ -85,14 +85,14 @@ delegate_blt (pixman_implementation_t * imp,
               int                       dst_bpp,
               int                       src_x,
               int                       src_y,
-              int                       dst_x,
-              int                       dst_y,
+              int                       dest_x,
+              int                       dest_y,
               int                       width,
               int                       height)
 {
     return _pixman_implementation_blt (
        imp->delegate, src_bits, dst_bits, src_stride, dst_stride,
-       src_bpp, dst_bpp, src_x, src_y, dst_x, dst_y,
+       src_bpp, dst_bpp, src_x, src_y, dest_x, dest_y,
        width, height);
 }
 
@@ -217,13 +217,13 @@ _pixman_implementation_blt (pixman_implementation_t * imp,
                             int                       dst_bpp,
                             int                       src_x,
                             int                       src_y,
-                            int                       dst_x,
-                            int                       dst_y,
+                            int                       dest_x,
+                            int                       dest_y,
                             int                       width,
                             int                       height)
 {
     return (*imp->blt) (imp, src_bits, dst_bits, src_stride, dst_stride,
-                       src_bpp, dst_bpp, src_x, src_y, dst_x, dst_y,
+                       src_bpp, dst_bpp, src_x, src_y, dest_x, dest_y,
                        width, height);
 }
 
diff --git a/pixman/pixman-mmx.c b/pixman/pixman-mmx.c
index 62a73d6..d5dd92b 100644 (file)
--- a/pixman/pixman-mmx.c
+++ b/pixman/pixman-mmx.c
@@ -1090,7 +1090,7 @@ mmx_composite_over_n_8888 (pixman_implementation_t *imp,
                            pixman_op_t              op,
                            pixman_image_t *         src_image,
                            pixman_image_t *         mask_image,
-                           pixman_image_t *         dst_image,
+                           pixman_image_t *         dest_image,
                            int32_t                  src_x,
                            int32_t                  src_y,
                            int32_t                  mask_x,
@@ -1108,12 +1108,12 @@ mmx_composite_over_n_8888 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
 
     vsrc = load8888 (src);
     vsrca = expand_alpha (vsrc);
@@ -1169,7 +1169,7 @@ mmx_composite_over_n_0565 (pixman_implementation_t *imp,
                            pixman_op_t              op,
                            pixman_image_t *         src_image,
                            pixman_image_t *         mask_image,
-                           pixman_image_t *         dst_image,
+                           pixman_image_t *         dest_image,
                            int32_t                  src_x,
                            int32_t                  src_y,
                            int32_t                  mask_x,
@@ -1187,12 +1187,12 @@ mmx_composite_over_n_0565 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
 
     vsrc = load8888 (src);
     vsrca = expand_alpha (vsrc);
@@ -1257,7 +1257,7 @@ mmx_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
                                    pixman_op_t              op,
                                    pixman_image_t *         src_image,
                                    pixman_image_t *         mask_image,
-                                   pixman_image_t *         dst_image,
+                                   pixman_image_t *         dest_image,
                                    int32_t                  src_x,
                                    int32_t                  src_y,
                                    int32_t                  mask_x,
@@ -1275,12 +1275,12 @@ mmx_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
 
     vsrc = load8888 (src);
@@ -1360,7 +1360,7 @@ mmx_composite_over_8888_n_8888 (pixman_implementation_t *imp,
                                 pixman_op_t              op,
                                 pixman_image_t *         src_image,
                                 pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
+                                pixman_image_t *         dest_image,
                                 int32_t                  src_x,
                                 int32_t                  src_y,
                                 int32_t                  mask_x,
@@ -1379,10 +1379,10 @@ mmx_composite_over_8888_n_8888 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
-    mask = _pixman_image_get_solid (imp, mask_image, dst_image->bits.format);
+    mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format);
     mask &= 0xff000000;
     mask = mask | mask >> 8 | mask >> 16 | mask >> 24;
     vmask = load8888 (mask);
@@ -1444,7 +1444,7 @@ mmx_composite_over_x888_n_8888 (pixman_implementation_t *imp,
                                 pixman_op_t              op,
                                 pixman_image_t *         src_image,
                                 pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
+                                pixman_image_t *         dest_image,
                                 int32_t                  src_x,
                                 int32_t                  src_y,
                                 int32_t                  mask_x,
@@ -1464,9 +1464,9 @@ mmx_composite_over_x888_n_8888 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    mask = _pixman_image_get_solid (imp, mask_image, dst_image->bits.format);
+    mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format);
 
     mask &= 0xff000000;
     mask = mask | mask >> 8 | mask >> 16 | mask >> 24;
@@ -1580,7 +1580,7 @@ mmx_composite_over_8888_8888 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -1599,7 +1599,7 @@ mmx_composite_over_8888_8888 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
     while (height--)
@@ -1638,7 +1638,7 @@ mmx_composite_over_8888_0565 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -1655,7 +1655,7 @@ mmx_composite_over_8888_0565 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
 #if 0
@@ -1741,7 +1741,7 @@ mmx_composite_over_n_8_8888 (pixman_implementation_t *imp,
                              pixman_op_t              op,
                              pixman_image_t *         src_image,
                              pixman_image_t *         mask_image,
-                             pixman_image_t *         dst_image,
+                             pixman_image_t *         dest_image,
                              int32_t                  src_x,
                              int32_t                  src_y,
                              int32_t                  mask_x,
@@ -1761,7 +1761,7 @@ mmx_composite_over_n_8_8888 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
@@ -1769,7 +1769,7 @@ mmx_composite_over_n_8_8888 (pixman_implementation_t *imp,
 
     srcsrc = (uint64_t)src << 32 | src;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
     vsrc = load8888 (src);
@@ -2015,7 +2015,7 @@ mmx_composite_src_n_8_8888 (pixman_implementation_t *imp,
                             pixman_op_t              op,
                             pixman_image_t *         src_image,
                             pixman_image_t *         mask_image,
-                            pixman_image_t *         dst_image,
+                            pixman_image_t *         dest_image,
                             int32_t                  src_x,
                             int32_t                  src_y,
                             int32_t                  mask_x,
@@ -2035,20 +2035,20 @@ mmx_composite_src_n_8_8888 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
     {
-       pixman_fill_mmx (dst_image->bits.bits, dst_image->bits.rowstride,
-                        PIXMAN_FORMAT_BPP (dst_image->bits.format),
+       pixman_fill_mmx (dest_image->bits.bits, dest_image->bits.rowstride,
+                        PIXMAN_FORMAT_BPP (dest_image->bits.format),
                         dest_x, dest_y, width, height, 0);
        return;
     }
 
     srcsrc = (uint64_t)src << 32 | src;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
     vsrc = load8888 (src);
@@ -2146,7 +2146,7 @@ mmx_composite_over_n_8_0565 (pixman_implementation_t *imp,
                              pixman_op_t              op,
                              pixman_image_t *         src_image,
                              pixman_image_t *         mask_image,
-                             pixman_image_t *         dst_image,
+                             pixman_image_t *         dest_image,
                              int32_t                  src_x,
                              int32_t                  src_y,
                              int32_t                  mask_x,
@@ -2166,13 +2166,13 @@ mmx_composite_over_n_8_0565 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
     vsrc = load8888 (src);
@@ -2287,7 +2287,7 @@ mmx_composite_over_pixbuf_0565 (pixman_implementation_t *imp,
                                 pixman_op_t              op,
                                 pixman_image_t *         src_image,
                                 pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
+                                pixman_image_t *         dest_image,
                                 int32_t                  src_x,
                                 int32_t                  src_y,
                                 int32_t                  mask_x,
@@ -2304,7 +2304,7 @@ mmx_composite_over_pixbuf_0565 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
 #if 0
@@ -2407,7 +2407,7 @@ mmx_composite_over_pixbuf_8888 (pixman_implementation_t *imp,
                                 pixman_op_t              op,
                                 pixman_image_t *         src_image,
                                 pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
+                                pixman_image_t *         dest_image,
                                 int32_t                  src_x,
                                 int32_t                  src_y,
                                 int32_t                  mask_x,
@@ -2424,7 +2424,7 @@ mmx_composite_over_pixbuf_8888 (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
 #if 0
@@ -2507,7 +2507,7 @@ mmx_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
                                    pixman_op_t              op,
                                    pixman_image_t *         src_image,
                                    pixman_image_t *         mask_image,
-                                   pixman_image_t *         dst_image,
+                                   pixman_image_t *         dest_image,
                                    int32_t                  src_x,
                                    int32_t                  src_y,
                                    int32_t                  mask_x,
@@ -2525,12 +2525,12 @@ mmx_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
 
     CHECKPOINT ();
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
 
     vsrc = load8888 (src);
@@ -2614,7 +2614,7 @@ mmx_composite_in_n_8_8 (pixman_implementation_t *imp,
                         pixman_op_t              op,
                         pixman_image_t *         src_image,
                         pixman_image_t *         mask_image,
-                        pixman_image_t *         dst_image,
+                        pixman_image_t *         dest_image,
                         int32_t                  src_x,
                         int32_t                  src_y,
                         int32_t                  mask_x,
@@ -2632,10 +2632,10 @@ mmx_composite_in_n_8_8 (pixman_implementation_t *imp,
     uint8_t sa;
     __m64 vsrc, vsrca;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     sa = src >> 24;
 
@@ -2650,7 +2650,7 @@ mmx_composite_in_n_8_8 (pixman_implementation_t *imp,
        mask_line += mask_stride;
        w = width;
 
-       if ((((unsigned long)dst_image & 3) == 0) &&
+       if ((((unsigned long)dest_image & 3) == 0) &&
            (((unsigned long)src_image & 3) == 0))
        {
            while (w >= 4)
@@ -2693,7 +2693,7 @@ mmx_composite_in_8_8 (pixman_implementation_t *imp,
                       pixman_op_t              op,
                       pixman_image_t *         src_image,
                       pixman_image_t *         mask_image,
-                      pixman_image_t *         dst_image,
+                      pixman_image_t *         dest_image,
                       int32_t                  src_x,
                       int32_t                  src_y,
                       int32_t                  mask_x,
@@ -2708,7 +2708,7 @@ mmx_composite_in_8_8 (pixman_implementation_t *imp,
     int src_stride, dst_stride;
     int32_t w;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
 
     while (height--)
@@ -2719,7 +2719,7 @@ mmx_composite_in_8_8 (pixman_implementation_t *imp,
        src_line += src_stride;
        w = width;
 
-       if ((((unsigned long)dst_image & 3) == 0) &&
+       if ((((unsigned long)dest_image & 3) == 0) &&
            (((unsigned long)src_image & 3) == 0))
        {
            while (w >= 4)
@@ -2758,7 +2758,7 @@ mmx_composite_add_n_8_8 (pixman_implementation_t *imp,
                         pixman_op_t              op,
                         pixman_image_t *         src_image,
                         pixman_image_t *         mask_image,
-                        pixman_image_t *         dst_image,
+                        pixman_image_t *         dest_image,
                         int32_t                  src_x,
                         int32_t                  src_y,
                         int32_t                  mask_x,
@@ -2776,10 +2776,10 @@ mmx_composite_add_n_8_8 (pixman_implementation_t *imp,
     uint8_t sa;
     __m64 vsrc, vsrca;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     sa = src >> 24;
 
@@ -2798,7 +2798,7 @@ mmx_composite_add_n_8_8 (pixman_implementation_t *imp,
        w = width;
 
        if ((((unsigned long)mask_image & 3) == 0) &&
-           (((unsigned long)dst_image  & 3) == 0))
+           (((unsigned long)dest_image  & 3) == 0))
        {
            while (w >= 4)
            {
@@ -2838,7 +2838,7 @@ mmx_composite_add_8_8 (pixman_implementation_t *imp,
                       pixman_op_t              op,
                       pixman_image_t *         src_image,
                       pixman_image_t *         mask_image,
-                      pixman_image_t *         dst_image,
+                      pixman_image_t *         dest_image,
                       int32_t                  src_x,
                       int32_t                  src_y,
                       int32_t                  mask_x,
@@ -2858,7 +2858,7 @@ mmx_composite_add_8_8 (pixman_implementation_t *imp,
     CHECKPOINT ();
 
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
 
     while (height--)
     {
@@ -2911,7 +2911,7 @@ mmx_composite_add_8888_8888 (pixman_implementation_t *imp,
                              pixman_op_t              op,
                              pixman_image_t *         src_image,
                              pixman_image_t *         mask_image,
-                             pixman_image_t *         dst_image,
+                             pixman_image_t *         dest_image,
                              int32_t                  src_x,
                              int32_t                  src_y,
                              int32_t                  mask_x,
@@ -2930,7 +2930,7 @@ mmx_composite_add_8888_8888 (pixman_implementation_t *imp,
     CHECKPOINT ();
 
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
 
     while (height--)
     {
@@ -2978,8 +2978,8 @@ pixman_blt_mmx (uint32_t *src_bits,
                 int       dst_bpp,
                 int       src_x,
                 int       src_y,
-                int       dst_x,
-                int       dst_y,
+                int       dest_x,
+                int       dest_y,
                 int       width,
                 int       height)
 {
@@ -2995,7 +2995,7 @@ pixman_blt_mmx (uint32_t *src_bits,
        src_stride = src_stride * (int) sizeof (uint32_t) / 2;
        dst_stride = dst_stride * (int) sizeof (uint32_t) / 2;
        src_bytes = (uint8_t *)(((uint16_t *)src_bits) + src_stride * (src_y) + (src_x));
-       dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+       dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dest_y) + (dest_x));
        byte_width = 2 * width;
        src_stride *= 2;
        dst_stride *= 2;
@@ -3005,7 +3005,7 @@ pixman_blt_mmx (uint32_t *src_bits,
        src_stride = src_stride * (int) sizeof (uint32_t) / 4;
        dst_stride = dst_stride * (int) sizeof (uint32_t) / 4;
        src_bytes = (uint8_t *)(((uint32_t *)src_bits) + src_stride * (src_y) + (src_x));
-       dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+       dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dest_y) + (dest_x));
        byte_width = 4 * width;
        src_stride *= 4;
        dst_stride *= 4;
@@ -3117,7 +3117,7 @@ mmx_composite_copy_area (pixman_implementation_t *imp,
                          pixman_op_t              op,
                          pixman_image_t *         src_image,
                          pixman_image_t *         mask_image,
-                         pixman_image_t *         dst_image,
+                         pixman_image_t *         dest_image,
                          int32_t                  src_x,
                          int32_t                  src_y,
                          int32_t                  mask_x,
@@ -3128,11 +3128,11 @@ mmx_composite_copy_area (pixman_implementation_t *imp,
                          int32_t                  height)
 {
     pixman_blt_mmx (src_image->bits.bits,
-                    dst_image->bits.bits,
+                    dest_image->bits.bits,
                     src_image->bits.rowstride,
-                    dst_image->bits.rowstride,
+                    dest_image->bits.rowstride,
                     PIXMAN_FORMAT_BPP (src_image->bits.format),
-                    PIXMAN_FORMAT_BPP (dst_image->bits.format),
+                    PIXMAN_FORMAT_BPP (dest_image->bits.format),
                     src_x, src_y, dest_x, dest_y, width, height);
 }
 
@@ -3142,7 +3142,7 @@ mmx_composite_over_x888_8_8888 (pixman_implementation_t *imp,
                                 pixman_op_t              op,
                                 pixman_image_t *         src_image,
                                 pixman_image_t *         mask_image,
-                                pixman_image_t *         dst_image,
+                                pixman_image_t *         dest_image,
                                 int32_t                  src_x,
                                 int32_t                  src_y,
                                 int32_t                  mask_x,
@@ -3158,7 +3158,7 @@ mmx_composite_over_x888_8_8888 (pixman_implementation_t *imp,
     int src_stride, mask_stride, dst_stride;
     int32_t w;
 
-    PIXMAN_IMAGE_GET_LINE (dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+    PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
     PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
@@ -3289,20 +3289,20 @@ mmx_blt (pixman_implementation_t *imp,
          int                      dst_bpp,
          int                      src_x,
          int                      src_y,
-         int                      dst_x,
-         int                      dst_y,
+         int                      dest_x,
+         int                      dest_y,
          int                      width,
          int                      height)
 {
     if (!pixman_blt_mmx (
             src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
-            src_x, src_y, dst_x, dst_y, width, height))
+            src_x, src_y, dest_x, dest_y, width, height))
 
     {
        return _pixman_implementation_blt (
            imp->delegate,
            src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
-           src_x, src_y, dst_x, dst_y, width, height);
+           src_x, src_y, dest_x, dest_y, width, height);
     }
 
     return TRUE;
diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index 2996907..34c2994 100644 (file)
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -382,8 +382,8 @@ typedef pixman_bool_t (*pixman_blt_func_t) (pixman_implementation_t *imp,
                                            int                      dst_bpp,
                                            int                      src_x,
                                            int                      src_y,
-                                           int                      dst_x,
-                                           int                      dst_y,
+                                           int                      dest_x,
+                                           int                      dest_y,
                                            int                      width,
                                            int                      height);
 typedef pixman_bool_t (*pixman_fill_func_t) (pixman_implementation_t *imp,
@@ -478,8 +478,8 @@ _pixman_implementation_blt (pixman_implementation_t *imp,
                             int                      dst_bpp,
                             int                      src_x,
                             int                      src_y,
-                            int                      dst_x,
-                            int                      dst_y,
+                            int                      dest_x,
+                            int                      dest_y,
                             int                      width,
                             int                      height);
 
diff --git a/pixman/pixman-sse2.c b/pixman/pixman-sse2.c
index 1fd66bf..bab3ca6 100644 (file)
--- a/pixman/pixman-sse2.c
+++ b/pixman/pixman-sse2.c
@@ -2363,7 +2363,7 @@ sse2_composite_over_n_8888 (pixman_implementation_t *imp,
                             pixman_op_t              op,
                             pixman_image_t *         src_image,
                             pixman_image_t *         mask_image,
-                            pixman_image_t *         dst_image,
+                            pixman_image_t *         dest_image,
                             int32_t                  src_x,
                             int32_t                  src_y,
                             int32_t                  mask_x,
@@ -2380,13 +2380,13 @@ sse2_composite_over_n_8888 (pixman_implementation_t *imp,
     __m128i xmm_src, xmm_alpha;
     __m128i xmm_dst, xmm_dst_lo, xmm_dst_hi;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
 
     xmm_src = expand_pixel_32_1x128 (src);
     xmm_alpha = expand_alpha_1x128 (xmm_src);
@@ -2442,7 +2442,7 @@ sse2_composite_over_n_0565 (pixman_implementation_t *imp,
                             pixman_op_t              op,
                             pixman_image_t *         src_image,
                             pixman_image_t *         mask_image,
-                            pixman_image_t *         dst_image,
+                            pixman_image_t *         dest_image,
                             int32_t                  src_x,
                             int32_t                  src_y,
                             int32_t                  mask_x,
@@ -2459,13 +2459,13 @@ sse2_composite_over_n_0565 (pixman_implementation_t *imp,
     __m128i xmm_src, xmm_alpha;
     __m128i xmm_dst, xmm_dst0, xmm_dst1, xmm_dst2, xmm_dst3;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
 
     xmm_src = expand_pixel_32_1x128 (src);
     xmm_alpha = expand_alpha_1x128 (xmm_src);
@@ -2527,7 +2527,7 @@ sse2_composite_add_n_8888_8888_ca (pixman_implementation_t *imp,
                                   pixman_op_t              op,
                                   pixman_image_t *         src_image,
                                   pixman_image_t *         mask_image,
-                                  pixman_image_t *         dst_image,
+                                  pixman_image_t *         dest_image,
                                   int32_t                  src_x,
                                   int32_t                  src_y,
                                   int32_t                  mask_x,
@@ -2549,13 +2549,13 @@ sse2_composite_add_n_8888_8888_ca (pixman_implementation_t *imp,
 
     __m128i mmx_src, mmx_mask, mmx_dest;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
 
@@ -2649,7 +2649,7 @@ sse2_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
                                     pixman_op_t              op,
                                     pixman_image_t *         src_image,
                                     pixman_image_t *         mask_image,
-                                    pixman_image_t *         dst_image,
+                                    pixman_image_t *         dest_image,
                                     int32_t                  src_x,
                                     int32_t                  src_y,
                                     int32_t                  mask_x,
@@ -2671,13 +2671,13 @@ sse2_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
 
     __m128i mmx_src, mmx_alpha, mmx_mask, mmx_dest;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
 
@@ -2772,7 +2772,7 @@ sse2_composite_over_8888_n_8888 (pixman_implementation_t *imp,
                                  pixman_op_t              op,
                                  pixman_image_t *         src_image,
                                  pixman_image_t *         mask_image,
-                                 pixman_image_t *         dst_image,
+                                 pixman_image_t *         dest_image,
                                  int32_t                  src_x,
                                  int32_t                  src_y,
                                  int32_t                  mask_x,
@@ -2794,7 +2794,7 @@ sse2_composite_over_8888_n_8888 (pixman_implementation_t *imp,
     __m128i xmm_alpha_lo, xmm_alpha_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
@@ -2886,7 +2886,7 @@ sse2_composite_src_x888_8888 (pixman_implementation_t *imp,
                              pixman_op_t              op,
                              pixman_image_t *         src_image,
                              pixman_image_t *         mask_image,
-                             pixman_image_t *         dst_image,
+                             pixman_image_t *         dest_image,
                              int32_t                  src_x,
                              int32_t                  src_y,
                              int32_t                  mask_x,
@@ -2903,7 +2903,7 @@ sse2_composite_src_x888_8888 (pixman_implementation_t *imp,
 
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
@@ -2954,7 +2954,7 @@ sse2_composite_over_x888_n_8888 (pixman_implementation_t *imp,
                                  pixman_op_t              op,
                                  pixman_image_t *         src_image,
                                  pixman_image_t *         mask_image,
-                                 pixman_image_t *         dst_image,
+                                 pixman_image_t *         dest_image,
                                  int32_t                  src_x,
                                  int32_t                  src_y,
                                  int32_t                  mask_x,
@@ -2975,7 +2975,7 @@ sse2_composite_over_x888_n_8888 (pixman_implementation_t *imp,
     __m128i xmm_dst, xmm_dst_lo, xmm_dst_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
@@ -3055,7 +3055,7 @@ sse2_composite_over_8888_8888 (pixman_implementation_t *imp,
                                pixman_op_t              op,
                                pixman_image_t *         src_image,
                                pixman_image_t *         mask_image,
-                               pixman_image_t *         dst_image,
+                               pixman_image_t *         dest_image,
                                int32_t                  src_x,
                                int32_t                  src_y,
                                int32_t                  mask_x,
@@ -3070,7 +3070,7 @@ sse2_composite_over_8888_8888 (pixman_implementation_t *imp,
     uint32_t    *src_line, *src;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
@@ -3103,7 +3103,7 @@ sse2_composite_over_8888_0565 (pixman_implementation_t *imp,
                                pixman_op_t              op,
                                pixman_image_t *         src_image,
                                pixman_image_t *         mask_image,
-                               pixman_image_t *         dst_image,
+                               pixman_image_t *         dest_image,
                                int32_t                  src_x,
                                int32_t                  src_y,
                                int32_t                  mask_x,
@@ -3123,7 +3123,7 @@ sse2_composite_over_8888_0565 (pixman_implementation_t *imp,
     __m128i xmm_dst, xmm_dst0, xmm_dst1, xmm_dst2, xmm_dst3;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
@@ -3206,7 +3206,7 @@ sse2_composite_over_n_8_8888 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -3229,14 +3229,14 @@ sse2_composite_over_n_8_8888 (pixman_implementation_t *imp,
 
     __m128i mmx_src, mmx_alpha, mmx_mask, mmx_dest;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
        return;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
@@ -3487,7 +3487,7 @@ sse2_composite_src_n_8_8888 (pixman_implementation_t *imp,
                              pixman_op_t              op,
                              pixman_image_t *         src_image,
                              pixman_image_t *         mask_image,
-                             pixman_image_t *         dst_image,
+                             pixman_image_t *         dest_image,
                              int32_t                  src_x,
                              int32_t                  src_y,
                              int32_t                  mask_x,
@@ -3507,19 +3507,19 @@ sse2_composite_src_n_8_8888 (pixman_implementation_t *imp,
     __m128i xmm_src, xmm_def;
     __m128i xmm_mask, xmm_mask_lo, xmm_mask_hi;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     srca = src >> 24;
     if (src == 0)
     {
-       pixman_fill_sse2 (dst_image->bits.bits, dst_image->bits.rowstride,
-                         PIXMAN_FORMAT_BPP (dst_image->bits.format),
+       pixman_fill_sse2 (dest_image->bits.bits, dest_image->bits.rowstride,
+                         PIXMAN_FORMAT_BPP (dest_image->bits.format),
                          dest_x, dest_y, width, height, 0);
        return;
     }
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
@@ -3615,7 +3615,7 @@ sse2_composite_over_n_8_0565 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -3637,13 +3637,13 @@ sse2_composite_over_n_8_0565 (pixman_implementation_t *imp,
     __m128i xmm_mask, xmm_mask_lo, xmm_mask_hi;
     __m128i xmm_dst, xmm_dst0, xmm_dst1, xmm_dst2, xmm_dst3;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
@@ -3761,7 +3761,7 @@ sse2_composite_over_pixbuf_0565 (pixman_implementation_t *imp,
                                  pixman_op_t              op,
                                  pixman_image_t *         src_image,
                                  pixman_image_t *         mask_image,
-                                 pixman_image_t *         dst_image,
+                                 pixman_image_t *         dest_image,
                                  int32_t                  src_x,
                                  int32_t                  src_y,
                                  int32_t                  mask_x,
@@ -3782,7 +3782,7 @@ sse2_composite_over_pixbuf_0565 (pixman_implementation_t *imp,
     __m128i xmm_dst, xmm_dst0, xmm_dst1, xmm_dst2, xmm_dst3;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
@@ -3881,7 +3881,7 @@ sse2_composite_over_pixbuf_8888 (pixman_implementation_t *imp,
                                  pixman_op_t              op,
                                  pixman_image_t *         src_image,
                                  pixman_image_t *         mask_image,
-                                 pixman_image_t *         dst_image,
+                                 pixman_image_t *         dest_image,
                                  int32_t                  src_x,
                                  int32_t                  src_y,
                                  int32_t                  mask_x,
@@ -3901,7 +3901,7 @@ sse2_composite_over_pixbuf_8888 (pixman_implementation_t *imp,
     __m128i xmm_dst_lo, xmm_dst_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
 
@@ -3980,7 +3980,7 @@ sse2_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
                                     pixman_op_t              op,
                                     pixman_image_t *         src_image,
                                     pixman_image_t *         mask_image,
-                                    pixman_image_t *         dst_image,
+                                    pixman_image_t *         dest_image,
                                     int32_t                  src_x,
                                     int32_t                  src_y,
                                     int32_t                  mask_x,
@@ -4003,13 +4003,13 @@ sse2_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
 
     __m128i mmx_src, mmx_alpha, mmx_mask, mmx_dest;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
 
@@ -4124,7 +4124,7 @@ sse2_composite_in_n_8_8 (pixman_implementation_t *imp,
                          pixman_op_t              op,
                          pixman_image_t *         src_image,
                          pixman_image_t *         mask_image,
-                         pixman_image_t *         dst_image,
+                         pixman_image_t *         dest_image,
                          int32_t                  src_x,
                          int32_t                  src_y,
                          int32_t                  mask_x,
@@ -4146,11 +4146,11 @@ sse2_composite_in_n_8_8 (pixman_implementation_t *imp,
     __m128i xmm_dst, xmm_dst_lo, xmm_dst_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     xmm_alpha = expand_alpha_1x128 (expand_pixel_32_1x128 (src));
 
@@ -4220,7 +4220,7 @@ sse2_composite_in_n_8 (pixman_implementation_t *imp,
                       pixman_op_t              op,
                       pixman_image_t *         src_image,
                       pixman_image_t *         mask_image,
-                      pixman_image_t *         dst_image,
+                      pixman_image_t *         dest_image,
                       int32_t                  src_x,
                       int32_t                  src_y,
                       int32_t                  mask_x,
@@ -4240,9 +4240,9 @@ sse2_composite_in_n_8 (pixman_implementation_t *imp,
     __m128i xmm_dst, xmm_dst_lo, xmm_dst_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     xmm_alpha = expand_alpha_1x128 (expand_pixel_32_1x128 (src));
 
@@ -4253,7 +4253,7 @@ sse2_composite_in_n_8 (pixman_implementation_t *imp,
 
     if (src == 0x00)
     {
-       pixman_fill (dst_image->bits.bits, dst_image->bits.rowstride,
+       pixman_fill (dest_image->bits.bits, dest_image->bits.rowstride,
                     8, dest_x, dest_y, width, height, src);
 
        return;
@@ -4312,7 +4312,7 @@ sse2_composite_in_8_8 (pixman_implementation_t *imp,
                        pixman_op_t              op,
                        pixman_image_t *         src_image,
                        pixman_image_t *         mask_image,
-                       pixman_image_t *         dst_image,
+                       pixman_image_t *         dest_image,
                        int32_t                  src_x,
                        int32_t                  src_y,
                        int32_t                  mask_x,
@@ -4332,7 +4332,7 @@ sse2_composite_in_8_8 (pixman_implementation_t *imp,
     __m128i xmm_dst, xmm_dst_lo, xmm_dst_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
 
@@ -4393,7 +4393,7 @@ sse2_composite_add_n_8_8 (pixman_implementation_t *imp,
                          pixman_op_t              op,
                          pixman_image_t *         src_image,
                          pixman_image_t *         mask_image,
-                         pixman_image_t *         dst_image,
+                         pixman_image_t *         dest_image,
                          int32_t                  src_x,
                          int32_t                  src_y,
                          int32_t                  mask_x,
@@ -4415,11 +4415,11 @@ sse2_composite_add_n_8_8 (pixman_implementation_t *imp,
     __m128i xmm_dst, xmm_dst_lo, xmm_dst_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     xmm_alpha = expand_alpha_1x128 (expand_pixel_32_1x128 (src));
 
@@ -4489,7 +4489,7 @@ sse2_composite_add_n_8 (pixman_implementation_t *imp,
                        pixman_op_t              op,
                        pixman_image_t *         src_image,
                        pixman_image_t *         mask_image,
-                       pixman_image_t *         dst_image,
+                       pixman_image_t *         dest_image,
                        int32_t                  src_x,
                        int32_t                  src_y,
                        int32_t                  mask_x,
@@ -4507,9 +4507,9 @@ sse2_composite_add_n_8 (pixman_implementation_t *imp,
     __m128i xmm_src;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     src >>= 24;
 
@@ -4518,7 +4518,7 @@ sse2_composite_add_n_8 (pixman_implementation_t *imp,
 
     if (src == 0xff)
     {
-       pixman_fill (dst_image->bits.bits, dst_image->bits.rowstride,
+       pixman_fill (dest_image->bits.bits, dest_image->bits.rowstride,
                     8, dest_x, dest_y, width, height, 0xff);
 
        return;
@@ -4572,7 +4572,7 @@ sse2_composite_add_8_8 (pixman_implementation_t *imp,
                        pixman_op_t              op,
                        pixman_image_t *         src_image,
                        pixman_image_t *         mask_image,
-                       pixman_image_t *         dst_image,
+                       pixman_image_t *         dest_image,
                        int32_t                  src_x,
                        int32_t                  src_y,
                        int32_t                  mask_x,
@@ -4591,7 +4591,7 @@ sse2_composite_add_8_8 (pixman_implementation_t *imp,
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint8_t, src_stride, src_line, 1);
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1);
 
     while (height--)
     {
@@ -4634,7 +4634,7 @@ sse2_composite_add_8888_8888 (pixman_implementation_t *imp,
                               pixman_op_t              op,
                               pixman_image_t *         src_image,
                               pixman_image_t *         mask_image,
-                              pixman_image_t *         dst_image,
+                              pixman_image_t *         dest_image,
                               int32_t                  src_x,
                               int32_t                  src_y,
                               int32_t                  mask_x,
@@ -4651,7 +4651,7 @@ sse2_composite_add_8888_8888 (pixman_implementation_t *imp,
     PIXMAN_IMAGE_GET_LINE (
        src_image, src_x, src_y, uint32_t, src_stride, src_line, 1);
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
 
     while (height--)
     {
@@ -4674,8 +4674,8 @@ pixman_blt_sse2 (uint32_t *src_bits,
                  int       dst_bpp,
                  int       src_x,
                  int       src_y,
-                 int       dst_x,
-                 int       dst_y,
+                 int       dest_x,
+                 int       dest_y,
                  int       width,
                  int       height)
 {
@@ -4691,7 +4691,7 @@ pixman_blt_sse2 (uint32_t *src_bits,
        src_stride = src_stride * (int) sizeof (uint32_t) / 2;
        dst_stride = dst_stride * (int) sizeof (uint32_t) / 2;
        src_bytes =(uint8_t *)(((uint16_t *)src_bits) + src_stride * (src_y) + (src_x));
-       dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+       dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dest_y) + (dest_x));
        byte_width = 2 * width;
        src_stride *= 2;
        dst_stride *= 2;
@@ -4701,7 +4701,7 @@ pixman_blt_sse2 (uint32_t *src_bits,
        src_stride = src_stride * (int) sizeof (uint32_t) / 4;
        dst_stride = dst_stride * (int) sizeof (uint32_t) / 4;
        src_bytes = (uint8_t *)(((uint32_t *)src_bits) + src_stride * (src_y) + (src_x));
-       dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
+       dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dest_y) + (dest_x));
        byte_width = 4 * width;
        src_stride *= 4;
        dst_stride *= 4;
@@ -4792,7 +4792,7 @@ sse2_composite_copy_area (pixman_implementation_t *imp,
                           pixman_op_t              op,
                           pixman_image_t *         src_image,
                           pixman_image_t *         mask_image,
-                          pixman_image_t *         dst_image,
+                          pixman_image_t *         dest_image,
                           int32_t                  src_x,
                           int32_t                  src_y,
                           int32_t                  mask_x,
@@ -4803,11 +4803,11 @@ sse2_composite_copy_area (pixman_implementation_t *imp,
                           int32_t                  height)
 {
     pixman_blt_sse2 (src_image->bits.bits,
-                     dst_image->bits.bits,
+                     dest_image->bits.bits,
                      src_image->bits.rowstride,
-                     dst_image->bits.rowstride,
+                     dest_image->bits.rowstride,
                      PIXMAN_FORMAT_BPP (src_image->bits.format),
-                     PIXMAN_FORMAT_BPP (dst_image->bits.format),
+                     PIXMAN_FORMAT_BPP (dest_image->bits.format),
                      src_x, src_y, dest_x, dest_y, width, height);
 }
 
@@ -4816,7 +4816,7 @@ sse2_composite_over_x888_8_8888 (pixman_implementation_t *imp,
                                  pixman_op_t              op,
                                  pixman_image_t *         src_image,
                                  pixman_image_t *         mask_image,
-                                 pixman_image_t *         dst_image,
+                                 pixman_image_t *         dest_image,
                                  int32_t                  src_x,
                                  int32_t                  src_y,
                                  int32_t                  mask_x,
@@ -4839,7 +4839,7 @@ sse2_composite_over_x888_8_8888 (pixman_implementation_t *imp,
     __m128i xmm_mask, xmm_mask_lo, xmm_mask_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
     PIXMAN_IMAGE_GET_LINE (
@@ -4951,7 +4951,7 @@ sse2_composite_over_8888_8_8888 (pixman_implementation_t *imp,
                                  pixman_op_t              op,
                                  pixman_image_t *         src_image,
                                  pixman_image_t *         mask_image,
-                                 pixman_image_t *         dst_image,
+                                 pixman_image_t *         dest_image,
                                  int32_t                  src_x,
                                  int32_t                  src_y,
                                  int32_t                  mask_x,
@@ -4973,7 +4973,7 @@ sse2_composite_over_8888_8_8888 (pixman_implementation_t *imp,
     __m128i xmm_mask, xmm_mask_lo, xmm_mask_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1);
     PIXMAN_IMAGE_GET_LINE (
@@ -5104,7 +5104,7 @@ sse2_composite_over_reverse_n_8888 (pixman_implementation_t *imp,
                                    pixman_op_t              op,
                                    pixman_image_t *         src_image,
                                    pixman_image_t *         mask_image,
-                                   pixman_image_t *         dst_image,
+                                   pixman_image_t *         dest_image,
                                    int32_t                  src_x,
                                    int32_t                  src_y,
                                    int32_t                  mask_x,
@@ -5122,13 +5122,13 @@ sse2_composite_over_reverse_n_8888 (pixman_implementation_t *imp,
     int dst_stride;
     int32_t w;
 
-    src = _pixman_image_get_solid (imp, src_image, dst_image->bits.format);
+    src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
 
     if (src == 0)
        return;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
 
     xmm_src = expand_pixel_32_1x128 (src);
 
@@ -5195,7 +5195,7 @@ sse2_composite_over_8888_8888_8888 (pixman_implementation_t *imp,
                                    pixman_op_t              op,
                                    pixman_image_t *         src_image,
                                    pixman_image_t *         mask_image,
-                                   pixman_image_t *         dst_image,
+                                   pixman_image_t *         dest_image,
                                    int32_t                  src_x,
                                    int32_t                  src_y,
                                    int32_t                  mask_x,
@@ -5217,7 +5217,7 @@ sse2_composite_over_8888_8888_8888 (pixman_implementation_t *imp,
     __m128i xmm_mask, xmm_mask_lo, xmm_mask_hi;
 
     PIXMAN_IMAGE_GET_LINE (
-       dst_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
+       dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1);
     PIXMAN_IMAGE_GET_LINE (
        mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1);
     PIXMAN_IMAGE_GET_LINE (
@@ -5783,20 +5783,20 @@ sse2_blt (pixman_implementation_t *imp,
           int                      dst_bpp,
           int                      src_x,
           int                      src_y,
-          int                      dst_x,
-          int                      dst_y,
+          int                      dest_x,
+          int                      dest_y,
           int                      width,
           int                      height)
 {
     if (!pixman_blt_sse2 (
             src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
-            src_x, src_y, dst_x, dst_y, width, height))
+            src_x, src_y, dest_x, dest_y, width, height))
 
     {
        return _pixman_implementation_blt (
            imp->delegate,
            src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
-           src_x, src_y, dst_x, dst_y, width, height);
+           src_x, src_y, dest_x, dest_y, width, height);
     }
 
     return TRUE;
diff --git a/pixman/pixman.c b/pixman/pixman.c
index 61d3a92..730509a 100644 (file)
--- a/pixman/pixman.c
+++ b/pixman/pixman.c
@@ -238,7 +238,7 @@ static pixman_bool_t
 pixman_compute_composite_region32 (pixman_region32_t * region,
                                    pixman_image_t *    src_image,
                                    pixman_image_t *    mask_image,
-                                   pixman_image_t *    dst_image,
+                                   pixman_image_t *    dest_image,
                                    int32_t             src_x,
                                    int32_t             src_y,
                                    int32_t             mask_x,
@@ -255,8 +255,8 @@ pixman_compute_composite_region32 (pixman_region32_t * region,
 
     region->extents.x1 = MAX (region->extents.x1, 0);
     region->extents.y1 = MAX (region->extents.y1, 0);
-    region->extents.x2 = MIN (region->extents.x2, dst_image->bits.width);
-    region->extents.y2 = MIN (region->extents.y2, dst_image->bits.height);
+    region->extents.x2 = MIN (region->extents.x2, dest_image->bits.width);
+    region->extents.y2 = MIN (region->extents.y2, dest_image->bits.height);
 
     region->data = 0;
 
@@ -271,29 +271,29 @@ pixman_compute_composite_region32 (pixman_region32_t * region,
        return FALSE;
     }
 
-    if (dst_image->common.have_clip_region)
+    if (dest_image->common.have_clip_region)
     {
-       if (!clip_general_image (region, &dst_image->common.clip_region, 0, 0))
+       if (!clip_general_image (region, &dest_image->common.clip_region, 0, 0))
            return FALSE;
     }
 
-    if (dst_image->common.alpha_map)
+    if (dest_image->common.alpha_map)
     {
        if (!pixman_region32_intersect_rect (region, region,
-                                            dst_image->common.alpha_origin_x,
-                                            dst_image->common.alpha_origin_y,
-                                            dst_image->common.alpha_map->width,
-                                            dst_image->common.alpha_map->height))
+                                            dest_image->common.alpha_origin_x,
+                                            dest_image->common.alpha_origin_y,
+                                            dest_image->common.alpha_map->width,
+                                            dest_image->common.alpha_map->height))
        {
            return FALSE;
        }
        if (!pixman_region32_not_empty (region))
            return FALSE;
-       if (dst_image->common.alpha_map->common.have_clip_region)
+       if (dest_image->common.alpha_map->common.have_clip_region)
        {
-           if (!clip_general_image (region, &dst_image->common.alpha_map->common.clip_region,
-                                    -dst_image->common.alpha_origin_x,
-                                    -dst_image->common.alpha_origin_y))
+           if (!clip_general_image (region, &dest_image->common.alpha_map->common.clip_region,
+                                    -dest_image->common.alpha_origin_x,
+                                    -dest_image->common.alpha_origin_y))
            {
                return FALSE;
            }
@@ -821,8 +821,8 @@ pixman_blt (uint32_t *src_bits,
             int       dst_bpp,
             int       src_x,
             int       src_y,
-            int       dst_x,
-            int       dst_y,
+            int       dest_x,
+            int       dest_y,
             int       width,
             int       height)
 {
@@ -830,7 +830,7 @@ pixman_blt (uint32_t *src_bits,
                                       src_bits, dst_bits, src_stride, dst_stride,
                                        src_bpp, dst_bpp,
                                        src_x, src_y,
-                                       dst_x, dst_y,
+                                       dest_x, dest_y,
                                        width, height);
 }
 
@@ -1184,7 +1184,7 @@ PIXMAN_EXPORT pixman_bool_t
 pixman_compute_composite_region (pixman_region16_t * region,
                                  pixman_image_t *    src_image,
                                  pixman_image_t *    mask_image,
-                                 pixman_image_t *    dst_image,
+                                 pixman_image_t *    dest_image,
                                  int16_t             src_x,
                                  int16_t             src_y,
                                  int16_t             mask_x,
@@ -1200,7 +1200,7 @@ pixman_compute_composite_region (pixman_region16_t * region,
     pixman_region32_init (&r32);
 
     retval = pixman_compute_composite_region32 (
-       &r32, src_image, mask_image, dst_image,
+       &r32, src_image, mask_image, dest_image,
        src_x, src_y, mask_x, mask_y, dest_x, dest_y,
        width, height);
 
diff --git a/pixman/pixman.h b/pixman/pixman.h
index 59d0760..c57092a 100644 (file)
--- a/pixman/pixman.h
+++ b/pixman/pixman.h
@@ -571,8 +571,8 @@ pixman_bool_t pixman_blt                (uint32_t           *src_bits,
                                         int                 dst_bpp,
                                         int                 src_x,
                                         int                 src_y,
-                                        int                 dst_x,
-                                        int                 dst_y,
+                                        int                 dest_x,
+                                        int                 dest_y,
                                         int                 width,
                                         int                 height);
 pixman_bool_t pixman_fill               (uint32_t           *bits,
@@ -811,7 +811,7 @@ pixman_bool_t   pixman_image_fill_boxes              (pixman_op_t
 pixman_bool_t pixman_compute_composite_region (pixman_region16_t *region,
                                               pixman_image_t    *src_image,
                                               pixman_image_t    *mask_image,
-                                              pixman_image_t    *dst_image,
+                                              pixman_image_t    *dest_image,
                                               int16_t            src_x,
                                               int16_t            src_y,
                                               int16_t            mask_x,
Domain: Graphics System / Rendering Engine;