summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorBart Massey <bart@cs.pdx.edu>2007-12-07 00:44:11 -0800
committerBart Massey <bart@cs.pdx.edu>2007-12-07 00:44:11 -0800
commit4eca47fa04ee3c50667d94994902c176b27bdbd8 (patch)
tree2a83915a4a243d3c62db88c4202a5dbd0013d0c8
parent4bda072a8f824914f97306da0993c9b5cbef1ffc (diff)
...and in with the new image library
-rw-r--r--image/.gitignore5
-rw-r--r--image/Makefile.am37
-rw-r--r--image/test_bitmap.c110
-rw-r--r--image/test_formats.c174
-rw-r--r--image/test_xcb_image.c198
-rw-r--r--image/test_xcb_image_shm.c167
-rw-r--r--image/xcb-image.pc.in11
-rw-r--r--image/xcb_image.c993
-rw-r--r--image/xcb_image.h580
-rw-r--r--image/xcb_pixel.h169
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__ */