cairo/patches/cairo-1.0.0-display_endianness.patch

diff -NurdB cairo-1.0.0/src/cairo-xlib-surface.c cairo-1.0.0-patched/src/cairo-xlib-surface.c
--- cairo-1.0.0/src/cairo-xlib-surface.c	2005-08-24 00:42:19.000000000 -0500
+++ cairo-1.0.0-patched/src/cairo-xlib-surface.c	2005-09-02 10:12:59.000000000 -0500
@@ -60,6 +60,9 @@
 static cairo_bool_t
 _cairo_surface_is_xlib (cairo_surface_t *surface);
 
+static cairo_bool_t
+_native_byte_order_lsb (void);
+
 /*
  * Instead of taking two round trips for each blending request,
  * assume that if a particular drawable fails GetImage that it will
@@ -302,6 +305,116 @@
     return False;
 }
 
+static void
+_swap_ximage_2bytes (XImage *ximage)
+{
+    int i, j;
+    char *line = ximage->data;
+
+    for (j = ximage->height; j; j--) {
+	uint16_t *p = (uint16_t *)line;
+	for (i = ximage->width; i; i--) {
+	    *p = (((*p & 0x00ff) << 8) |
+		  ((*p)          >> 8));
+	    p++;
+	}
+
+	line += ximage->bytes_per_line;
+    }
+}
+
+static void
+_swap_ximage_4bytes (XImage *ximage)
+{
+    int i, j;
+    char *line = ximage->data;
+
+    for (j = ximage->height; j; j--) {
+	uint32_t *p = (uint32_t *)line;
+	for (i = ximage->width; i; i--) {
+	    *p = (((*p & 0x000000ff) << 24) |
+		  ((*p & 0x0000ff00) << 8) |
+		  ((*p & 0x00ff0000) >> 8) |
+		  ((*p)              >> 24));
+	    p++;
+	}
+
+	line += ximage->bytes_per_line;
+    }
+}
+
+static void
+_swap_ximage_bits (XImage *ximage)
+{
+    int i, j;
+    char *line = ximage->data;
+    int unit = ximage->bitmap_unit;
+    int line_bytes = ((ximage->width + unit - 1) & ~(unit - 1)) / 8;
+
+    for (j = ximage->height; j; j--) {
+	char *p = line;
+	
+	for (i = line_bytes; i; i--) {
+	    char b = *p;
+	    b = ((b << 1) & 0xaa) | ((b >> 1) & 0x55);
+	    b = ((b << 2) & 0xcc) | ((b >> 2) & 0x33);
+	    b = ((b << 4) & 0xf0) | ((b >> 4) & 0x0f);
+	    *p = b;
+	    
+	    p++;
+	}
+
+	line += ximage->bytes_per_line;
+    }
+}
+
+static void
+_swap_ximage_to_native (XImage *ximage)
+{
+    int unit_bytes = 0;
+    int native_byte_order = _native_byte_order_lsb () ? LSBFirst : MSBFirst;
+
+    if (ximage->bits_per_pixel == 1 &&
+	ximage->bitmap_bit_order != native_byte_order) {
+	_swap_ximage_bits (ximage);
+	if (ximage->bitmap_bit_order == ximage->byte_order)
+	    return;
+    }
+    
+    if (ximage->byte_order == native_byte_order)
+	return;
+
+    switch (ximage->bits_per_pixel) {
+    case 1:
+	unit_bytes = ximage->bitmap_unit / 8;
+	break;
+    case 8:
+    case 16:
+    case 32:
+	unit_bytes = ximage->bits_per_pixel / 8;
+	break;
+    default:
+        /* This could be hit on some uncommon but possible cases,
+	 * such as bpp=4. These are cases that libpixman can't deal
+	 * with in any case.
+	 */
+	ASSERT_NOT_REACHED;
+    }
+
+    switch (unit_bytes) {
+    case 1:
+	return;
+    case 2:
+	_swap_ximage_2bytes (ximage);
+	break;
+    case 4:
+	_swap_ximage_4bytes (ximage);
+	break;
+    default:
+	ASSERT_NOT_REACHED;
+    }
+}
+
 static cairo_status_t
 _get_image_surface (cairo_xlib_surface_t   *surface,
 		    cairo_rectangle_t      *interest_rect,
@@ -405,6 +518,8 @@
     }
     if (!ximage)
 	return CAIRO_STATUS_NO_MEMORY;
