aboutsummaryrefslogtreecommitdiff
path: root/nxcompext/Mask.c
diff options
context:
space:
mode:
Diffstat (limited to 'nxcompext/Mask.c')
-rw-r--r--nxcompext/Mask.c794
1 files changed, 794 insertions, 0 deletions
diff --git a/nxcompext/Mask.c b/nxcompext/Mask.c
new file mode 100644
index 000000000..b04989d44
--- /dev/null
+++ b/nxcompext/Mask.c
@@ -0,0 +1,794 @@
+/**************************************************************************/
+/* */
+/* Copyright (c) 2001, 2007 NoMachine, http://www.nomachine.com/. */
+/* */
+/* NXCOMPEXT, NX protocol compression and NX extensions to this software */
+/* are copyright of NoMachine. Redistribution and use of the present */
+/* software is allowed according to terms specified in the file LICENSE */
+/* which comes in the source distribution. */
+/* */
+/* Check http://www.nomachine.com/licensing.html for applicability. */
+/* */
+/* NX and NoMachine are trademarks of NoMachine S.r.l. */
+/* */
+/* All rigths reserved. */
+/* */
+/**************************************************************************/
+
+#include <stdio.h>
+
+#include "Xlib.h"
+
+#include "NXpack.h"
+
+#include "Mask.h"
+
+#define PANIC
+#define WARNING
+#undef TEST
+#undef DEBUG
+
+/*
+ * Try first to reduce to a white or black
+ * pixel. If not possible, apply the mask.
+ * Note that correction is applied at the
+ * time pixel is unpacked.
+ */
+
+#define MaskPixel(red, green, blue, mask) \
+\
+if (red > mask -> white_threshold && \
+ green > mask -> white_threshold && \
+ blue > mask -> white_threshold) \
+{ \
+ red = green = blue = 0xff; \
+} \
+else if (red < mask -> black_threshold && \
+ green < mask -> black_threshold && \
+ blue < mask -> black_threshold) \
+{ \
+ red = green = blue = 0x00; \
+} \
+else \
+{ \
+ red = red & mask -> color_mask; \
+ green = green & mask -> color_mask; \
+ blue = blue & mask -> color_mask; \
+}
+
+int MaskImage(const ColorMask *mask, XImage *src_image, XImage *dst_image)
+{
+ unsigned long pixel;
+
+ register unsigned int red;
+ register unsigned int green;
+ register unsigned int blue;
+
+ register unsigned long data_size;
+
+ register unsigned int i;
+
+ data_size = (src_image -> bytes_per_line * src_image -> height) >> 2;
+
+ #ifdef TEST
+ fprintf(stderr, "******MaskImage: Going to mask image with [%d] bits per pixel.\n",
+ src_image -> bits_per_pixel);
+ #endif
+
+ if (src_image -> bits_per_pixel == 24 || src_image -> bits_per_pixel == 32)
+ {
+ register unsigned char *pixel_addr;
+
+ for (i = 0; i < data_size; i++)
+ {
+ pixel = ((unsigned long *) src_image -> data)[i];
+
+ pixel_addr = (unsigned char *) &pixel;
+
+ red = pixel_addr[2];
+ green = pixel_addr[1];
+ blue = pixel_addr[0];
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskImage: 24/32 bits original R [%d] G [%d] B [%d] A [%d].\n",
+ red, green, blue, pixel_addr[3]);
+ #endif
+
+ MaskPixel(red, green, blue, mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskImage: 24/32 bits masked R [%d] G [%d] B [%d] A [%d].\n",
+ red, green, blue, pixel_addr[3]);
+ #endif
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskImage: 24/32 bits pixel 0x%lx", pixel);
+ #endif
+
+ pixel_addr[2] = red;
+ pixel_addr[1] = green;
+ pixel_addr[0] = blue;
+
+ ((unsigned long*)dst_image -> data)[i] = pixel;
+
+ #ifdef DEBUG
+ fprintf(stderr, " -> 0x%lx\n", pixel);
+ #endif
+ }
+
+ return 1;
+ }
+ else if (src_image -> bits_per_pixel == 16)
+ {
+ /*
+ * FIXME: Masking doesn't work in 16 bpp.
+ *
+
+ unsigned long src_addr, *dst_addr;
+ unsigned short *src_pixels_addr, *dst_pixels_addr;
+
+ for (i = 0; i < data_size; i++)
+ {
+ src_addr = ((unsigned long *)src_image -> data)[i];
+ dst_addr = (unsigned long *)((unsigned long *)dst_image -> data + i);
+
+ src_pixels_addr = ((unsigned short *) &src_addr);
+ dst_pixels_addr = ((unsigned short *) dst_addr);
+
+ red = (src_pixels_addr[0] & src_image -> red_mask) >> 8;
+ green = (src_pixels_addr[0] & src_image -> green_mask) >> 3;
+ blue = (src_pixels_addr[0] & src_image -> blue_mask) << 3;
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskImage: 16 bits original R [%d] G [%d] B [%d].\n",
+ red, green, blue);
+ #endif
+
+ MaskPixel(red, green, blue, mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskImage: 16 bits masked R [%d] G [%d] B [%d].\n",
+ red, green, blue);
+ #endif
+
+ dst_pixels_addr[0] = ((red << 8) & src_image -> red_mask) |
+ ((green << 3) & src_image -> green_mask) |
+ ((blue >> 3) & src_image -> blue_mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskImage: 16 bits pixel 0x%x", dst_pixels_addr[0]);
+ #endif
+
+ red = (src_pixels_addr[1] & src_image -> red_mask) >> 8;
+ green = (src_pixels_addr[1] & src_image -> green_mask) >> 3;
+ blue = (src_pixels_addr[1] & src_image -> blue_mask) << 3;
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskImage: 16 bits original R [%d] G [%d] B [%d].\n",
+ red, green, blue);
+ #endif
+
+ MaskPixel(red, green, blue, mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskImage: 16 bits masked R [%d] G [%d] B [%d].\n",
+ red, green, blue);
+ #endif
+
+ dst_pixels_addr[1] = ((red << 8) & src_image -> red_mask) |
+ ((green << 3) & src_image -> green_mask) |
+ ((blue >> 3) & src_image -> blue_mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskImage: 16 bits pixel 0x%x", dst_pixels_addr[0]);
+ #endif
+ }
+
+ if (dst_image -> width & 0x00000001)
+ {
+ int card32_per_line;
+ int i;
+
+ card32_per_line = dst_image -> bytes_per_line >> 2;
+
+ for (i = 0; i < dst_image -> height;)
+ {
+ ((CARD32 *) dst_image -> data)[(++i * card32_per_line) - 1] &= 0x0000ffff;
+ }
+ }
+
+ *
+ * End of FIXME.
+ */
+ }
+ else
+ {
+ #ifdef TEST
+ fprintf(stderr, "******MaskImage: PANIC! Cannot apply mask with [%d] bits per pixel.\n",
+ src_image -> bits_per_pixel);
+ #endif
+
+ return 0;
+ }
+
+ return 1;
+}
+
+int MaskInPlaceImage(const ColorMask *mask, XImage *image)
+{
+ unsigned long pixel;
+
+ register unsigned int red;
+ register unsigned int green;
+ register unsigned int blue;
+
+ register unsigned int i;
+
+ register unsigned long data_size;
+
+ data_size = (image -> bytes_per_line * image -> height)>>2;
+
+ #ifdef TEST
+ fprintf(stderr, "******MaskInPlaceImage: Going to mask image with [%d] bits per pixel.\n",
+ image -> bits_per_pixel);
+ #endif
+
+ if (image -> bits_per_pixel == 24 || image -> bits_per_pixel == 32)
+ {
+ register unsigned char *pixel_addr;
+
+ for (i = 0; i < data_size; i++)
+ {
+ pixel = ((unsigned long *) image -> data)[i];
+
+ pixel_addr = (unsigned char *) &pixel;
+
+ red = pixel_addr[2];
+ green = pixel_addr[1];
+ blue = pixel_addr[0];
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskInPlaceImage: 24/32 bits original R [%d] G [%d] B [%d] A [%d].\n",
+ red, green, blue, pixel_addr[3]);
+ #endif
+
+ MaskPixel(red, green, blue, mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskInPlaceImage: 24/32 bits masked R [%d] G [%d] B [%d] A [%d].\n",
+ red, green, blue, pixel_addr[3]);
+ #endif
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskInPlaceImage: 24/32 bits pixel 0x%lx", pixel);
+ #endif
+
+ pixel_addr[2] = red;
+ pixel_addr[1] = green;
+ pixel_addr[0] = blue;
+
+ ((unsigned long *) image -> data)[i] = pixel;
+
+ #ifdef DEBUG
+ fprintf(stderr, " -> 0x%lx\n", pixel);
+ #endif
+ }
+
+ return 1;
+ }
+ else if (image -> bits_per_pixel == 16)
+ {
+ /*
+ * FIXME: Mask doesn't still work for 16 bits.
+ *
+
+ unsigned long addr;
+ register unsigned short *pixels_addr;
+
+ for (i = 0; i < data_size; i++)
+ {
+ addr = ((unsigned long *) image -> data)[i];
+
+ pixels_addr = ((unsigned short *) &addr);
+
+ red = (pixels_addr[0] & image -> red_mask) >> 8;
+ green = (pixels_addr[0] & image -> green_mask) >> 3;
+ blue = (pixels_addr[0] & image -> blue_mask) << 3;
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskInPlaceImage: 16 bits original R [%d] G [%d] B [%d].\n",
+ red, green, blue);
+ #endif
+
+ MaskPixel(red, green, blue, mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskInPlaceImage: 16 bits masked R [%d] G [%d] B [%d].\n",
+ red, green, blue);
+ #endif
+
+ pixels_addr[0] = ((red << 8) & image -> red_mask) |
+ ((green << 3) & image -> green_mask) |
+ ((blue >> 3) & image -> blue_mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskInPlaceImage: 16 bits pixel 0x%x", pixels_addr[0]);
+ #endif
+
+ red = (pixels_addr[1] & image -> red_mask) >> 8;
+ green = (pixels_addr[1] & image -> green_mask) >> 3;
+ blue = (pixels_addr[1] & image -> blue_mask) << 3;
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskInPlaceImage: 16 bits original R [%d] G [%d] B [%d].\n",
+ red, green, blue);
+ #endif
+
+ MaskPixel(red, green, blue, mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskInPlaceImage: 16 bits masked R [%d] G [%d] B [%d].\n",
+ red, green, blue);
+ #endif
+
+ pixels_addr[1] = ((red << 8) & image -> red_mask) |
+ ((green << 3) & image -> green_mask) |
+ ((blue >> 3) & image -> blue_mask);
+
+ #ifdef DEBUG
+ fprintf(stderr, "******MaskInPlaceImage: 16 bits pixel 0x%x", pixels_addr[1]);
+ #endif
+ }
+
+ if (image -> width & 0x00000001)
+ {
+ int card32_per_line;
+ int i;
+
+ card32_per_line = image -> bytes_per_line >> 2;
+
+ for (i = 0; i < image -> height;)
+ {
+ ((CARD32 *) image -> data)[(++i * card32_per_line) - 1] &= 0x0000ffff;
+ }
+ }
+
+ *
+ * End of FIXME.
+ */
+ }
+ else
+ {
+ #ifdef TEST
+ fprintf(stderr, "******MaskImage: PANIC! Cannot apply mask with [%d] bits per pixel.\n",
+ image -> bits_per_pixel);
+ #endif
+
+ return 0;
+ }
+
+ return 1;
+}
+
+static int Pack16To8(unsigned int src_data_size, XImage *src_image, XImage *dst_image)
+{
+ unsigned short *src_pixel = (unsigned short *) src_image -> data;
+ unsigned char *dst_pixel = (unsigned char *) dst_image -> data;
+
+ #ifdef DEBUG
+ unsigned int counter = 0;
+ #endif
+
+ while (src_pixel < ((unsigned short *) (src_image -> data + src_data_size)))
+ {
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] value [0x%x] red [0x%x] green [0x%x] blue [0x%x].\n",
+ counter, *src_pixel, (*src_pixel & 0xc000) >> 8,
+ ((*src_pixel & 0x600) >> 3), (*src_pixel & 0x18) << 3);
+ #endif
+
+ if (*src_pixel == 0x0)
+ {
+ *dst_pixel = 0x0;
+ }
+ else if (*src_pixel == 0xffff)
+ {
+ *dst_pixel = 0xff;
+ }
+ else
+ {
+ *dst_pixel = ((*src_pixel & 0xc000) >> 10) |
+ ((*src_pixel & 0x600) >> 7) |
+ ((*src_pixel & 0x18) >> 3);
+ }
+
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] destination [0x%x].\n",
+ counter++, *dst_pixel);
+ #endif
+
+ src_pixel++;
+ dst_pixel++;
+ }
+
+ return 1;
+}
+
+static int Pack24To8(unsigned int src_data_size, XImage *src_image, XImage *dst_image)
+{
+ unsigned char *src_pixel = (unsigned char *) src_image -> data;
+ unsigned char *dst_pixel = (unsigned char *) dst_image -> data;
+
+ int i;
+
+ unsigned int bytes_per_line = src_image -> bytes_per_line;
+
+ unsigned char *end_of_line = (unsigned char *) (src_pixel + bytes_per_line);
+
+
+ #ifdef DEBUG
+ unsigned int counter = 0;
+ #endif
+
+ for (i = 0; i < src_image -> height; i++ )
+ {
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] value [0x%x%x%x] red [0x%x] green [0x%x] blue [0x%x].\n",
+ counter, src_pixel[0], src_pixel[1], src_pixel[2], src_pixel[0] & 0xc0,
+ src_pixel[1] & 0xc0, src_pixel[2] & 0xc0);
+ #endif
+
+ while(src_pixel < end_of_line - 2)
+ {
+ if (src_pixel[0] == 0x00 &&
+ src_pixel[1] == 0x00 &&
+ src_pixel[2] == 0x00)
+ {
+ *dst_pixel = 0x0;
+ }
+ else if (src_pixel[0] == 0xff &&
+ src_pixel[1] == 0xff &&
+ src_pixel[2] == 0xff)
+ {
+ *dst_pixel = 0xff;
+ }
+ else
+ {
+ /*
+ * Pixel layout:
+ *
+ * 24 bit RRRRR000 GGGGG000 BBBBB000 -> 8 bit 00RRGGBB
+ */
+
+ *dst_pixel = (src_pixel[0] & 0xc0) >> 2 |
+ ((src_pixel[1] & 0xc0) >> 4) |
+ ((src_pixel[2] & 0xc0) >> 6);
+ }
+
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] destination [0x%x].\n",
+ counter++, *dst_pixel);
+ #endif
+
+ src_pixel += 3;
+ dst_pixel += 1;
+ }
+
+ src_pixel = end_of_line;
+ end_of_line += bytes_per_line;
+ }
+
+ return 1;
+}
+
+static int Pack24To16(unsigned int src_data_size, XImage *src_image, XImage *dst_image)
+{
+ unsigned char *src_pixel = (unsigned char *) src_image -> data;
+ unsigned short *dst_pixel = (unsigned short *) dst_image -> data;
+
+ int i;
+
+ unsigned int bytes_per_line = src_image -> bytes_per_line;
+
+ unsigned char *end_of_line = (unsigned char *) (src_pixel + bytes_per_line);
+
+ #ifdef DEBUG
+ unsigned int counter = 0;
+ #endif
+
+ for (i = 0; i < src_image -> height; i++ )
+ {
+ while(src_pixel < end_of_line - 2)
+ {
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] value [0x%x%x%x] red [0x%x] green [0x%x] blue [0x%x].\n",
+ counter, src_pixel[0], src_pixel[1], src_pixel[2], src_pixel[0] & 0xf8,
+ src_pixel[1] & 0xf8, src_pixel[2] & 0xf8);
+ #endif
+
+ if (src_pixel[0] == 0x00 &&
+ src_pixel[1] == 0x00 &&
+ src_pixel[2] == 0x00)
+ {
+ *dst_pixel = 0x0;
+ }
+ else if (src_pixel[0] == 0xff &&
+ src_pixel[1] == 0xff &&
+ src_pixel[2] == 0xff)
+ {
+ *dst_pixel = 0xffff;
+ }
+ else
+ {
+ /*
+ * Pixel layout:
+ *
+ * 24 bit RRRRR000 GGGGG000 BBBBB000 -> 16 bit 0RRRRRGG GGGBBBBB
+ */
+
+ *dst_pixel = ((src_pixel[0] & 0xf8) << 7) |
+ ((src_pixel[1] & 0xf8) << 2) |
+ ((src_pixel[2] & 0xf8) >> 3);
+ }
+
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] destination [0x%x].\n",
+ counter++, *dst_pixel);
+ #endif
+
+ src_pixel += 3;
+ dst_pixel += 1;
+ }
+
+ src_pixel = end_of_line;
+ end_of_line += bytes_per_line;
+ }
+
+ return 1;
+}
+
+static int Pack32To8(unsigned int src_data_size, XImage *src_image, XImage *dst_image)
+{
+ unsigned int *src_pixel = (unsigned int *) src_image -> data;
+ unsigned char *dst_pixel = (unsigned char *) dst_image -> data;
+
+ #ifdef DEBUG
+ unsigned int counter = 0;
+ #endif
+
+ while (src_pixel < ((unsigned int *) (src_image -> data + src_data_size)))
+ {
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] value [0x%x] red [0x%x] green [0x%x] blue [0x%x].\n",
+ counter, *src_pixel, (*src_pixel & 0xc00000),
+ (*src_pixel & 0xc000), (*src_pixel & 0xc0));
+ #endif
+
+ if (*src_pixel == 0x0)
+ {
+ *dst_pixel = 0x0;
+ }
+ else if (*src_pixel == 0xffffff)
+ {
+ *dst_pixel = 0xff;
+ }
+ else
+ {
+ *dst_pixel = ((*src_pixel & 0xc00000) >> 18) |
+ ((*src_pixel & 0xc000) >> 12) |
+ ((*src_pixel & 0xc0) >> 6);
+ }
+
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] destination [0x%x].\n",
+ counter++, *dst_pixel);
+ #endif
+
+ src_pixel++;
+ dst_pixel++;
+ }
+
+ return 1;
+}
+
+static int Pack32To16(unsigned int src_data_size, XImage *src_image, XImage *dst_image)
+{
+ unsigned int *src_pixel = (unsigned int *) src_image -> data;
+ unsigned short *dst_pixel = (unsigned short *) dst_image -> data;
+
+ #ifdef DEBUG
+ unsigned int counter = 0;
+ #endif
+
+ while (src_pixel < ((unsigned int *) (src_image -> data + src_data_size)))
+ {
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] value [0x%x] red [0x%x] green [0x%x] blue [0x%x].\n",
+ counter, *src_pixel, (*src_pixel & 0xf80000),
+ (*src_pixel & 0xf800), (*src_pixel & 0xf8));
+ #endif
+
+ if (*src_pixel == 0x0)
+ {
+ *dst_pixel = 0x0;
+ }
+ else if (*src_pixel == 0xffffff)
+ {
+ *dst_pixel = 0xffff;
+ }
+ else
+ {
+ *dst_pixel = ((*src_pixel & 0xf80000) >> 9) |
+ ((*src_pixel & 0xf800) >> 6) |
+ ((*src_pixel & 0xf8) >> 3);
+ }
+
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] destination [0x%x].\n",
+ counter++, *dst_pixel);
+ #endif
+
+ src_pixel++;
+ dst_pixel++;
+ }
+
+ return 1;
+}
+
+static int Pack32To24(unsigned int src_data_size, XImage *src_image, XImage *dst_image)
+{
+ unsigned int *src_pixel = (unsigned int *) src_image -> data;
+ unsigned char *dst_pixel = (unsigned char *) dst_image -> data;
+
+ #ifdef DEBUG
+ unsigned int counter = 0;
+ #endif
+
+ while (src_pixel < ((unsigned int *) (src_image -> data + src_data_size)))
+ {
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] value [0x%x] red [0x%x] green [0x%x] blue [0x%x].\n",
+ counter, *src_pixel, ((*src_pixel & 0xff0000) >> 16),
+ ((*src_pixel & 0x00ff00) >> 8), (*src_pixel & 0xff));
+ #endif
+
+ if (*src_pixel == 0x0)
+ {
+ dst_pixel[0] = dst_pixel[1] = dst_pixel[2] = 0x0;
+ }
+ else if (*src_pixel == 0xffffff)
+ {
+ dst_pixel[0] = dst_pixel[1] = dst_pixel[2] = 0xff;
+ }
+ else
+ {
+ dst_pixel[0] = (*src_pixel & 0xff0000) >> 16;
+ dst_pixel[1] = (*src_pixel & 0x00ff00) >> 8;
+ dst_pixel[2] = (*src_pixel & 0x0000ff);
+ }
+
+ #ifdef DEBUG
+ fprintf(stderr, "******PackImage: Pixel [%d] destination [0x%x], [0x%x], [0x%x].\n",
+ counter++, dst_pixel[0], dst_pixel[1], dst_pixel[2]);
+ #endif
+
+ src_pixel += 1;
+ dst_pixel += 3;
+ }
+
+ return 1;
+}
+
+int PackImage(unsigned int method, unsigned int src_data_size, XImage *src_image,
+ unsigned int dst_data_size, XImage *dst_image)
+{
+ unsigned int src_bits_per_pixel;
+ unsigned int dst_bits_per_pixel;
+
+ src_bits_per_pixel = src_image -> bits_per_pixel;
+ dst_bits_per_pixel = MethodBitsPerPixel(method);
+
+ #ifdef TEST
+ fprintf(stderr, "******PackImage: Source bits per pixel [%d], destination bits per pixel [%d].\n",
+ src_bits_per_pixel, dst_bits_per_pixel);
+
+ fprintf(stderr, "******PackImage: Source data size [%d], destination data size [%d].\n",
+ src_data_size, dst_data_size);
+ #endif
+
+ if (dst_bits_per_pixel >= src_bits_per_pixel)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "******PackImage: PANIC! Cannot pack image from [%d] to [%d] bytes per pixel.\n",
+ src_bits_per_pixel, dst_bits_per_pixel);
+ #endif
+
+ return 0;
+ }
+
+ switch (src_bits_per_pixel)
+ {
+ case 16:
+ {
+ switch (dst_bits_per_pixel)
+ {
+ case 8:
+ {
+ return Pack16To8(src_data_size, src_image, dst_image);
+ }
+ default:
+ {
+ return 0;
+ }
+ }
+ }
+ case 24:
+ {
+ switch (dst_bits_per_pixel)
+ {
+ case 8:
+ {
+ return Pack24To8(src_data_size, src_image, dst_image);
+ }
+ case 16:
+ {
+ return Pack24To16(src_data_size, src_image, dst_image);
+ }
+ default:
+ {
+ return 0;
+ }
+ }
+ }
+ case 32:
+ {
+ switch (dst_bits_per_pixel)
+ {
+ case 8:
+ {
+ return Pack32To8(src_data_size, src_image, dst_image);
+ }
+ case 16:
+ {
+ return Pack32To16(src_data_size, src_image, dst_image);
+ }
+ case 24:
+ {
+ return Pack32To24(src_data_size, src_image, dst_image);
+ }
+ default:
+ {
+ return 0;
+ }
+ }
+ }
+ default:
+ {
+ return 0;
+ }
+ }
+}
+
+/*
+ * Replace the ffs() call that may be not
+ * present on some systems.
+ */
+
+int FindLSB(int word)
+{
+ int t = word;
+
+ int m = 1;
+ int i = 0;
+
+ for (; i < sizeof(word) << 3; i++, m <<= 1)
+ {
+ if (t & m)
+ {
+ return i + 1;
+ }
+ }
+
+ return 0;
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-03 22:33:15 +0000