summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/xcb/xcb-util-image/xcb_image.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/3rdparty/xcb/xcb-util-image/xcb_image.c')
-rw-r--r--src/3rdparty/xcb/xcb-util-image/xcb_image.c1011
1 files changed, 1011 insertions, 0 deletions
diff --git a/src/3rdparty/xcb/xcb-util-image/xcb_image.c b/src/3rdparty/xcb/xcb-util-image/xcb_image.c
new file mode 100644
index 0000000000..e426cbd00c
--- /dev/null
+++ b/src/3rdparty/xcb/xcb-util-image/xcb_image.c
@@ -0,0 +1,1011 @@
+/* Copyright © 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"
+#define BUILD
+#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)
+ 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->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->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 = 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->plane_mask = xcb_mask(depth);
+ 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) {
+ image->base = 0;
+ image->data = 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);
+
+ if (!tmp_image) {
+ free(imrep);
+ return 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->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);
+ return 0;
+ }
+ 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;
+ }
+}
+
+
+static uint32_t
+xy_image_byte (xcb_image_t *image, uint32_t x)
+{
+ x >>= 3;
+ if (image->byte_order == image->bit_order)
+ return x;
+ switch (image->unit) {
+ default:
+ case 8:
+ return x;
+ case 16:
+ return x ^ 1;
+ case 32:
+ return x ^ 3;
+ }
+}
+
+static uint32_t
+xy_image_bit (xcb_image_t *image, uint32_t x)
+{
+ x &= 7;
+ if (image->bit_order == XCB_IMAGE_ORDER_MSB_FIRST)
+ x = 7 - x;
+ return x;
+}
+
+/* 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 (effective_format(image->format, image->bpp)) {
+ 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 byte = xy_image_byte(image, x);
+ uint32_t bit = xy_image_bit(image,x);
+ uint8_t mask = 1 << bit;
+
+ for (p = image->bpp - 1; p >= 0; p--) {
+ if ((plane_mask >> p) & 1) {
+ uint8_t * bp = plane + byte;
+ uint8_t this_bit = ((pixel >> p) & 1) << bit;
+ *bp = (*bp & ~mask) | this_bit;
+ }
+ plane += image->stride * image->height;
+ }
+ }
+ 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 (effective_format(image->format, image->bpp)) {
+ 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 byte = xy_image_byte(image, x);
+ uint32_t bit = xy_image_bit(image,x);
+
+ for (p = image->bpp - 1; p >= 0; p--) {
+ pixel <<= 1;
+ if ((plane_mask >> p) & 1) {
+ uint8_t * bp = plane + byte;
+ pixel |= (*bp >> bit) & 1;
+ }
+ plane += image->stride * image->height;
+ }
+ }
+ 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);
+ }
+}
+
+
+xcb_image_t *
+xcb_image_create_from_bitmap_data (uint8_t * data,
+ uint32_t width,
+ uint32_t height)
+{
+ return xcb_image_create(width, height, XCB_IMAGE_FORMAT_XY_PIXMAP,
+ 8, 1, 1, 8,
+ XCB_IMAGE_ORDER_LSB_FIRST,
+ XCB_IMAGE_ORDER_LSB_FIRST,
+ 0, 0, data);
+}
+
+
+/*
+ * (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_gcontext_t gc;
+ uint32_t mask = 0;
+ xcb_params_gc_t gcv;
+
+ image = xcb_image_create_from_bitmap_data(data, width, height);
+ if (!image)
+ return 0;
+ if (depth > 1)
+ image->format = XCB_IMAGE_FORMAT_XY_BITMAP;
+ 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,
+ uint32_t height,
+ uint32_t byteswap,
+ int bitswap,
+ int nibbleswap)
+{
+ while (height--) {
+ uint32_t s;
+
+ for (s = 0; s < src_stride; s++) {
+ uint8_t b;
+ uint32_t d = s ^ byteswap;
+
+ 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;
+ }
+ src += src_stride;
+ dst += dst_stride;
+ }
+}
+
+/* Which order are bytes in (low two bits), given
+ * code which accesses an image one byte at a time
+ */
+static uint32_t
+byte_order(xcb_image_t *i)
+{
+ uint32_t flip = i->byte_order == XCB_IMAGE_ORDER_MSB_FIRST;
+
+ switch (i->bpp) {
+ default:
+ case 8:
+ return 0;
+ case 16:
+ return flip;
+ case 32:
+ return flip | (flip << 1);
+ }
+}
+
+static uint32_t
+bit_order(xcb_image_t *i)
+{
+ uint32_t flip = i->byte_order != i->bit_order;
+
+ switch (i->unit) {
+ default:
+ case 8:
+ return 0;
+ case 16:
+ return flip;
+ case 32:
+ return flip | (flip << 1);
+ }
+}
+
+/* Convert from one byte order to another by flipping the
+ * low two bits of the byte index along a scanline
+ */
+static uint32_t
+conversion_byte_swap(xcb_image_t *src, xcb_image_t *dst)
+{
+ xcb_image_format_t ef = effective_format(src->format, src->bpp);
+
+ /* src_ef == dst_ef in all callers of this function */
+ if (ef == XCB_IMAGE_FORMAT_XY_PIXMAP) {
+ return bit_order(src) ^ bit_order(dst);
+ } else {
+ /* src_bpp == dst_bpp in all callers of this function */
+ return byte_order(src) ^ byte_order(dst);
+ }
+}
+
+xcb_image_t *
+xcb_image_convert (xcb_image_t * src,
+ xcb_image_t * dst)
+{
+ 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));
+
+ /* images must be the same size
+ * (yes, we could copy a sub-set)
+ */
+ if (src->width != dst->width ||
+ src->height != dst->height)
+ return 0;
+
+ if (ef == effective_format(dst->format, dst->bpp) &&
+ src->bpp == dst->bpp)
+ {
+ if (src->unit == dst->unit &&
+ src->scanline_pad == dst->scanline_pad &&
+ src->byte_order == dst->byte_order &&
+ (ef == XCB_IMAGE_FORMAT_Z_PIXMAP ||
+ src->bit_order == dst->bit_order)) {
+ memcpy(dst->data, src->data, src->size);
+ } else {
+ int bitswap = 0;
+ int nibbleswap = 0;
+ uint32_t byteswap = conversion_byte_swap(src, dst);
+ uint32_t height = src->height;;
+
+ if (ef == XCB_IMAGE_FORMAT_Z_PIXMAP) {
+ if (src->bpp == 4 && src->byte_order != dst->byte_order)
+ nibbleswap = 1;
+ } else {
+ if (src->bit_order != dst->bit_order)
+ bitswap = 1;
+ height *= src->depth;
+ }
+ swap_image (src->data, src->stride, dst->data, dst->stride,
+ height, byteswap, bitswap, nibbleswap);
+ }
+ }
+ else
+ {
+ uint32_t x;
+ uint32_t y;
+ /* 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;
+}
+
+xcb_image_t *
+xcb_image_subimage(xcb_image_t * image,
+ uint32_t x,
+ uint32_t y,
+ uint32_t width,
+ uint32_t height,
+ void * base,
+ uint32_t bytes,
+ uint8_t * data)
+{
+ int i, j;
+ xcb_image_t * result;
+
+ if (x + width > image->width)
+ return 0;
+ if (y + height > image->height)
+ return 0;
+ result = xcb_image_create(width, height, image->format,
+ image->scanline_pad, image->depth,
+ image->bpp, image->unit, image->byte_order,
+ image->bit_order,
+ base, bytes, data);
+ if (!result)
+ return 0;
+ /* XXX FIXME For now, lose on performance. Sorry. */
+ for (j = 0; j < height; j++) {
+ for (i = 0; i < width; i++) {
+ uint32_t pixel = xcb_image_get_pixel(image, x + i, y + j);
+ xcb_image_put_pixel(result, i, j, pixel);
+ }
+ }
+ return result;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-27 15:10:04 +0000