+
+    _swap_ximage_to_native (ximage);
 					
     /*
      * Compute the pixel format masks from either a visual or a 
@@ -545,40 +660,35 @@
 		     int                    dst_x,
 		     int                    dst_y)
 {
-    XImage *ximage;
-    unsigned bitmap_pad;
-
-    /* XXX this is wrong */
-    if (image->depth > 16)
-	bitmap_pad = 32;
-    else if (image->depth > 8)
-	bitmap_pad = 16;
-    else
-	bitmap_pad = 8;
-
-    ximage = XCreateImage (surface->dpy,
-			   DefaultVisual(surface->dpy, DefaultScreen(surface->dpy)),
-			   image->depth,
-			   ZPixmap,
-			   0,
-			   (char *) image->data,
-			   image->width,
-			   image->height,
-			   bitmap_pad,
-			   image->stride);
-    if (ximage == NULL)
-	return CAIRO_STATUS_NO_MEMORY;
+    XImage ximage;
+    int bpp, alpha, red, green, blue;
+    int native_byte_order = _native_byte_order_lsb () ? LSBFirst : MSBFirst;
+    
+    pixman_format_get_masks (pixman_image_get_format (image->pixman_image),
+			     &bpp, &alpha, &red, &green, &blue);
+    
+    ximage.width = image->width;
+    ximage.height = image->height;
+    ximage.format = ZPixmap;
+    ximage.data = (char *)image->data;
+    ximage.byte_order = native_byte_order;
+    ximage.bitmap_unit = 32;	/* always for libpixman */
+    ximage.bitmap_bit_order = native_byte_order;
+    ximage.bitmap_pad = 32;	/* always for libpixman */
+    ximage.depth = image->depth;
+    ximage.bytes_per_line = image->stride;
+    ximage.bits_per_pixel = bpp;
+    ximage.red_mask = red;
+    ximage.green_mask = green;
+    ximage.blue_mask = blue;
 
+    XInitImage (&ximage);
+    
     _cairo_xlib_surface_ensure_gc (surface);
     XPutImage(surface->dpy, surface->drawable, surface->gc,
-	      ximage, 0, 0, dst_x, dst_y,
+	      &ximage, 0, 0, dst_x, dst_y,
 	      image->width, image->height);
 
-    /* Foolish XDestroyImage thinks it can free my data, but I won't
-       stand for it. */
-    ximage->data = NULL;
-    XDestroyImage (ximage);
-
     return CAIRO_STATUS_SUCCESS;
 
 }
