...and in with the new image library

10 files changed, 2444 insertions, 0 deletions

diff --git a/image/.gitignore b/image/.gitignore
new file mode 100644
index 0000000..586956e
--- /dev/null
+++ b/image/.gitignore
@@ -0,0 +1,5 @@
+test_xcb_image
+test_xcb_image_shm
+test_formats
+test_bitmap
+test.xbm
diff --git a/image/Makefile.am b/image/Makefile.am
new file mode 100644
index 0000000..9a88187
--- /dev/null
+++ b/image/Makefile.am
@@ -0,0 +1,37 @@
+
+MAINTAINERCLEANFILES = Makefile.in
+
+lib_LTLIBRARIES = libxcb-image.la
+
+xcbinclude_HEADERS = xcb_image.h xcb_pixel.h
+
+AM_CFLAGS = $(CWARNFLAGS)
+
+XCB_IMAGE_LIBS = libxcb-image.la
+
+libxcb_image_la_SOURCES = xcb_image.c
+libxcb_image_la_CPPFLAGS = $(XCB_CFLAGS) $(XCB_SHM_CFLAGS) $(XCB_AUX_CFLAGS)
+libxcb_image_la_LIBADD = $(XCB_LIBS) $(XCB_SHM_LIBS) $(XCB_AUX_LIBS)
+
+pkgconfig_DATA = xcb-image.pc
+
+EXTRA_DIST=xcb-image.pc.in
+
+noinst_PROGRAMS = test_xcb_image test_xcb_image_shm test_formats test_bitmap
+
+test_xcb_image_SOURCES = test_xcb_image.c
+test_xcb_image_CPPFLAGS = $(XCB_CFLAGS) $(XCB_SHM_CFLAGS) $(XCB_AUX_CFLAGS)
+test_xcb_image_LDADD = $(XCB_LIBS) $(XCB_AUX_LIBS) $(XCB_IMAGE_LIBS)
+
+test_xcb_image_shm_SOURCES = test_xcb_image_shm.c
+test_xcb_image_shm_CPPFLAGS = $(XCB_CFLAGS) $(XCB_SHM_CFLAGS) $(XCB_AUX_CFLAGS)
+test_xcb_image_shm_LDADD = $(XCB_LIBS) $(XCB_SHM_LIBS) \
+	$(XCB_AUX_LIBS) $(XCB_IMAGE_LIBS)
+
+test_formats_SOURCES = test_formats.c
+test_formats_CPPFLAGS = $(XCB_CFLAGS) $(XCB_SHM_CFLAGS) $(XCB_AUX_CFLAGS)
+test_formats_LDADD = $(XCB_LIBS) $(XCB_AUX_LIBS) $(XCB_IMAGE_LIBS)
+
+test_bitmap_SOURCES = test_bitmap.c
+test_bitmap_CPPFLAGS = $(XCB_CFLAGS) $(XCB_SHM_CFLAGS) $(XCB_AUX_CFLAGS)
+test_bitmap_LDADD = $(XCB_LIBS) $(XCB_AUX_LIBS) $(XCB_IMAGE_LIBS)
diff --git a/image/test_bitmap.c b/image/test_bitmap.c
new file mode 100644
index 0000000..5328516
--- /dev/null
+++ b/image/test_bitmap.c
@@ -0,0 +1,110 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <xcb/xcb.h>
+#include <xcb/xcb_aux.h>
+#include "xcb_image.h"
+
+#include "test.xbm"
+
+static xcb_window_t make_window(xcb_connection_t *c,
+				xcb_screen_t *s,
+				uint32_t bg,
+				uint32_t fg) {
+    uint32_t mask = 0;
+    xcb_params_cw_t cwa;
+    xcb_window_t w;
+    xcb_void_cookie_t check_cookie;
+    xcb_generic_error_t *error;
+    xcb_visualtype_t *v = xcb_aux_find_visual_by_id(s, s->root_visual);
+    assert(v);
+    XCB_AUX_ADD_PARAM(&mask, &cwa, back_pixel, bg);
+    XCB_AUX_ADD_PARAM(&mask, &cwa, border_pixel, fg);
+    XCB_AUX_ADD_PARAM(&mask, &cwa, override_redirect, 1);
+    XCB_AUX_ADD_PARAM(&mask, &cwa, event_mask,
+		      XCB_EVENT_MASK_BUTTON_PRESS |
+		      XCB_EVENT_MASK_EXPOSURE);
+    w = xcb_generate_id(c);
+    check_cookie = xcb_aux_create_window_checked(c,
+      s->root_depth, w, s->root, 0, 0, test_width, test_height, 1,
+      XCB_WINDOW_CLASS_INPUT_OUTPUT, v->visual_id, mask, &cwa);
+    error = xcb_request_check(c, check_cookie);
+    assert(!error);
+    check_cookie = xcb_map_window_checked(c, w);
+    error = xcb_request_check(c, check_cookie);
+    assert(!error);
+    return w;
+}
+
+void process_events(xcb_connection_t *c,
+		    xcb_gcontext_t g,
+		    xcb_window_t w,
+		    xcb_pixmap_t p) {
+    xcb_generic_event_t *e;
+    xcb_void_cookie_t cookie;
+
+    while ((e = xcb_wait_for_event(c))) {
+	uint32_t r = e->response_type & 0x7f;
+	xcb_generic_error_t *err;
+	
+	fprintf(stderr, "event %d\n", r);
+	switch (r) {
+	case XCB_EXPOSE:
+	case XCB_MAP_NOTIFY:
+	    cookie = xcb_copy_area_checked(c, p, w, g,
+					   0, 0, 0, 0,
+					   test_width, test_height);
+	    assert(!xcb_request_check(c, cookie));
+	    break;
+	case XCB_BUTTON_PRESS:
+	    exit(0);
+	    break;
+	case 0:
+	    err = (xcb_generic_error_t *) e;
+	    printf("error: %d (sequence %d)\n",
+		   err->error_code, (unsigned int) err->full_sequence);
+	    exit(1);
+	default:
+	    break;
+	}
+	free(e);
+    }
+}
+		       
+int main(int argc, char **argv) {
+    int snum;
+    xcb_void_cookie_t check_cookie;
+    xcb_window_t w;
+    xcb_gcontext_t gc;
+    xcb_pixmap_t p;
+    xcb_connection_t *c = xcb_connect(0, &snum);
+    xcb_screen_t *s = xcb_aux_get_screen(c, snum);
+    xcb_alloc_named_color_cookie_t bg_cookie =
+	xcb_alloc_named_color(c, s->default_colormap,
+			      strlen("white"), "white");
+    xcb_alloc_named_color_cookie_t fg_cookie =
+	xcb_alloc_named_color(c, s->default_colormap,
+			      strlen("black"), "black");
+    xcb_alloc_named_color_reply_t *bg_reply =
+	xcb_alloc_named_color_reply(c, bg_cookie, 0);
+    xcb_alloc_named_color_reply_t *fg_reply =
+	xcb_alloc_named_color_reply(c, fg_cookie, 0);
+    uint32_t fg, bg;
+    assert(bg_reply && fg_reply);
+    bg = bg_reply->pixel;
+    fg = fg_reply->pixel;
+    free(bg_reply);
+    free(fg_reply);
+    w = make_window(c, s, bg, fg);
+    gc = xcb_generate_id(c);
+    check_cookie = xcb_create_gc_checked(c, gc, w, 0, 0);
+    assert(!xcb_request_check(c, check_cookie));
+    p = xcb_create_pixmap_from_bitmap_data(c, w,
+          (uint8_t *)test_bits, test_width, test_height,
+	  s->root_depth, fg, bg, 0);
+    assert(p);
+    process_events(c, gc, w, p);
+    xcb_disconnect(c);
+    return 1;
+}
diff --git a/image/test_formats.c b/image/test_formats.c
new file mode 100644
index 0000000..276f442
--- /dev/null
+++ b/image/test_formats.c
@@ -0,0 +1,174 @@
+#include <xcb/xcb.h>
+#include "xcb_image.h"
+#include "xcb_aux.h"
+#include "xcb_bitops.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define WIDTH 50
+#define HEIGHT 50
+
+static uint32_t
+color (uint32_t depth, uint32_t x, uint32_t y)
+{
+	uint32_t p;
+
+	if (depth == 1) {
+		extern long random();
+		int frac = random() % (WIDTH * HEIGHT);
+		p = x * y >= frac;
+		return p;
+	}
+	depth /= 3;
+	p =  ((1 << depth) - 1) * x * y / WIDTH / HEIGHT;
+	return (p << depth) | (p << (2 * depth));
+}
+
+static xcb_image_t *create_image(xcb_connection_t *c, int depth, int format)
+{
+	xcb_image_t *im;
+	int x, y;
+	printf("Image depth %d, format %d\n", depth, format);
+	im = xcb_image_create_native(c, WIDTH, HEIGHT,
+				     format, depth, 0, 0, 0);
+	for(x = 0; x < WIDTH; ++x)
+		for(y = 0; y < HEIGHT; ++y)
+			xcb_image_put_pixel(im, x, y, color(depth, x, y));
+	return im;
+}
+
+static xcb_window_t create_window(xcb_connection_t *c, xcb_screen_t *root)
+{
+	static const uint32_t mask = XCB_CW_EVENT_MASK;
+	static const uint32_t values[] = { XCB_EVENT_MASK_EXPOSURE };
+	unsigned int seq;
+	xcb_window_t w = xcb_generate_id(c);
+	seq = xcb_create_window(c, root->root_depth, w, root->root, 30, 30, WIDTH, HEIGHT, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, root->root_visual, mask, values).sequence;
+	printf("CreateWindow sequence %d, depth %d\n", seq, root->root_depth);
+	seq = xcb_map_window(c, w).sequence;
+	printf("MapWindow sequence %d\n", seq);
+	return w;
+}
+
+static xcb_pixmap_t create_pixmap(xcb_connection_t *c, xcb_drawable_t d, uint8_t depth)
+{
+	xcb_pixmap_t p = xcb_generate_id(c);
+	unsigned int seq;
+	seq = xcb_create_pixmap(c, depth, p, d, WIDTH, HEIGHT).sequence;
+	printf("CreatePixmap sequence %d, depth %d\n", seq, depth);
+	return p;
+}
+
+static xcb_gcontext_t create_gcontext(xcb_connection_t *c,
+				      xcb_drawable_t d,
+				      xcb_screen_t *root)
+{
+	static const uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND;
+	const uint32_t values[] = { root->black_pixel, 0xffff };
+	unsigned int seq;
+	xcb_gcontext_t gc = xcb_generate_id(c);
+	seq = xcb_create_gc(c, gc, d, mask, values).sequence;
+	printf("CreateGC sequence %d\n", seq);
+	return gc;
+}
+
+
+typedef struct {
+	char *name;
+	xcb_image_format_t format;
+	uint8_t depth;
+} format_t;
+
+static format_t formats[] = {
+	{"z-pixmap", XCB_IMAGE_FORMAT_Z_PIXMAP, 24},
+	{"xy-bitmap", XCB_IMAGE_FORMAT_XY_BITMAP, 1},
+	{"xy-pixmap-1", XCB_IMAGE_FORMAT_XY_PIXMAP, 1},
+	{"xy-pixmap-24", XCB_IMAGE_FORMAT_XY_PIXMAP, 24},
+	{0, 0, 0}
+};
+
+static format_t *
+parse_format (char *name) {
+	format_t *f;
+	for (f = formats; f->name; f++)
+		if (!strcmp(name, f->name))
+			return f;
+	fprintf(stderr, "%s: bad format: known formats are:\n", name);
+	for (f = formats; f->name; f++)
+		fprintf(stderr, "\t%s\n", f->name);
+	exit(1);
+}
+
+int main(int argc, char **argv)
+{
+	int screen, depth;
+	format_t *format = &formats[0];
+	xcb_screen_t *root;
+	xcb_visualtype_t *visual;
+	xcb_image_t *im;
+	xcb_drawable_t d, w = XCB_NONE;
+	xcb_gcontext_t dgc, wgc = 0;
+	xcb_generic_event_t *ev;
+	xcb_connection_t *c = xcb_connect(0, &screen);
+	if(!c)
+	{
+		printf("Connection failed.\n");
+		exit(1);
+	}
+	root = xcb_aux_get_screen(c, screen);
+	assert(root);
+	visual = xcb_aux_find_visual_by_id(root, root->root_visual);
+	assert(visual);
+	if(argc > 1)
+		format = parse_format(argv[1]);
+	if (root->root_depth != 24 ||
+	    visual->visual_class != XCB_VISUAL_CLASS_TRUE_COLOR)
+	{
+		printf("Only 24 bit TrueColor visuals for now\n");
+		exit(1);
+	}
+	depth = format->depth;
+
+	im = create_image(c, depth, format->format);
+	d = create_window(c, root);
+	if(format->format == XCB_IMAGE_FORMAT_XY_PIXMAP && depth == 1)
+	{
+		w = d;
+		d = create_pixmap(c, w, depth);
+	}
+	dgc = create_gcontext(c, d, root);
+	if (w)
+	    wgc = create_gcontext(c, w, root);
+	xcb_flush(c);
+
+	if(im)
+	{
+		while((ev = xcb_wait_for_event(c)))
+		{
+			if(ev->response_type == XCB_EXPOSE && ((xcb_expose_event_t *) ev)->count == 0)
+			{
+				printf("ImagePut sequence %d\n", xcb_image_put(c, d, dgc, im, 0, 0, 0).sequence);
+				if(w)
+				{
+					unsigned int seq;
+					seq = xcb_copy_plane(c, d, w, wgc,
+							     0, 0, 0, 0,
+							     WIDTH, HEIGHT, 1).sequence;
+					printf("CopyPlane sequence %d\n", seq);
+				}
+				xcb_flush(c);
+			}
+			else if(ev->response_type == 0)
+			{
+				xcb_generic_error_t *err = (xcb_generic_error_t *) ev;
+				printf("Error: %d after sequence %d\n", err->error_code, (unsigned int) err->full_sequence);
+			}
+			free(ev);
+		}
+		xcb_image_destroy(im);
+	}
+
+	xcb_disconnect(c);
+	exit(0);
+}
diff --git a/image/test_xcb_image.c b/image/test_xcb_image.c
new file mode 100644
index 0000000..56904cf
--- /dev/null
+++ b/image/test_xcb_image.c
@@ -0,0 +1,198 @@
+/* gcc -g -O2 -Wall `pkg-config --cflags --libs xcb` -o test xcb_image.o test_xcb_image.c */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <xcb/xcb.h>
+
+#include "xcb_aux.h"
+#include "xcb_image.h"
+
+#define W_W 64
+#define W_H 64
+
+void
+reflect_window (xcb_connection_t *c,
+		xcb_drawable_t win,
+		xcb_drawable_t new_win,
+		xcb_gcontext_t gc,
+		uint16_t      width,
+		uint16_t      height)
+{
+  xcb_image_t *image;
+  uint32_t    pixel1;
+  uint32_t    pixel2;
+  int32_t     left_x;
+  int32_t     right_x;
+  int32_t     y;
+  int         format;
+
+  format = XCB_IMAGE_FORMAT_Z_PIXMAP;
+
+  printf ("get_image %d %d\n", width, height);
+  image = xcb_image_get (c, win,
+			 0, 0, width, height,
+			 ~0,
+			 format);
+
+  printf ("Create image summary:\n");
+  printf (" * format................: %d\n", image->format);
+  printf (" * byte order............: %d\n", image->byte_order);
+  printf (" * bitmap order..........: %d\n", image->bit_order);
+  printf (" * bitmap pad............: %d\n", image->scanline_pad);
+  printf (" * depth.................: %d\n", image->depth);
+  printf (" * bytes/line............: %d\n", image->stride);
+  printf (" * bits/pixel (or unit)..: %d\n", image->bpp);
+
+  printf ("bpl %d %d\n", image->stride, image->height);
+
+  printf("calculating reflection -- this may take awhile...\n");
+  
+  for (left_x = 0 ; left_x < width/2 ; left_x++)
+    {
+      for (y = 0 ; y < height ; y++)
+	{
+	  pixel1 = xcb_image_get_pixel (image, left_x, y);
+	  right_x = width - left_x-1;
+	  if (left_x != right_x)
+	    {
+	      pixel2 = xcb_image_get_pixel (image, right_x, y);
+	      xcb_image_put_pixel (image, left_x, y, pixel2);
+	    }
+	  xcb_image_put_pixel (image, right_x, y, pixel1);
+	}
+    }
+
+  printf("putting image\n");
+
+  xcb_image_put (c, new_win, gc, image, 0, 0, 0);
+  image = xcb_image_get (c, new_win,
+			 0, 0, width, height,
+			 ~0,
+			 format);
+
+  printf ("done\n");
+}
+
+int
+main (int argc, char *argv[])
+{
+  xcb_connection_t   *c;
+  xcb_screen_t       *screen;
+  xcb_drawable_t      win;
+  xcb_drawable_t      new_win;
+  xcb_drawable_t      rect;
+  xcb_rectangle_t     rect_coord = { 0, 0, W_W, W_H};
+  xcb_gcontext_t      bgcolor, fgcolor;
+  xcb_point_t         points[2];
+  uint32_t           mask;
+  uint32_t           valgc[2];
+  uint32_t           valwin[3];
+  int              depth;
+  int              screen_nbr;
+  xcb_generic_event_t *e;
+  
+  /* Open the connexion to the X server and get the first screen */
+  c = xcb_connect (NULL, &screen_nbr);
+  screen = xcb_aux_get_screen (c, screen_nbr);
+  depth = xcb_aux_get_depth (c, screen);
+
+  /* Create a black graphic context for drawing in the foreground */
+  win = screen->root;
+
+  fgcolor = xcb_generate_id(c);
+  mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
+  valgc[0] = screen->black_pixel;
+  valgc[1] = 0; /* no graphics exposures */
+  xcb_create_gc(c, fgcolor, win, mask, valgc);
+
+  bgcolor = xcb_generate_id(c);
+  mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
+  valgc[0] = screen->white_pixel;
+  valgc[1] = 0; /* no graphics exposures */
+  xcb_create_gc(c, bgcolor, win, mask, valgc);
+
+  /* Ask for our window's Id */
+  win = xcb_generate_id(c);
+
+  /* Create the window */
+  mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK | XCB_CW_DONT_PROPAGATE;
+  valwin[0] = screen->white_pixel;
+  valwin[1] = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_EXPOSURE;
+  valwin[2] = XCB_EVENT_MASK_BUTTON_PRESS;
+  xcb_create_window (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   win,                      /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   W_W, W_H,                 /* width, height       */
+		   10,                       /* border_width        */
+		   XCB_WINDOW_CLASS_INPUT_OUTPUT,/* class               */
+		   screen->root_visual,      /* visual              */
+		   mask, valwin);                 /* masks, not used yet */
+
+  /* Map the window on the screen */
+  xcb_map_window (c, win);
+
+  /* Create a Pixmap that will fill the window */
+  rect = xcb_generate_id (c);
+  xcb_create_pixmap(c, depth, rect, win, W_W, W_H);
+  xcb_poly_fill_rectangle(c, rect, bgcolor, 1, &rect_coord);
+  points[0].x = 0;
+  points[0].y = 0;
+  points[1].x = W_W;
+  points[1].y = W_H;
+  xcb_poly_line(c, XCB_COORD_MODE_ORIGIN, rect, fgcolor, 2, points);
+  points[0].x = W_W / 4;
+  points[0].y = 0;
+  points[1].x = W_W / 2;
+  points[1].y = W_H / 2;
+  xcb_poly_line(c, XCB_COORD_MODE_ORIGIN, rect, fgcolor, 2, points);
+
+  /* Ask for our window's Id */
+  new_win = xcb_generate_id(c);
+
+  /* Create the window */
+  mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK | XCB_CW_DONT_PROPAGATE;
+  valwin[0] = screen->white_pixel;
+  valwin[1] = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_EXPOSURE;
+  valwin[2] = XCB_EVENT_MASK_BUTTON_PRESS;
+  xcb_create_window (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   new_win,                  /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   W_W, W_H,                 /* width, height       */
+		   10,                       /* border_width        */
+		   XCB_WINDOW_CLASS_INPUT_OUTPUT,/* class               */
+		   screen->root_visual,      /* visual              */
+		   mask, valwin);                 /* masks, not used yet */
+
+  
+
+  /* Map the window on the screen */
+  xcb_map_window (c, new_win);
+
+
+  xcb_flush (c); 
+
+  while ((e = xcb_wait_for_event(c)))
+    {
+      switch (e->response_type)
+	{ 
+	case XCB_EXPOSE:
+	  {
+	    xcb_copy_area(c, rect, win, bgcolor,
+			0, 0, 0, 0, W_W, W_H);
+	    reflect_window (c, win, new_win,
+			    fgcolor,
+			    W_W, W_H);
+	    xcb_flush (c);
+	    break;
+	  }
+	}
+      free (e);
+    }
+
+  return 1;
+}
diff --git a/image/test_xcb_image_shm.c b/image/test_xcb_image_shm.c
new file mode 100644
index 0000000..d22825c
--- /dev/null
+++ b/image/test_xcb_image_shm.c
@@ -0,0 +1,167 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+#include <xcb/xcb.h>
+#include <xcb/shm.h>
+
+#include "xcb_aux.h"
+#include "xcb_image.h"
+
+#define W_W 40
+#define W_H 40
+
+
+
+int
+main (int argc, char *argv[])
+{
+  xcb_connection_t   *c;
+  xcb_screen_t       *screen;
+  xcb_drawable_t      win;
+  xcb_drawable_t      rect;
+  xcb_rectangle_t     rect_coord = { 0, 0, W_W, W_H};
+  xcb_gcontext_t      bgcolor, fgcolor;
+  xcb_point_t         points[2];
+  uint32_t           mask;
+  uint32_t           valgc[2];
+  uint32_t           valwin[3];
+  int              depth;
+  int              screen_nbr;
+  xcb_generic_event_t *e;
+  
+  /* Open the connexion to the X server and get the first screen */
+  c = xcb_connect (NULL, &screen_nbr);
+  screen = xcb_aux_get_screen (c, screen_nbr);
+  depth = xcb_aux_get_depth (c, screen);
+
+  /* Create a black graphic context for drawing in the foreground */
+  win = screen->root;
+
+  fgcolor = xcb_generate_id(c);
+  mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
+  valgc[0] = screen->black_pixel;
+  valgc[1] = 0; /* no graphics exposures */
+  xcb_create_gc(c, fgcolor, win, mask, valgc);
+
+  bgcolor = xcb_generate_id(c);
+  mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
+  valgc[0] = screen->white_pixel;
+  valgc[1] = 0; /* no graphics exposures */
+  xcb_create_gc(c, bgcolor, win, mask, valgc);
+
+  /* Shm test */
+  printf ("shm test begin\n");
+  xcb_image_t *img = 0;
+  xcb_shm_query_version_reply_t *rep;
+  xcb_shm_segment_info_t shminfo;
+
+  rep = xcb_shm_query_version_reply (c,
+				 xcb_shm_query_version (c),
+				 NULL);
+  if (rep)
+    {
+      uint8_t format;
+      
+      if (!rep->shared_pixmaps ||
+	  rep->major_version < 1 ||
+	  (rep->major_version == 1 && rep->minor_version == 0))
+	{
+	  printf ("No or insufficient shm support...\n");
+	  exit (0);
+	}
+      format = rep->pixmap_format;
+      img = xcb_image_create_native (c, W_W, W_H, format, depth,
+				     0, ~0, 0);
+
+      if (!img)
+	{
+	  printf ("Can't create image...\n");
+	  exit (0);
+	}
+
+      printf ("Create image summary:\n");
+      printf (" * format..........: %d\n", img->format);
+      printf (" * byte order......: %d\n", img->byte_order);
+      printf (" * bitmap unit.....: %d\n", img->bpp);
+      printf (" * bitmap order....: %d\n", img->bit_order);
+      printf (" * bitmap pad......: %d\n", img->scanline_pad);
+
+      shminfo.shmid = shmget (IPC_PRIVATE, img->size, IPC_CREAT|0777);
+      shminfo.shmaddr = shmat(shminfo.shmid, 0, 0);
+      img->data = shminfo.shmaddr;
+
+      shminfo.shmseg = xcb_generate_id (c);
+      xcb_shm_attach(c, shminfo.shmseg, shminfo.shmid, 0);
+      shmctl(shminfo.shmid, IPC_RMID, 0);
+    }
+
+  /* Draw in the image */
+  printf ("put the pixel\n");
+  xcb_image_put_pixel (img, 20, 20, 65535);
+  printf ("fin put pixel\n");
+
+  /* Ask for our window's Id */
+  win = xcb_generate_id(c);
+
+  /* Create the window */
+  mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK | XCB_CW_DONT_PROPAGATE;
+  valwin[0] = screen->white_pixel;
+  valwin[1] = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_EXPOSURE;
+  valwin[2] = XCB_EVENT_MASK_BUTTON_PRESS;
+  xcb_create_window (c,                        /* Connection          */
+ 		   0,                        /* depth               */
+		   win,                      /* window Id           */
+		   screen->root,             /* parent window       */
+		   0, 0,                     /* x, y                */
+		   W_W, W_H,                 /* width, height       */
+		   10,                       /* border_width        */
+		   XCB_WINDOW_CLASS_INPUT_OUTPUT,/* class               */
+		   screen->root_visual,      /* visual              */
+		   mask, valwin);            /* masks, not used yet */
+
+  /* Map the window on the screen */
+  xcb_map_window (c, win);
+
+  /* Create a Pixmap that will fill the window */
+  rect = xcb_generate_id (c);
+  xcb_create_pixmap(c, depth, rect, win, W_W, W_H);
+  xcb_poly_fill_rectangle(c, rect, bgcolor, 1, &rect_coord);
+  points[0].x = 0;
+  points[0].y = 0;
+  points[1].x = 1;
+  points[1].y = 1;
+  xcb_poly_line(c, XCB_COORD_MODE_ORIGIN, rect, fgcolor, 2, points);
+/*   points[0].x = 10; */
+/*   points[0].y = 10; */
+/*   points[1].x = 10; */
+/*   points[1].y = 40; */
+/*   xcb_poly_line(c, XCB_COORD_MODE_ORIGIN, rect, fgcolor, 2, points); */
+
+
+  xcb_flush (c); 
+
+  while ((e = xcb_wait_for_event(c)))
+    {
+      switch (e->response_type)
+	{ 
+	case XCB_EXPOSE:
+	  {
+	    xcb_copy_area(c, rect, win, bgcolor,
+			0, 0, 0, 0, W_W, W_H);
+	    printf ("put image\n");
+	    xcb_image_shm_put (c, win, fgcolor,
+			       img, shminfo,
+			       0, 0, 0, 0, W_W,W_H,
+			       0);
+	    xcb_flush (c);
+	    break;
+	  }
+	}
+      free (e);
+    }
+
+  return 1;
+}
diff --git a/image/xcb-image.pc.in b/image/xcb-image.pc.in
new file mode 100644
index 0000000..403fdd0
--- /dev/null
+++ b/image/xcb-image.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: XCB Image library
+Description: XCB image convenience library
+Version: @PACKAGE_VERSION@
+Requires: xcb xcb-shm
+Libs: -L${libdir} -lxcb-image @LIBS@
+Cflags: -I${includedir}
diff --git a/image/xcb_image.c b/image/xcb_image.c
new file mode 100644
index 0000000..b5e78a7
--- /dev/null
+++ b/image/xcb_image.c
@@ -0,0 +1,993 @@
+/* Copyright (C) 2007 Bart Massey
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <xcb/xcb.h>
+#include <xcb/shm.h>
+#include <xcb/xcb_aux.h>
+#include "xcb_bitops.h"
+#include "xcb_image.h"
+#include "xcb_pixel.h"
+
+
+static xcb_format_t *
+find_format_by_depth (const xcb_setup_t *setup, uint8_t depth)
+{ 
+  xcb_format_t *fmt = xcb_setup_pixmap_formats(setup);
+  xcb_format_t *fmtend = fmt + xcb_setup_pixmap_formats_length(setup);
+  for(; fmt != fmtend; ++fmt)
+      if(fmt->depth == depth)
+	  return fmt;
+  return 0;
+}
+
+
+static xcb_image_format_t
+effective_format(xcb_image_format_t format, uint8_t bpp)
+{
+    if (format == XCB_IMAGE_FORMAT_Z_PIXMAP && bpp != 1)
+	    return format;
+    return XCB_IMAGE_FORMAT_XY_PIXMAP;
+}
+
+
+static int
+format_valid (uint8_t depth, uint8_t bpp, uint8_t unit,
+	      xcb_image_format_t format, uint8_t xpad)
+{
+  xcb_image_format_t  ef = effective_format(format, bpp);
+  if (depth > bpp || bpp > unit)
+      return 0;
+  switch(ef) {
+  case XCB_IMAGE_FORMAT_XY_PIXMAP:
+      switch(unit) {
+      case 8:
+      case 16:
+      case 32:
+	  break;
+      default:
+	  return 0;
+      }
+      if (xpad < bpp)
+	  return 0;
+      switch (xpad) {
+      case 8:
+      case 16:
+      case 32:
+	  break;
+      default:
+	  return 0;
+      }
+      break;
+  case XCB_IMAGE_FORMAT_Z_PIXMAP:
+      switch (bpp) {
+      case 4:
+	  if (unit != 8)
+	      return 0;
+	  break;
+      case 8:
+      case 16:
+      case 24:
+      case 32:
+	  if (unit != bpp)
+	      return 0;
+	  break;
+      default:
+	  return 0;
+      }
+      break;
+  default:
+      return 0;
+  }
+  return 1;
+}
+
+
+static int
+image_format_valid (xcb_image_t *image) {
+    return format_valid(image->depth,
+			image->bpp,
+			image->unit,
+			image->format,
+			image->scanline_pad);
+}
+
+
+void
+xcb_image_annotate (xcb_image_t *image)
+{
+  xcb_image_format_t  ef = effective_format(image->format, image->bpp);
+  switch (ef) {
+  case XCB_IMAGE_FORMAT_XY_PIXMAP:
+      image->plane_mask = xcb_mask(image->depth);
+      image->stride = xcb_roundup(image->width, image->scanline_pad) >> 3;
+      image->size = image->height * image->stride * image->depth;
+      break;
+  case XCB_IMAGE_FORMAT_Z_PIXMAP:
+      image->plane_mask = 0;
+      image->stride = xcb_roundup((uint32_t)image->width *
+				  (uint32_t)image->bpp,
+				  image->scanline_pad) >> 3;
+      image->size = image->height * image->stride;
+      break;
+  default:
+      assert(0);
+  }
+}
+
+
+xcb_image_t *
+xcb_image_create_native (xcb_connection_t *  c,
+			 uint16_t            width,
+			 uint16_t            height,
+			 xcb_image_format_t  format,
+			 uint8_t             depth,
+			 void *              base,
+			 uint32_t            bytes,
+			 uint8_t *           data)
+{
+  const xcb_setup_t *  setup = xcb_get_setup(c);
+  xcb_format_t *       fmt;
+  xcb_image_format_t   ef = format;
+  
+  if (ef == XCB_IMAGE_FORMAT_Z_PIXMAP && depth == 1)
+      ef = XCB_IMAGE_FORMAT_XY_PIXMAP;
+  switch (ef) {
+  case XCB_IMAGE_FORMAT_XY_BITMAP:
+      if (depth != 1)
+	  return 0;
+      /* fall through */
+  case XCB_IMAGE_FORMAT_XY_PIXMAP:
+      if (depth > 1) {
+	  fmt = find_format_by_depth(setup, depth);
+	  if (!fmt)
+	      return 0;
+      }
+      return xcb_image_create(width, height, format,
+			      setup->bitmap_format_scanline_pad,
+			      depth, depth, setup->bitmap_format_scanline_unit,
+			      setup->image_byte_order,
+			      setup->bitmap_format_bit_order,
+			      base, bytes, data);
+  case XCB_IMAGE_FORMAT_Z_PIXMAP:
+      fmt = find_format_by_depth(setup, depth);
+      if (!fmt)
+	  return 0;
+      return xcb_image_create(width, height, format,
+			      fmt->scanline_pad,
+			      fmt->depth, fmt->bits_per_pixel, 0,
+			      setup->image_byte_order,
+			      XCB_IMAGE_ORDER_MSB_FIRST,
+			      base, bytes, data);
+  default:
+      assert(0);
+  }
+  assert(0);
+}
+
+
+xcb_image_t *
+xcb_image_create (uint16_t           width,
+		  uint16_t           height,
+		  xcb_image_format_t format,
+		  uint8_t            xpad,
+		  uint8_t            depth,
+		  uint8_t            bpp,
+		  uint8_t            unit,
+		  xcb_image_order_t  byte_order,
+		  xcb_image_order_t  bit_order,
+		  void *             base,
+		  uint32_t           bytes,
+		  uint8_t *          data)
+{
+  xcb_image_t *  image;
+
+  if (unit == 0) {
+      switch (format) {
+      case XCB_IMAGE_FORMAT_XY_BITMAP:
+      case XCB_IMAGE_FORMAT_XY_PIXMAP:
+	  unit = 32;
+	  break;
+      case XCB_IMAGE_FORMAT_Z_PIXMAP:
+	  if (bpp == 1) {
+	      unit = 32;
+	      break;
+	  }
+	  if (bpp < 8) {
+	      unit = 8;
+	      break;
+	  }
+	  unit = bpp;
+	  break;
+      }
+  }
+  if (!format_valid(depth, bpp, unit, format, xpad))
+      return 0;
+  image = (xcb_image_t *)malloc(sizeof(*image));
+  if (image == 0)
+      return 0;
+  image->width = width;
+  image->height = height;
+  image->format = format;
+  image->scanline_pad = xpad;
+  image->depth = depth;
+  image->bpp = bpp;
+  image->unit = unit;
+  image->byte_order = byte_order;
+  image->bit_order = bit_order;
+  xcb_image_annotate(image);
+
+  /*
+   * Ways this function can be called:
+   *   * with data: we fail if bytes isn't
+   *     large enough, else leave well enough alone.
+   *   * with base and !data: if bytes is zero, we
+   *     default; otherwise we fail if bytes isn't
+   *     large enough, else fill in data
+   *   * with !base and !data: we malloc storage
+   *     for the data, save that address as the base,
+   *     and fail if malloc does.
+   *
+   * When successful, we establish the invariant that data
+   * points at sufficient storage that may have been
+   * supplied, and base is set iff it should be
+   * auto-freed when the image is destroyed.
+   * 
+   * Except as a special case when base = 0 && data == 0 &&
+   * bytes == ~0 we just return the image structure and let
+   * the caller deal with getting the allocation right.
+   */
+  if (!base && !data && bytes == ~0)
+      return image;
+  if (!base && data && bytes == 0)
+      bytes = image->size;
+  image->base = base;
+  image->data = data;
+  if (!image->data) {
+      if (image->base) {
+	  image->data = image->base;
+      } else {
+	  bytes = image->size;
+	  image->base = malloc(bytes);
+	  image->data = image->base;
+      }
+  }
+  if (!image->data || bytes < image->size) {
+      free(image);
+      return 0;
+  }
+  return image;
+}
+
+
+void
+xcb_image_destroy (xcb_image_t *image)
+{
+  if (image->base)
+      free (image->base);
+  free (image);
+}
+
+
+xcb_image_t *
+xcb_image_get (xcb_connection_t *  conn,
+	       xcb_drawable_t      draw,
+	       int16_t             x,
+	       int16_t             y,
+	       uint16_t            width,
+	       uint16_t            height,
+	       uint32_t            plane_mask,
+	       xcb_image_format_t  format)
+{
+  xcb_get_image_cookie_t   image_cookie;
+  xcb_get_image_reply_t *  imrep;
+  xcb_image_t *            image = 0;
+  uint32_t                 bytes;
+  uint8_t *                data;
+
+  image_cookie = xcb_get_image(conn, format, draw, x, y,
+			       width, height, plane_mask);
+  imrep = xcb_get_image_reply(conn, image_cookie, 0);
+  if (!imrep)
+      return 0;
+  bytes = xcb_get_image_data_length(imrep);
+  data = xcb_get_image_data(imrep);
+  switch (format) {
+  case XCB_IMAGE_FORMAT_XY_PIXMAP:
+      plane_mask &= xcb_mask(imrep->depth);
+      if (plane_mask != xcb_mask(imrep->depth)) {
+	  xcb_image_t *  tmp_image =
+	    xcb_image_create_native(conn, width, height, format,
+				    imrep->depth, 0, 0, 0);
+	  int            i;
+	  uint32_t       rpm = plane_mask;
+	  uint8_t *      src_plane = image->data;
+	  uint8_t *      dst_plane = tmp_image->data;
+	  uint32_t       size = image->height * image->stride;
+	  
+	  if (!tmp_image) {
+	      free(imrep);
+	      return 0;
+	  }
+	  if (tmp_image->bit_order == XCB_IMAGE_ORDER_MSB_FIRST)
+	      rpm = xcb_bit_reverse(plane_mask, imrep->depth);
+	  for (i = 0; i < imrep->depth; i++) {
+	      if (rpm & 1) {
+		  memcpy(dst_plane, src_plane, size);
+		  src_plane += size;
+	      } else {
+		  memset(dst_plane, 0, size);
+	      }
+	      dst_plane += size;
+	  }
+	  tmp_image->plane_mask = plane_mask;
+	  image = tmp_image;
+	  free(imrep);
+	  break;
+      }
+      /* fall through */
+  case XCB_IMAGE_FORMAT_Z_PIXMAP:
+      image = xcb_image_create_native(conn, width, height, format,
+				      imrep->depth, imrep, bytes, data);
+      if (!image)
+	  free(imrep);
+      break;
+  default:
+      assert(0);
+  }
+  assert(bytes == image->size);
+  return image;
+}
+
+
+xcb_image_t *
+xcb_image_native (xcb_connection_t *  c,
+		  xcb_image_t *       image,
+		  int                 convert)
+{
+  xcb_image_t *        tmp_image = 0;
+  const xcb_setup_t *  setup = xcb_get_setup(c);
+  xcb_format_t *       fmt = 0;
+  xcb_image_format_t   ef = effective_format(image->format, image->bpp);
+  uint8_t              bpp = 1;
+
+  if (image->depth > 1 || ef == XCB_IMAGE_FORMAT_Z_PIXMAP) {
+      fmt = find_format_by_depth(setup, image->depth);
+      /* XXX For now, we don't do depth conversions, even
+	 for xy-pixmaps */
+      if (!fmt)
+	  return 0;
+      bpp = fmt->bits_per_pixel;
+  }
+  switch (ef) {
+  case XCB_IMAGE_FORMAT_XY_PIXMAP:
+      if (setup->bitmap_format_scanline_unit != image->unit ||
+	  setup->bitmap_format_scanline_pad != image->scanline_pad ||
+	  setup->image_byte_order != image->byte_order ||
+	  setup->bitmap_format_bit_order != image->bit_order ||
+	  bpp != image->bpp) {
+	  if (!convert)
+	      return 0;
+	  tmp_image =
+	      xcb_image_create(image->width, image->height, image->format,
+			       setup->bitmap_format_scanline_pad,
+			       image->depth, bpp,
+			       setup->bitmap_format_scanline_unit,
+			       setup->image_byte_order,
+			       setup->bitmap_format_bit_order,
+			       0, 0, 0);
+	  if (!tmp_image)
+	      return 0;
+      }
+      break;
+  case XCB_IMAGE_FORMAT_Z_PIXMAP:
+      if (fmt->scanline_pad != image->scanline_pad ||
+	  setup->image_byte_order != image->byte_order ||
+	  bpp != image->bpp) {
+	  if (!convert)
+	      return 0;
+	  tmp_image =
+	      xcb_image_create(image->width, image->height, image->format,
+			       fmt->scanline_pad,
+			       image->depth, bpp, 0,
+			       setup->image_byte_order,
+			       XCB_IMAGE_ORDER_MSB_FIRST,
+			       0, 0, 0);
+	  if (!tmp_image)
+	      return 0;
+      }
+      break;
+  default:
+      assert(0);
+  }
+  if (tmp_image) {
+      if (!xcb_image_convert(image, tmp_image)) {
+	  xcb_image_destroy(tmp_image);
+	  return 0;
+      }
+      image = tmp_image;
+  }
+  return image;
+}
+
+
+xcb_void_cookie_t
+xcb_image_put (xcb_connection_t *  conn,
+	       xcb_drawable_t      draw,
+	       xcb_gcontext_t      gc,
+	       xcb_image_t *       image,
+	       int16_t             x,
+	       int16_t             y,
+	       uint8_t             left_pad)
+{
+  return xcb_put_image(conn, image->format, draw, gc,
+		       image->width, image->height,
+		       x, y, left_pad,
+		       image->depth,
+		       image->size,
+		       image->data);
+}
+
+
+
+/*
+ * Shm stuff
+ */
+
+xcb_image_t *
+xcb_image_shm_put (xcb_connection_t *      conn,
+		   xcb_drawable_t          draw,
+		   xcb_gcontext_t          gc,
+		   xcb_image_t *           image,
+		   xcb_shm_segment_info_t  shminfo,
+		   int16_t                 src_x,
+		   int16_t                 src_y,
+		   int16_t                 dest_x,
+		   int16_t                 dest_y,
+		   uint16_t                src_width,
+		   uint16_t                src_height,
+		   uint8_t                 send_event)
+{
+  if (!xcb_image_native(conn, image, 0))
+      return 0;
+  if (!shminfo.shmaddr)
+      return 0;
+  xcb_shm_put_image(conn, draw, gc,
+		    image->width, image->height,
+		    src_x, src_y, src_width, src_height,
+		    dest_x, dest_y,
+		    image->depth, image->format,
+		    send_event, 
+		    shminfo.shmseg,
+		    image->data - shminfo.shmaddr);
+  return image;
+}
+
+
+int
+xcb_image_shm_get (xcb_connection_t *      conn,
+		   xcb_drawable_t          draw,
+		   xcb_image_t *           image,
+		   xcb_shm_segment_info_t  shminfo,
+		   int16_t                 x,
+		   int16_t                 y,
+		   uint32_t                plane_mask)
+{
+  xcb_shm_get_image_reply_t *  setup;
+  xcb_shm_get_image_cookie_t   cookie;
+  xcb_generic_error_t *        err = 0;
+
+  if (!shminfo.shmaddr)
+      return 0;
+  cookie = xcb_shm_get_image(conn, draw,
+			     x, y,
+			     image->width, image->height,
+			     plane_mask,
+			     image->format,
+			     shminfo.shmseg,
+			     image->data - shminfo.shmaddr);
+  setup = xcb_shm_get_image_reply(conn, cookie, &err);
+  if (err) {
+      fprintf(stderr, "ShmGetImageReply error %d\n", (int)err->error_code);
+      free(err);
+      return 0;
+  } else {
+      free (setup);
+      return 1;
+  }
+}
+
+
+/* GetPixel/PutPixel */
+
+/* XXX this is the most hideously done cut-and-paste
+   to below.  Any bugs fixed there should be fixed here
+   and vice versa. */
+void
+xcb_image_put_pixel (xcb_image_t *image,
+		     uint32_t x,
+		     uint32_t y,
+		     uint32_t pixel)
+{
+  uint8_t *row;
+
+  if (x > image->width || y > image->height)
+      return;
+  row = image->data + (y * image->stride);
+  switch (image->format) {
+  case XCB_IMAGE_FORMAT_XY_BITMAP:
+  case XCB_IMAGE_FORMAT_XY_PIXMAP:
+      /* block */ {
+	  int  p;
+	  uint32_t   plane_mask = image->plane_mask;
+	  uint8_t *  plane = row;
+	  uint32_t   ulog = image->bpp >> 4;
+	  uint32_t   unit = (x >> 3) & ~xcb_mask(ulog);
+	  uint32_t   byte = (x >> 3) & xcb_mask(ulog);
+	  uint32_t   bit = x & 7;
+
+	  if (image->byte_order == XCB_IMAGE_ORDER_MSB_FIRST)
+	      byte = xcb_mask(ulog) - byte;
+	  if (image->bit_order == XCB_IMAGE_ORDER_MSB_FIRST) {
+	      bit = 7 - bit;
+	  } else {
+	      pixel = xcb_bit_reverse(pixel, image->bpp);
+	      plane_mask = xcb_bit_reverse(plane_mask, image->bpp);
+	  }
+	  for (p = 0; p < image->bpp; p++) {
+	      if (plane_mask & 1) {
+		  uint8_t *  bp = plane + (unit | byte);
+		  uint8_t    m = 1 << bit;
+		  uint8_t    p = (pixel & 1) << bit;
+		  *bp = (*bp & ~m) | p;
+	      }
+	      plane += image->stride * image->height;
+	      pixel >>= 1;
+	      plane_mask >>= 1;
+	  }
+      }
+      break;
+  case XCB_IMAGE_FORMAT_Z_PIXMAP:
+      switch (image->bpp) {
+      uint32_t   mask;
+      case 4:
+	  mask = 0xf;
+	  pixel &= 0xf;
+	  if ((x & 1) ==
+	      (image->byte_order == XCB_IMAGE_ORDER_MSB_FIRST)) {
+	      pixel <<= 4;
+	      mask <<= 4;
+	  }
+	  row[x >> 1] = (row[x >> 1] & ~mask) | pixel;
+	  break;
+      case 8:
+	  row[x] = pixel;
+	  break;
+      case 16:
+	  switch (image->byte_order) {
+	  case XCB_IMAGE_ORDER_LSB_FIRST:
+	      row[x << 1] = pixel;
+	      row[(x << 1) + 1] = pixel >> 8;
+	      break;
+	  case XCB_IMAGE_ORDER_MSB_FIRST:
+	      row[x << 1] = pixel >> 8;
+	      row[(x << 1) + 1] = pixel;
+	      break;
+	  }
+	  break;
+      case 24:
+	  switch (image->byte_order) {
+	  case XCB_IMAGE_ORDER_LSB_FIRST:
+	      row[x * 3] = pixel;
+	      row[x * 3 + 1] = pixel >> 8;
+	      row[x * 3 + 2] = pixel >> 16;
+	      break;
+	  case XCB_IMAGE_ORDER_MSB_FIRST:
+	      row[x * 3] = pixel >> 16;
+	      row[x * 3 + 1] = pixel >> 8;
+	      row[x * 3 + 2] = pixel;
+	      break;
+	  }
+	  break;
+      case 32:
+	  switch (image->byte_order) {
+	  case XCB_IMAGE_ORDER_LSB_FIRST:
+	      row[x << 2] = pixel;
+	      row[(x << 2) + 1] = pixel >> 8;
+	      row[(x << 2) + 2] = pixel >> 16;
+	      row[(x << 2) + 3] = pixel >> 24;
+	      break;
+	  case XCB_IMAGE_ORDER_MSB_FIRST:
+	      row[x << 2] = pixel >> 24;
+	      row[(x << 2) + 1] = pixel >> 16;
+	      row[(x << 2) + 2] = pixel >> 8;
+	      row[(x << 2) + 3] = pixel;
+	      break;
+	  }
+	  break;
+      default:
+	  assert(0);
+      }
+      break;
+  default:
+      assert(0);
+  }
+}
+
+
+/* XXX this is the most hideously done cut-and-paste
+   from above.  Any bugs fixed there should be fixed here
+   and vice versa. */
+uint32_t
+xcb_image_get_pixel (xcb_image_t *image,
+		     uint32_t x,
+		     uint32_t y)
+{
+  uint32_t pixel = 0;
+  uint8_t *row;
+
+  assert(x < image->width && y < image->height);
+  row = image->data + (y * image->stride);
+  switch (image->format) {
+  case XCB_IMAGE_FORMAT_XY_BITMAP:
+  case XCB_IMAGE_FORMAT_XY_PIXMAP:
+      /* block */ {
+	  int  p;
+	  uint32_t   plane_mask = image->plane_mask;
+	  uint8_t *  plane = row;
+	  uint32_t   ulog = image->bpp >> 4;
+	  uint32_t   unit = (x >> 3) & ~xcb_mask(ulog);
+	  uint32_t   byte = (x >> 3) & xcb_mask(ulog);
+	  uint32_t   bit = x & 7;
+
+	  if (image->byte_order == XCB_IMAGE_ORDER_MSB_FIRST)
+	      byte = xcb_mask(ulog) - byte;
+	  if (image->bit_order == XCB_IMAGE_ORDER_MSB_FIRST) {
+	      bit = 7 - bit;
+	  } else {
+	      plane_mask = xcb_bit_reverse(plane_mask, image->bpp);
+	  }
+	  for (p = 0; p < image->bpp; p++) {
+	      pixel <<= 1;
+	      if (plane_mask & 1) {
+		  uint8_t *  bp = plane + (unit | byte);
+		  pixel |= (*bp >> bit) & 1;
+	      }
+	      plane += image->stride * image->height;
+	      plane_mask >>= 1;
+	  }
+	  if (image->bit_order == XCB_IMAGE_ORDER_LSB_FIRST)
+	      pixel = xcb_bit_reverse(pixel, image->bpp);
+      }
+      return pixel;
+  case XCB_IMAGE_FORMAT_Z_PIXMAP:
+      switch (image->bpp) {
+      case 4:
+	  if ((x & 1) == (image->byte_order == XCB_IMAGE_ORDER_MSB_FIRST))
+	      return row[x >> 1] >> 4;
+	  return row[x >> 1] & 0xf;
+      case 8:
+	  return row[x];
+      case 16:
+	  switch (image->byte_order) {
+	  case XCB_IMAGE_ORDER_LSB_FIRST:
+	      pixel = row[x << 1];
+	      pixel |= row[(x << 1) + 1] << 8;
+	      break;
+	  case XCB_IMAGE_ORDER_MSB_FIRST:
+	      pixel = row[x << 1] << 8;
+	      pixel |= row[(x << 1) + 1];
+	      break;
+	  }
+	  break;
+      case 24:
+	  switch (image->byte_order) {
+	  case XCB_IMAGE_ORDER_LSB_FIRST:
+	      pixel = row[x * 3];
+	      pixel |= row[x * 3 + 1] << 8;
+	      pixel |= row[x * 3 + 2] << 16;
+	      break;
+	  case XCB_IMAGE_ORDER_MSB_FIRST:
+	      pixel = row[x * 3] << 16;
+	      pixel |= row[x * 3 + 1] << 8;
+	      pixel |= row[x * 3 + 2];
+	      break;
+	  }
+	  break;
+      case 32:
+	  switch (image->byte_order) {
+	  case XCB_IMAGE_ORDER_LSB_FIRST:
+	      pixel = row[x << 2];
+	      pixel |= row[(x << 2) + 1] << 8;
+	      pixel |= row[(x << 2) + 2] << 16;
+	      pixel |= row[(x << 2) + 3] << 24;
+	      break;
+	  case XCB_IMAGE_ORDER_MSB_FIRST:
+	      pixel = row[x << 2] << 24;
+	      pixel |= row[(x << 2) + 1] << 16;
+	      pixel |= row[(x << 2) + 2] << 8;
+	      pixel |= row[(x << 2) + 3];
+	      break;
+	  }
+	  break;
+      default:
+	  assert(0);
+      }
+      return pixel;
+  default:
+      assert(0);
+  }
+}
+
+
+/*
+ * (Adapted from libX11.)
+ *
+ * xcb_create_pixmap_from_bitmap_data: Routine to make a pixmap of
+ *      given depth from user supplied bitmap data.
+ *	D is any drawable on the same screen that the pixmap will be used in.
+ *	Data is a pointer to the bit data, and 
+ *	width & height give the size in bits of the pixmap.
+ *
+ * The following format is assumed for data:
+ *
+ *    format=XY (will use XYPixmap for depth 1 and XYBitmap for larger)
+ *    bit_order=LSBFirst
+ *    padding=8
+ *    bitmap_unit=8
+ */  
+xcb_pixmap_t
+xcb_create_pixmap_from_bitmap_data (xcb_connection_t *  display,
+				    xcb_drawable_t      d,
+				    uint8_t *           data,
+				    uint32_t            width,
+				    uint32_t            height,
+				    uint32_t            depth,
+				    uint32_t            fg,
+				    uint32_t            bg,
+				    xcb_gcontext_t *    gcp)
+{
+  xcb_pixmap_t        pix;
+  xcb_image_t *       image;
+  xcb_image_t *       final_image;
+  xcb_image_format_t  format = XCB_IMAGE_FORMAT_XY_PIXMAP;
+  xcb_gcontext_t gc;
+  uint32_t mask = 0;
+  xcb_params_gc_t gcv;
+
+  if (depth > 1)
+      format = XCB_IMAGE_FORMAT_XY_BITMAP;
+  image = xcb_image_create(width, height, format,
+			   8, 1, 1, 8,
+			   XCB_IMAGE_ORDER_LSB_FIRST,
+			   XCB_IMAGE_ORDER_LSB_FIRST,
+			   0, 0, data);
+  if (!image)
+      return 0;
+  final_image = xcb_image_native(display, image, 1);
+  if (!final_image) {
+      xcb_image_destroy(image);
+      return 0;
+  }
+  pix = xcb_generate_id(display);
+  xcb_create_pixmap(display, depth, pix, d, width, height);
+  gc = xcb_generate_id(display);
+  XCB_AUX_ADD_PARAM(&mask, &gcv, foreground, fg);
+  XCB_AUX_ADD_PARAM(&mask, &gcv, background, bg);
+  xcb_aux_create_gc(display, gc, pix, mask, &gcv);
+  xcb_image_put(display, pix, gc, final_image, 0, 0, 0);
+  if (final_image != image)
+      xcb_image_destroy(final_image);
+  xcb_image_destroy(image);
+  if (gcp)
+      *gcp = gc;
+  else
+      xcb_free_gc(display, gc);
+  return pix;
+}
+
+
+/* Thanks to Keith Packard <keithp@keithp.com> for this code */
+static void 
+swap_image(uint8_t *	     src,
+           uint32_t 	     src_stride,
+	   uint8_t *	     dst,
+	   uint32_t 	     dst_stride,
+	   uint8_t const *   byte_order,
+	   int		     unit_bytes,
+	   uint16_t 	     height,
+	   int		     bitswap,
+	   int               nibbleswap)
+{
+  while (height--) {
+      uint32_t    minor = 0;
+      uint32_t    major = 0;
+      uint32_t    s;
+
+      for (s = 0; s < src_stride; s++) {
+	  uint8_t   b;
+	  uint32_t  d = major + byte_order[minor];
+
+	  if (d > dst_stride)
+	      continue;
+
+	  b = src[s];
+	  if (bitswap)
+	      b = xcb_bit_reverse(b, 8);
+	  if (nibbleswap)
+	      b = (b << 4) | (b >> 4);
+	  dst[d] = b;
+
+	  if (++minor == unit_bytes) 
+	  {
+	      minor = 0; 
+	      major += unit_bytes;
+	  }
+      }
+      src += src_stride;
+      dst += dst_stride;
+  }
+}
+
+/* Note that all of these permutations are self-inverse.
+   Applying them twice yields the identity permutation, i.e p*p = i
+   This means that we only have to care about the
+   source and destination size and whether they mismatch, not
+   the actual endiannesses. */
+static uint8_t const forward_order[4] = {0, 1, 2, 3};
+static uint8_t const reverse_order[4] = {3, 2, 1, 0};
+static uint8_t const reverse_word_order[4] = {2, 3, 0, 1};
+
+static uint8_t const *
+conversion_byte_order(xcb_image_t *src, xcb_image_t *dst)
+{
+    uint8_t  nbytes = src->unit >> 3;
+    
+    if (src->byte_order == dst->byte_order)
+	return forward_order;
+    if (nbytes >= 1 && nbytes <= 4)
+	return &reverse_order[4 - nbytes];
+    return forward_order;
+}
+
+
+#define R1 forward_order
+#define R2 reverse_word_order
+#define R4 reverse_order
+#define W4 reverse_word_order
+
+static uint8_t const * const bbo_reverse[3][3] =
+        /* 8  16  32*/
+  /*8*/ {{R1, R2, R4},
+ /*16*/  {R2, R2, W4},
+ /*32*/  {R4, W4, R4}};
+
+static uint8_t const *
+bitmap_conversion_byte_order(xcb_image_t *src, xcb_image_t *dst)
+{
+    uint8_t  srclog = src->unit >> 4;
+    uint8_t  dstlog = dst->unit >> 4;
+    int sbo = src->byte_order;
+    int dbo = dst->byte_order;
+
+    if (srclog == 0)
+	sbo = XCB_IMAGE_ORDER_LSB_FIRST;
+    if (dstlog == 0)
+	dbo = XCB_IMAGE_ORDER_LSB_FIRST;
+    if (dbo == sbo)
+	return forward_order;
+    return bbo_reverse[srclog][dstlog];
+}
+
+
+xcb_image_t *
+xcb_image_convert (xcb_image_t *  src,
+		   xcb_image_t *  dst)
+{
+  uint32_t            x;
+  uint32_t            y;
+  int                 format_compatible = 0;
+  int                 bitmap = 0;
+  xcb_image_format_t  ef = effective_format(src->format, src->bpp);
+
+  /* Things will go horribly wrong here if a bad
+     image is passed in, so we check some things
+     up front just to be nice. */
+  assert(image_format_valid(src));
+  assert(image_format_valid(dst));
+  if (src->depth != dst->depth ||
+      src->width != dst->width ||
+      src->height != dst->height)
+      return 0;
+  switch (ef) {
+  case XCB_IMAGE_FORMAT_XY_PIXMAP:
+      bitmap = src->depth == 1;
+      format_compatible = src->format == dst->format || bitmap;
+      /* Case: Formats are identical.  Just copy. */
+      if (format_compatible &&
+	  src->bpp == dst->bpp &&
+	  src->unit == dst->unit &&
+	  src->scanline_pad == dst->scanline_pad &&
+	  src->byte_order == dst->byte_order &&
+	  src->bit_order == dst->bit_order) {
+	  memcpy(dst->data, src->data, src->size);
+	  return dst;
+      }
+      break;
+  case XCB_IMAGE_FORMAT_Z_PIXMAP:
+      format_compatible = src->format == dst->format;
+      /* Case: Formats are identical.  Just copy. */
+      if (format_compatible &&
+	  src->bpp == dst->bpp &&
+	  src->byte_order == dst->byte_order) {
+	  memcpy(dst->data, src->data, src->size);
+	  return dst;
+      }
+      break;
+  default:
+      assert(0);
+  }
+  /* Case: Bitmap scanline units are always compatible.  Copy and convert. */
+  if (bitmap) {
+      uint8_t const * const
+	       byte_order = bitmap_conversion_byte_order(src, dst);
+      int      bitswap = src->bit_order != dst->bit_order;
+      uint8_t  unit = src->unit;
+      
+      if (dst->unit < unit)
+	  unit = dst->unit;
+      swap_image(src->data, src->stride,
+		     dst->data, dst->stride,
+		     byte_order, unit >> 3,
+		     src->height, bitswap, 0);
+      return dst;
+  }
+  /* Case: Pixmap scanline units are identical.  Copy and convert. */
+  if (format_compatible && src->bpp == dst->bpp) {
+      uint8_t const * const
+	   byte_order = conversion_byte_order(src, dst);
+      int  bitswap = src->bit_order != dst->bit_order;
+      int  nibbleswap = src->byte_order != dst->byte_order &&
+                        src->bpp == 4;
+      swap_image(src->data, src->stride,
+		     dst->data, dst->stride,
+		     byte_order, src->unit >> 3,
+		     src->height, bitswap, nibbleswap);
+      return dst;
+  }
+
+  /* General case: Slow pixel copy. Should we optimize
+     Z24<->Z32 copies of either endianness? */
+  for (y = 0; y < src->height; y++) {
+      for (x = 0; x < src->width; x++) {
+	  uint32_t  pixel = xcb_image_get_pixel(src, x, y);
+	  xcb_image_put_pixel(dst, x, y, pixel);
+      }
+  }
+  return dst;
+}
diff --git a/image/xcb_image.h b/image/xcb_image.h
new file mode 100644
index 0000000..e9e427e
--- /dev/null
+++ b/image/xcb_image.h
@@ -0,0 +1,580 @@
+#ifndef __XCB_IMAGE_H__
+#define __XCB_IMAGE_H__
+
+/* Copyright (C) 2007 Bart Massey
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+#include <xcb/xcb.h>
+#include <xcb/shm.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup xcb__image_t XCB Image Functions
+ * 
+ * These are functions used to create and manipulate X images.
+ * 
+ * The X image format we use is specific to this software,
+ * which is probably a bug; it represents an intermediate
+ * position between the wire format used by the X GetImage
+ * and PutImage requests and standard formats like PBM.  An
+ * image consists of a header of type @ref xcb_image_t
+ * describing the properties of the image, together with a
+ * pointer to the image data itself.
+ * 
+ * X wire images come in three formats.  An xy-bitmap is a
+ * bit-packed format that will be expanded to a two-color
+ * pixmap using a GC when sent over the wire by PutImage.
+ * An xy-pixmap is one or more bit-planes, each in the same
+ * format as xy-bitmap.  A z-pixmap is a more conventional
+ * pixmap representation, with each pixel packed into a
+ * word.  Pixmaps are sent and received over the wire only
+ * to/from drawables of their depth.
+ * 
+ * Each X server defines, for each depth and format,
+ * properties of images in that format that are sent and
+ * received on the wire.  We refer to this as a "native"
+ * image for a given X server.  It is not uncommon to want
+ * to work with non-native images on the client side, or to
+ * convert between the native images of different servers.
+ *
+ * This library provides several things.  Facilities for
+ * creating and destroying images are, of course, provided.
+ * Wrappers for xcb_get_image() and xcb_put_image() are
+ * provided; these utilize the image header to simplify the
+ * interface.  Routines for getting and putting image pixels
+ * are provided: both a generic form that works with
+ * arbitrary images, and fastpath forms for some common
+ * cases.  Conversion routines are provided for X images;
+ * these routines have been fairly well optimized for the
+ * common cases, and should run fast even on older hardware.
+ * A routine analogous to Xlib's XCreate*FromBitmapData() is
+ * provided for creating X images from xbm-format data; this
+ * routine is in this library only because it is a trivial
+ * use case for the library.
+ * 
+ * @{
+ */
+
+
+typedef struct xcb_image_t xcb_image_t;
+
+/**
+ * @struct xcb_image_t
+ * A structure that describes an xcb_image_t.
+ */
+struct xcb_image_t
+{
+  uint16_t           width;   /**< Width in pixels, excluding pads etc. */
+  uint16_t           height;   /**< Height in pixels. */
+  xcb_image_format_t format;   /**< Format. */
+  uint8_t            scanline_pad;   /**< Right pad in bits.  Valid pads
+				      *   are 8, 16, 32.
+				      */
+  uint8_t            depth;   /**< Depth in bits. Valid depths
+			       *   are 1, 4, 8, 16, 24 for z format,
+			       *   1 for xy-bitmap-format, anything
+			       *   for xy-pixmap-format.
+			       */
+  uint8_t            bpp;   /**< Storage per pixel in bits.
+			     *   Must be >= depth. Valid bpp
+			     *   are 1, 4, 8, 16, 24, 32 for z
+			     *   format, 1 for xy-bitmap format,
+			     *   anything for xy-pixmap-format.
+			     */
+  uint8_t	     unit;  /**< Scanline unit in bits for
+			     *   xy formats and for bpp == 1,
+			     *   in which case valid scanline
+			     *   units are 8, 16, 32.  Otherwise,
+			     *   will be max(8, bpp).  Must be >= bpp.
+			     */
+  uint32_t           plane_mask;   /**< When format is
+				    *   xy-pixmap and depth >
+				    *   1, this says which
+				    *   planes are "valid" in
+				    *   some vague sense.
+				    *   Currently used only
+				    *   by xcb_image_get/put_pixel(),
+				    *   and set only by
+				    *   xcb_image_get().
+				    */
+  xcb_image_order_t  byte_order;   /**< Component byte order
+				    *   for z-pixmap, byte
+				    *   order of scanline unit
+				    *   for xy-bitmap and
+				    *   xy-pixmap.  Nybble
+				    *   order for z-pixmap
+				    *   when bpp == 4.
+				    */
+  xcb_image_order_t  bit_order;    /**< Bit order of
+				    *   scanline unit for
+				    *   xy-bitmap and
+				    *   xy-pixmap.
+				    */
+  uint32_t           stride;   /**< Bytes per image row.
+				*   Computable from other
+				*   data, but cached for
+				*   convenience/performance.
+				*/
+  uint32_t           size;   /**< Size of image data in bytes.
+			      *   Computable from other
+			      *   data, but cached for
+			      *   convenience/performance.
+			      */
+  void *             base;   /**< Malloced block of storage that
+			      *   will be freed by
+			      *   @ref xcb_image_destroy() if non-null.
+			      */
+  uint8_t *          data;   /**< The actual image. */
+};
+
+typedef struct xcb_shm_segment_info_t xcb_shm_segment_info_t;
+
+/**
+ * @struct xcb_shm_segment_info_t
+ * A structure that stores the informations needed by the MIT Shm
+ * Extension.
+ */
+struct xcb_shm_segment_info_t
+{
+  xcb_shm_seg_t shmseg;
+  uint32_t    shmid;
+  uint8_t     *shmaddr;
+};
+
+
+/**
+ * Update the cached data of an image.
+ * @param image The image.
+ *
+ * An image's size and stride, among other things, are
+ * cached in its structure.  This function recomputes those
+ * cached values for the given image.
+ * @ingroup xcb__image_t
+ */
+void
+xcb_image_annotate (xcb_image_t *image);
+
+/**
+ * Create a new image.
+ * @param width The width of the image, in pixels.
+ * @param height The height of the image, in pixels.
+ * @param format The format of the image.
+ * @param xpad The scanline pad of the image.
+ * @param depth The depth of the image.
+ * @param bpp The depth of the image storage.
+ * @param unit The unit of image representation, in bits.
+ * @param byte_order The byte order of the image.
+ * @param bit_order The bit order of the image.
+ * @param base The base address of malloced image data.
+ * @param bytes The size in bytes of the storage pointed to by base.
+ *              If base == 0 and bytes == ~0 and data == 0 on
+ *              entry, no storage will be auto-allocated.
+ * @param data The image data.  If data is null and bytes != ~0, then
+ *             an attempt will be made to fill in data; from
+ *             base if it is non-null (and bytes is large enough), else
+ *             by mallocing sufficient storage and filling in base.
+ * @return The new image.
+ *
+ * This function allocates the memory needed for an @ref xcb_image_t structure
+ * with the given properties.  See the description of xcb_image_t for details.
+ * This function initializes and returns a pointer to the
+ * xcb_image_t structure.  It may try to allocate or reserve data for the
+ * structure, depending on how @p base, @p bytes and @p data are set.
+ *
+ * The image must be destroyed with xcb_image_destroy().
+ * @ingroup xcb__image_t
+ */
+xcb_image_t *
+xcb_image_create (uint16_t           width,
+		  uint16_t           height,
+		  xcb_image_format_t format,
+		  uint8_t            xpad,
+		  uint8_t            depth,
+		  uint8_t            bpp,
+		  uint8_t            unit,
+		  xcb_image_order_t  byte_order,
+		  xcb_image_order_t  bit_order,
+		  void *             base,
+		  uint32_t           bytes,
+		  uint8_t *          data);
+
+
+/**
+ * Create a new image in connection-native format.
+ * @param c The connection.
+ * @param width The width of the image, in pixels.
+ * @param height The height of the image, in pixels.
+ * @param format The format of the image.
+ * @param depth The depth of the image.
+ * @param base The base address of malloced image data.
+ * @param bytes The size in bytes of the storage pointed to by base.
+ *              If base == 0 and bytes == ~0 and data == 0 on
+ *              entry, no storage will be auto-allocated.
+ * @param data The image data.  If data is null and bytes != ~0, then
+ *             an attempt will be made to fill in data; from
+ *             base if it is non-null (and bytes is large enough), else
+ *             by mallocing sufficient storage and filling in base.
+ * @return The new image.
+ *
+ * This function calls @ref xcb_image_create() with the given
+ * properties, and with the remaining properties chosen
+ * according to the "native format" with the given
+ * properties on the current connection.
+ *
+ * It is usual to use this rather
+ * than calling xcb_image_create() directly.
+ * @ingroup xcb__image_t
+ */
+xcb_image_t *
+xcb_image_create_native (xcb_connection_t *  c,
+			 uint16_t            width,
+			 uint16_t            height,
+			 xcb_image_format_t  format,
+			 uint8_t             depth,
+			 void *              base,
+			 uint32_t            bytes,
+			 uint8_t *           data);
+
+
+/**
+ * Destroy an image.
+ * @param image The image to be destroyed.
+ *
+ * This function frees the memory associated with the @p image
+ * parameter.  If its base pointer is non-null, it frees
+ * that also.
+ * @ingroup xcb__image_t
+ */
+void
+xcb_image_destroy (xcb_image_t *image);
+
+
+/**
+ * Get an image from the X server.
+ * @param conn The connection to the X server.
+ * @param draw The drawable to get the image from.
+ * @param x The x coordinate in pixels, relative to the origin of the
+ * drawable and defining the upper-left corner of the rectangle.
+ * @param y The y coordinate in pixels, relative to the origin of the
+ * drawable and defining the upper-left corner of the rectangle.
+ * @param width The width of the subimage in pixels.
+ * @param height The height of the subimage in pixels.
+ * @param plane_mask The plane mask.  See the protocol document for details.
+ * @param format The format of the image.
+ * @return The subimage of @p draw defined by @p x, @p y, @p w, @p h.
+ *
+
+ * This function returns a new image taken from the
+ * given drawable @p draw.
+ * The image will be in connection native format. If the @p format
+ * is xy-bitmap and the @p plane_mask masks bit planes out, those
+ * bit planes will be made part of the returned image anyway,
+ * by zero-filling them; this will require a fresh memory allocation
+ * and some copying.  Otherwise, the resulting image will use the
+ * xcb_get_image_reply() record as its backing store.
+ *
+ * If a problem occurs, the function returns null.
+ * @ingroup xcb__image_t
+ */
+xcb_image_t *
+xcb_image_get (xcb_connection_t *  conn,
+	       xcb_drawable_t      draw,
+	       int16_t             x,
+	       int16_t             y,
+	       uint16_t            width,
+	       uint16_t            height,
+	       uint32_t            plane_mask,
+	       xcb_image_format_t  format);
+
+
+/**
+ * Put an image onto the X server.
+ * @param conn The connection to the X server.
+ * @param draw The draw you get the image from.
+ * @param gc The graphic context.
+ * @param image The image you want to combine with the rectangle.
+ * @param x The x coordinate, which is relative to the origin of the
+ * drawable and defines the x coordinate of the upper-left corner of the
+ * rectangle.
+ * @param y The y coordinate, which is relative to the origin of the
+ * drawable and defines the x coordinate of the upper-left corner of
+ * the rectangle.
+ * @param left_pad Notionally shift an xy-bitmap or xy-pixmap image
+ * to the right some small amount, for some reason.  XXX Not clear
+ * this is currently supported correctly.
+ * @return The cookie returned by xcb_put_image().
+ *
+ * This function combines an image with a rectangle of the
+ * specified drawable @p draw. The image must be in native
+ * format for the connection.  The image is drawn at the
+ * specified location in the drawable. For the xy-bitmap
+ * format, the foreground pixel in @p gc defines the source
+ * for the one bits in the image, and the background pixel
+ * defines the source for the zero bits. For xy-pixmap and
+ * z-pixmap formats, the depth of the image must match the
+ * depth of the drawable; the gc is ignored.
+ *
+ * @ingroup xcb__image_t
+ */
+xcb_void_cookie_t
+xcb_image_put (xcb_connection_t *  conn,
+	       xcb_drawable_t      draw,
+	       xcb_gcontext_t      gc,
+	       xcb_image_t *       image,
+	       int16_t             x,
+	       int16_t             y,
+	       uint8_t             left_pad);
+
+
+/**
+ * Check image for or convert image to native format.
+ * @param c The connection to the X server.
+ * @param image The image.
+ * @param convert  If 0, just check the image for native format.
+ * Otherwise, actually convert it.
+ * @return Null if the image is not in native format and can or will not
+ * be converted.  Otherwise, the native format image.
+ *
+ * Each X display has its own "native format" for images of a given
+ * format and depth.  This function either checks whether the given
+ * @p image is in native format for the given connection @p c, or
+ * actually tries to convert the image to native format, depending
+ * on whether @p convert is true or false.
+ *
+ * When @p convert is true, and the image is not in native format
+ * but can be converted, it will be, and a pointer to the new image
+ * will be returned.  The image passed in will be unharmed in this
+ * case; it is the caller's responsibility to check that the returned
+ * pointer is different and to dispose of the old image if desired.
+ * @ingroup xcb__image_t
+ */
+xcb_image_t *
+xcb_image_native (xcb_connection_t *  c,
+		  xcb_image_t *       image,
+		  int                 convert);
+
+
+/**
+ * Put a pixel to an image.
+ * @param image The image.
+ * @param x The x coordinate of the pixel.
+ * @param y The y coordinate of the pixel.
+ * @param pixel The new pixel value.
+ *
+ * This function overwrites the pixel in the given @p image with the
+ * specified @p pixel value (in client format). The image must contain the @p x
+ * and @p y coordinates, as no clipping is done.  This function honors
+ * the plane-mask for xy-pixmap images.
+ * @ingroup xcb__image_t
+ */
+void
+xcb_image_put_pixel (xcb_image_t *image,
+		     uint32_t x,
+		     uint32_t y,
+		     uint32_t pixel);
+
+/**
+ * Get a pixel from an image.
+ * @param image The image.
+ * @param x The x coordinate of the pixel.
+ * @param y The y coordinate of the pixel.
+ * @return The pixel value.
+ *
+ * This function retrieves a pixel from the given @p image.
+ * The image must contain the @p x
+ * and @p y coordinates, as no clipping is done.  This function honors
+ * the plane-mask for xy-pixmap images.
+ * @ingroup xcb__image_t
+ */
+uint32_t
+xcb_image_get_pixel (xcb_image_t *image,
+		     uint32_t x,
+		     uint32_t y);
+
+
+/**
+ * Convert an image to a new format.
+ * @param src Source image.
+ * @param dst Destination image.
+ * @return The @p dst image, or null on error.
+ *
+ * This function tries to convert the image data of the @p
+ * src image to the format implied by the @p dst image,
+ * overwriting the current destination image data.
+ * The source and destination must have the same
+ * width, height, and depth.  When the source and destination
+ * are already the same format, a simple copy is done.  Otherwise,
+ * when the destination has the same bits-per-pixel/scanline-unit
+ * as the source, an optimized copy routine (thanks to Keith Packard)
+ * is used for the conversion.  Otherwise, the copy is done the
+ * slow, slow way with xcb_get_pixel() and xcb_put_pixel() calls.
+ * @ingroup xcb__image_t
+ */
+xcb_image_t *
+xcb_image_convert (xcb_image_t *  src,
+		   xcb_image_t *  dst);
+
+
+/*
+ * Shm stuff
+ */
+
+/**
+ * Put the data of an xcb_image_t onto a drawable using the MIT Shm
+ * Extension.
+ * @param conn The connection to the X server.
+ * @param draw The draw you get the image from.
+ * @param gc The graphic context.
+ * @param image The image you want to combine with the rectangle.
+ * @param shminfo A @ref xcb_shm_segment_info_t structure.
+ * @param src_x The offset in x from the left edge of the image
+ * defined by the xcb_image_t structure.
+ * @param src_y The offset in y from the left edge of the image
+ * defined by the xcb_image_t structure.
+ * @param dest_x The x coordinate, which is relative to the origin of the
+ * drawable and defines the x coordinate of the upper-left corner of the
+ * rectangle.
+ * @param dest_y The y coordinate, which is relative to the origin of the
+ * drawable and defines the x coordinate of the upper-left corner of
+ * the rectangle.
+ * @param src_width The width of the subimage, in pixels.
+ * @param src_height The height of the subimage, in pixels.
+ * @param send_event Indicates whether or not a completion event
+ * should occur when the image write is complete.
+ * @return 1 is no problems occurs.
+ *
+ * This function combines an image in memory with a shape of the
+ * specified drawable. The section of the image defined by the @p x, @p y,
+ * @p width, and @p height arguments is drawn on the specified part of
+ * the drawable. If XYBitmap format is used, the depth must be
+ * one, or a``BadMatch'' error results. The foreground pixel in the
+ * Graphic Context @p gc defines the source for the one bits in the
+ * image, and the background pixel defines the source for the zero
+ * bits. For XYPixmap and ZPixmap, the depth must match the depth of
+ * the drawable, or a ``BadMatch'' error results.
+ *
+ * If a problem occurs, the functons returns @c 0. Otherwise, it
+ * returns @c 1.
+ * @ingroup xcb__image_t
+ */
+xcb_image_t *
+xcb_image_shm_put (xcb_connection_t *      conn,
+		   xcb_drawable_t          draw,
+		   xcb_gcontext_t          gc,
+		   xcb_image_t *           image,
+		   xcb_shm_segment_info_t  shminfo,
+		   int16_t                 src_x,
+		   int16_t                 src_y,
+		   int16_t                 dest_x,
+		   int16_t                 dest_y,
+		   uint16_t                src_width,
+		   uint16_t                src_height,
+		   uint8_t                 send_event);
+
+
+/**
+ * Read image data into a shared memory xcb_image_t.
+ * @param conn The connection to the X server.
+ * @param draw The draw you get the image from.
+ * @param image The image you want to combine with the rectangle.
+ * @param shminfo A @ref xcb_shm_segment_info_t structure.
+ * @param x The x coordinate, which are relative to the origin of the
+ * drawable and define the upper-left corner of the rectangle.
+ * @param y The y coordinate, which are relative to the origin of the
+ * drawable and define the upper-left corner of the rectangle.
+ * @param plane_mask The plane mask.
+ * @return The subimage of @p draw defined by @p x, @p y, @p w, @p h.
+ *
+ * This function reads image data into a shared memory xcb_image_t where
+ * @p conn is the connection to the X server, @p draw is the source
+ * drawable, @p image is the destination xcb_image_t, @p x and @p y are offsets
+ * within the drawable, and @p plane_mask defines which planes are to be
+ * read.
+ *
+ * If a problem occurs, the functons returns @c 0. It returns 1
+ * otherwise.
+ * @ingroup xcb__image_t
+ */
+int xcb_image_shm_get (xcb_connection_t *      conn,
+		       xcb_drawable_t          draw,
+		       xcb_image_t *           image,
+		       xcb_shm_segment_info_t  shminfo,
+		       int16_t                 x,
+		       int16_t                 y,
+		       uint32_t                plane_mask);
+
+
+/**
+ * Create a pixmap from user-supplied bitmap data.
+ * @param display The connection to the X server.
+ * @param d The parent drawable for the pixmap.
+ * @param data Image data in packed bitmap format.
+ * @param width Width in bits of image data.
+ * @param height Height in bits of image data.
+ * @param depth Depth of the desired pixmap.
+ * @param fg Pixel for one-bits of pixmaps with depth larger than one.
+ * @param bg Pixel for zero-bits of pixmaps with depth larger than one.
+ * @param gcp If this pointer is non-null, the GC created to
+ * fill in the pixmap is stored here; it will have its foreground
+ * and background set to the supplied value.  Otherwise, the GC
+ * will be freed.
+ * @return The pixmap constructed from the image data, or 0 on error.
+ *
+ * This function creates a pixmap from the user-supplied
+ * bitmap @p data.  The bitmap data is assumed to be in
+ * xbm format (i.e., 8-bit scanline unit, LSB-first, 8-bit pad).
+ * If @p depth is greater than 1, the
+ * bitmap will be expanded to a pixmap using the given
+ * foreground and background pixels @p fg and @p bg.
+ * @ingroup xcb__image_t
+ */
+xcb_pixmap_t
+xcb_create_pixmap_from_bitmap_data (xcb_connection_t *  display,
+				    xcb_drawable_t      d,
+				    uint8_t *           data,
+				    uint32_t            width,
+				    uint32_t            height,
+				    uint32_t            depth,
+				    uint32_t            fg,
+				    uint32_t            bg,
+				    xcb_gcontext_t *    gcp);
+
+
+/**
+ * @}
+ */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __XCB_IMAGE_H__ */
diff --git a/image/xcb_pixel.h b/image/xcb_pixel.h
new file mode 100644
index 0000000..d7d5382
--- /dev/null
+++ b/image/xcb_pixel.h
@@ -0,0 +1,169 @@
+#ifndef __XCB_PIXEL_H__
+#define __XCB_PIXEL_H__
+
+/* Copyright (C) 2007 Bart Massey
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+#include <inttypes.h>
+#include <X11/Xfuncproto.h>
+#include <xcb/xcb_bitops.h>
+#include <xcb/xcb_image.h>
+
+/**
+ * XCB Image fast pixel ops.
+ *
+ * Fast inline versions of xcb_image_get_pixel() and
+ * xcb_image_put_pixel() for various common cases.
+ * The naming convention is xcb_image_put_pixel_FUB()
+ * where F is the format and is either XY for bitmaps
+ * or Z for pixmaps, U is the bitmap unit size or pixmap
+ * bits-per-pixel, and B is the endianness (if needed)
+ * and is either M for most-significant-first or L for
+ * least-significant-first.  Note that no checking
+ * is done on the arguments to these routines---caller beware.
+ * Also note that the pixel type is chosen to be appropriate
+ * to the unit; bitmaps use int and pixmaps use the appropriate
+ * size of unsigned.
+ * @ingroup xcb__image_t
+ */
+
+_X_INLINE static void
+xcb_image_put_pixel_XY32M (xcb_image_t *image,
+			  uint32_t x,
+			  uint32_t y,
+			  int pixel)
+{
+  uint32_t   unit = (x >> 3) & ~xcb_mask(2);
+  uint32_t   byte = xcb_mask(2) - ((x >> 3) & xcb_mask(2));
+  uint32_t   bit = xcb_mask(3) - (x & xcb_mask(3));
+  uint8_t    m = 1 << bit;
+  uint8_t    p = pixel << bit;
+  uint8_t *  bp = image->data + (y * image->stride) + (unit | byte);
+  *bp = (*bp & ~m) | p;
+}
+
+_X_INLINE static void
+xcb_image_put_pixel_XY32L (xcb_image_t *image,
+			  uint32_t x,
+			  uint32_t y,
+			  int pixel)
+{
+  uint32_t   bit = x & xcb_mask(3);
+  uint8_t    m = 1 << bit;
+  uint8_t    p = pixel << bit;
+  uint8_t *  bp = image->data + (y * image->stride) + (x >> 3);
+  *bp = (*bp & ~m) | p;
+}
+
+_X_INLINE static int
+xcb_image_get_pixel_XY32M (xcb_image_t *image,
+			  uint32_t x,
+			  uint32_t y)
+{
+  uint32_t   unit = (x >> 3) & ~xcb_mask(2);
+  uint32_t   byte = xcb_mask(2) - ((x >> 3) & xcb_mask(2));
+  uint32_t   bit = xcb_mask(3) - (x & xcb_mask(3));
+  uint8_t *  bp = image->data + (y * image->stride) + (unit | byte);
+  return (*bp >> bit) & 1;
+}
+
+_X_INLINE static int
+xcb_image_get_pixel_XY32L (xcb_image_t *image,
+			  uint32_t x,
+			  uint32_t y)
+{
+  uint32_t   bit = x & xcb_mask(3);
+  uint8_t *  bp = image->data + (y * image->stride) + (x >> 3);
+  return (*bp >> bit) & 1;
+}
+
+_X_INLINE static void
+xcb_image_put_pixel_Z8 (xcb_image_t *image,
+			uint32_t x,
+			uint32_t y,
+			uint8_t pixel)
+{
+  image->data[x + y * image->stride] = pixel;
+}
+
+_X_INLINE static uint8_t
+xcb_image_get_pixel_Z8 (xcb_image_t *image,
+			uint32_t x,
+			uint32_t y)
+{
+  return image->data[x + y * image->stride];
+}
+
+_X_INLINE static void
+xcb_image_put_pixel_Z32M (xcb_image_t *image,
+			  uint32_t x,
+			  uint32_t y,
+			  uint32_t pixel)
+{
+  uint8_t *  row = image->data + (y * image->stride);
+  row[x << 2] = pixel >> 24;
+  row[(x << 2) + 1] = pixel >> 16;
+  row[(x << 2) + 2] = pixel >> 8;
+  row[(x << 2) + 3] = pixel;
+}
+
+_X_INLINE static void
+xcb_image_put_pixel_Z32L (xcb_image_t *image,
+			  uint32_t x,
+			  uint32_t y,
+			  uint32_t pixel)
+{
+  uint8_t *  row = image->data + (y * image->stride);
+  row[x << 2] = pixel;
+  row[(x << 2) + 1] = pixel >> 8;
+  row[(x << 2) + 2] = pixel >> 16;
+  row[(x << 2) + 3] = pixel >> 24;
+}
+
+_X_INLINE static uint32_t
+xcb_image_get_pixel_Z32M (xcb_image_t *image,
+			  uint32_t x,
+			  uint32_t y)
+{
+  uint8_t *  row = image->data + (y * image->stride);
+  uint32_t    pixel = row[x << 2] << 24;
+  pixel |= row[(x << 2) + 1] << 16;
+  pixel |= row[(x << 2) + 2] << 8;
+  return pixel | row[(x << 2) + 3];
+}
+
+_X_INLINE static uint32_t
+xcb_image_get_pixel_Z32L (xcb_image_t *image,
+			  uint32_t x,
+			  uint32_t y)
+{
+  uint8_t *  row = image->data + (y * image->stride);
+  uint32_t    pixel = row[x << 2];
+  pixel |= row[(x << 2) + 1] << 8;
+  pixel |= row[(x << 2) + 2] << 16;
+  return pixel | row[(x << 2) + 3] << 24;
+}
+
+#endif /* __XCB_PIXEL_H__ */