diff options
author | Bart Massey <bart@cs.pdx.edu> | 2007-12-07 00:44:11 -0800 |
---|---|---|
committer | Bart Massey <bart@cs.pdx.edu> | 2007-12-07 00:44:11 -0800 |
commit | 4eca47fa04ee3c50667d94994902c176b27bdbd8 (patch) | |
tree | 2a83915a4a243d3c62db88c4202a5dbd0013d0c8 | |
parent | 4bda072a8f824914f97306da0993c9b5cbef1ffc (diff) |
...and in with the new image library
-rw-r--r-- | image/.gitignore | 5 | ||||
-rw-r--r-- | image/Makefile.am | 37 | ||||
-rw-r--r-- | image/test_bitmap.c | 110 | ||||
-rw-r--r-- | image/test_formats.c | 174 | ||||
-rw-r--r-- | image/test_xcb_image.c | 198 | ||||
-rw-r--r-- | image/test_xcb_image_shm.c | 167 | ||||
-rw-r--r-- | image/xcb-image.pc.in | 11 | ||||
-rw-r--r-- | image/xcb_image.c | 993 | ||||
-rw-r--r-- | image/xcb_image.h | 580 | ||||
-rw-r--r-- | image/xcb_pixel.h | 169 |
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__ */ |