1	niro	144	diff -NurdB cairo-1.0.0/src/cairo-xlib-surface.c cairo-1.0.0-patched/src/cairo-xlib-surface.c
2			--- cairo-1.0.0/src/cairo-xlib-surface.c 2005-08-24 00:42:19.000000000 -0500
3			+++ cairo-1.0.0-patched/src/cairo-xlib-surface.c 2005-09-02 10:12:59.000000000 -0500
4			@@ -60,6 +60,9 @@
5			static cairo_bool_t
6			_cairo_surface_is_xlib (cairo_surface_t *surface);
7
8			+static cairo_bool_t
9			+_native_byte_order_lsb (void);
10			+
11			/*
12			* Instead of taking two round trips for each blending request,
13			* assume that if a particular drawable fails GetImage that it will
14			@@ -302,6 +305,116 @@
15			return False;
16			}
17
18			+static void
19			+_swap_ximage_2bytes (XImage *ximage)
20			+{
21			+ int i, j;
22			+ char *line = ximage->data;
23			+
24			+ for (j = ximage->height; j; j--) {
25			+ uint16_t p = (uint16_t )line;
26			+ for (i = ximage->width; i; i--) {
27			+ p = (((p & 0x00ff) << 8) \|
28			+ ((*p) >> 8));
29			+ p++;
30			+ }
31			+
32			+ line += ximage->bytes_per_line;
33			+ }
34			+}
35			+
36			+static void
37			+_swap_ximage_4bytes (XImage *ximage)
38			+{
39			+ int i, j;
40			+ char *line = ximage->data;
41			+
42			+ for (j = ximage->height; j; j--) {
43			+ uint32_t p = (uint32_t )line;
44			+ for (i = ximage->width; i; i--) {
45			+ p = (((p & 0x000000ff) << 24) \|
46			+ ((*p & 0x0000ff00) << 8) \|
47			+ ((*p & 0x00ff0000) >> 8) \|
48			+ ((*p) >> 24));
49			+ p++;
50			+ }
51			+
52			+ line += ximage->bytes_per_line;
53			+ }
54			+}
55			+
56			+static void
57			+_swap_ximage_bits (XImage *ximage)
58			+{
59			+ int i, j;
60			+ char *line = ximage->data;
61			+ int unit = ximage->bitmap_unit;
62			+ int line_bytes = ((ximage->width + unit - 1) & ~(unit - 1)) / 8;
63			+
64			+ for (j = ximage->height; j; j--) {
65			+ char *p = line;
66			+
67			+ for (i = line_bytes; i; i--) {
68			+ char b = *p;
69			+ b = ((b << 1) & 0xaa) \| ((b >> 1) & 0x55);
70			+ b = ((b << 2) & 0xcc) \| ((b >> 2) & 0x33);
71			+ b = ((b << 4) & 0xf0) \| ((b >> 4) & 0x0f);
72			+ *p = b;
73			+
74			+ p++;
75			+ }
76			+
77			+ line += ximage->bytes_per_line;
78			+ }
79			+}
80			+
81			+static void
82			+_swap_ximage_to_native (XImage *ximage)
83			+{
84			+ int unit_bytes = 0;
85			+ int native_byte_order = _native_byte_order_lsb () ? LSBFirst : MSBFirst;
86			+
87			+ if (ximage->bits_per_pixel == 1 &&
88			+ ximage->bitmap_bit_order != native_byte_order) {
89			+ _swap_ximage_bits (ximage);
90			+ if (ximage->bitmap_bit_order == ximage->byte_order)
91			+ return;
92			+ }
93			+
94			+ if (ximage->byte_order == native_byte_order)
95			+ return;
96			+
97			+ switch (ximage->bits_per_pixel) {
98			+ case 1:
99			+ unit_bytes = ximage->bitmap_unit / 8;
100			+ break;
101			+ case 8:
102			+ case 16:
103			+ case 32:
104			+ unit_bytes = ximage->bits_per_pixel / 8;
105			+ break;
106			+ default:
107			+ /* This could be hit on some uncommon but possible cases,
108			+ * such as bpp=4. These are cases that libpixman can't deal
109			+ * with in any case.
110			+ */
111			+ ASSERT_NOT_REACHED;
112			+ }
113			+
114			+ switch (unit_bytes) {
115			+ case 1:
116			+ return;
117			+ case 2:
118			+ _swap_ximage_2bytes (ximage);
119			+ break;
120			+ case 4:
121			+ _swap_ximage_4bytes (ximage);
122			+ break;
123			+ default:
124			+ ASSERT_NOT_REACHED;
125			+ }
126			+}
127			+
128			static cairo_status_t
129			_get_image_surface (cairo_xlib_surface_t *surface,
130			cairo_rectangle_t *interest_rect,
131			@@ -405,6 +518,8 @@
132			}
133			if (!ximage)
134			return CAIRO_STATUS_NO_MEMORY;
135			+
136			+ _swap_ximage_to_native (ximage);
137
138			/*
139			* Compute the pixel format masks from either a visual or a
140			@@ -545,40 +660,35 @@
141			int dst_x,
142			int dst_y)
143			{
144			- XImage *ximage;
145			- unsigned bitmap_pad;
146			-
147			- /* XXX this is wrong */
148			- if (image->depth > 16)
149			- bitmap_pad = 32;
150			- else if (image->depth > 8)
151			- bitmap_pad = 16;
152			- else
153			- bitmap_pad = 8;
154			-
155			- ximage = XCreateImage (surface->dpy,
156			- DefaultVisual(surface->dpy, DefaultScreen(surface->dpy)),
157			- image->depth,
158			- ZPixmap,
159			- 0,
160			- (char *) image->data,
161			- image->width,
162			- image->height,
163			- bitmap_pad,
164			- image->stride);
165			- if (ximage == NULL)
166			- return CAIRO_STATUS_NO_MEMORY;
167			+ XImage ximage;
168			+ int bpp, alpha, red, green, blue;
169			+ int native_byte_order = _native_byte_order_lsb () ? LSBFirst : MSBFirst;
170			+
171			+ pixman_format_get_masks (pixman_image_get_format (image->pixman_image),
172			+ &bpp, &alpha, &red, &green, &blue);
173			+
174			+ ximage.width = image->width;
175			+ ximage.height = image->height;
176			+ ximage.format = ZPixmap;
177			+ ximage.data = (char *)image->data;
178			+ ximage.byte_order = native_byte_order;
179			+ ximage.bitmap_unit = 32; /* always for libpixman */
180			+ ximage.bitmap_bit_order = native_byte_order;
181			+ ximage.bitmap_pad = 32; /* always for libpixman */
182			+ ximage.depth = image->depth;
183			+ ximage.bytes_per_line = image->stride;
184			+ ximage.bits_per_pixel = bpp;
185			+ ximage.red_mask = red;
186			+ ximage.green_mask = green;
187			+ ximage.blue_mask = blue;
188
189			+ XInitImage (&ximage);
190			+
191			_cairo_xlib_surface_ensure_gc (surface);
192			XPutImage(surface->dpy, surface->drawable, surface->gc,
193			- ximage, 0, 0, dst_x, dst_y,
194			+ &ximage, 0, 0, dst_x, dst_y,
195			image->width, image->height);
196
197			- /* Foolish XDestroyImage thinks it can free my data, but I won't
198			- stand for it. */
199			- ximage->data = NULL;
200			- XDestroyImage (ximage);
201			-
202			return CAIRO_STATUS_SUCCESS;
203
204			}