From 9e0e44d9596ef874ec5d1e1bd749748c3a9e93f0 Mon Sep 17 00:00:00 2001 From: Holger Schemel Date: Tue, 10 Nov 1998 09:07:25 +0100 Subject: [PATCH] rnd-19981110-1 --- src/Makefile | 2 - src/image.c | 102 ++++++ src/image.h | 5 + src/new.c | 100 ------ src/send.c | 890 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/xli.h | 153 +++++++++ 6 files changed, 1150 insertions(+), 102 deletions(-) create mode 100644 src/send.c create mode 100644 src/xli.h diff --git a/src/Makefile b/src/Makefile index ca65fea5..9cc555fc 100644 --- a/src/Makefile +++ b/src/Makefile @@ -95,7 +95,6 @@ SRCS = main.c \ gifload.c \ gif.c \ image.c \ - new.c \ network.c \ netserv.c @@ -117,7 +116,6 @@ OBJS = main.o \ gifload.o \ gif.o \ image.o \ - new.o \ network.o \ netserv.o diff --git a/src/image.c b/src/image.c index f72ea230..d75de855 100644 --- a/src/image.c +++ b/src/image.c @@ -862,3 +862,105 @@ void freeXImage(Image *image, XImageInfo *ximageinfo) free((byte *)ximageinfo); /* should we free private color map to ??? */ } + + + +/* this table is useful for quick conversions between depth and ncolors + */ + +unsigned long DepthToColorsTable[] = +{ + /* 0 */ 1, + /* 1 */ 2, + /* 2 */ 4, + /* 3 */ 8, + /* 4 */ 16, + /* 5 */ 32, + /* 6 */ 64, + /* 7 */ 128, + /* 8 */ 256, + /* 9 */ 512, + /* 10 */ 1024, + /* 11 */ 2048, + /* 12 */ 4096, + /* 13 */ 8192, + /* 14 */ 16384, + /* 15 */ 32768, + /* 16 */ 65536, + /* 17 */ 131072, + /* 18 */ 262144, + /* 19 */ 524288, + /* 20 */ 1048576, + /* 21 */ 2097152, + /* 22 */ 4194304, + /* 23 */ 8388608, + /* 24 */ 16777216 +}; + +void newRGBMapData(RGBMap *rgb, unsigned int size) +{ + rgb->used = 0; + rgb->size = size; + rgb->compressed = FALSE; + rgb->red = (Intensity *)checked_malloc(sizeof(Intensity) * size); + rgb->green = (Intensity *)checked_malloc(sizeof(Intensity) * size); + rgb->blue = (Intensity *)checked_malloc(sizeof(Intensity) * size); +} + +void freeRGBMapData(RGBMap *rgb) +{ + free((byte *)rgb->red); + free((byte *)rgb->green); + free((byte *)rgb->blue); +} + +Image *newBitImage(unsigned int width, unsigned int height) +{ + Image *image; + unsigned int linelen; + + image = (Image *)checked_malloc(sizeof(Image)); + image->type = IBITMAP; + newRGBMapData(&(image->rgb), (unsigned int)2); + *(image->rgb.red)= *(image->rgb.green) = *(image->rgb.blue)= 65535; + *(image->rgb.red + 1)= *(image->rgb.green + 1) = *(image->rgb.blue + 1)= 0; + image->rgb.used = 2; + image->width = width; + image->height = height; + image->depth = 1; + linelen = ((width + 7) / 8); + image->data = (unsigned char *)checked_calloc(linelen * height); + return(image); +} + +Image *newRGBImage(unsigned int width, unsigned int height, unsigned int depth) +{ + Image *image; + unsigned int pixlen, numcolors; + + if (depth == 0) /* special case for `zero' depth image, which is */ + depth = 1; /* sometimes interpreted as `one color' */ + pixlen = ((depth+7) / 8); + numcolors = depthToColors(depth); + image = (Image *)checked_malloc(sizeof(Image)); + image->type = IRGB; + newRGBMapData(&(image->rgb), numcolors); + image->width = width; + image->height = height; + image->depth = depth; + image->pixlen = pixlen; + image->data = (unsigned char *)checked_malloc(width * height * pixlen); + return(image); +} + +void freeImageData(Image *image) +{ + freeRGBMapData(&(image->rgb)); + free(image->data); +} + +void freeImage(Image *image) +{ + freeImageData(image); + free((byte *)image); +} diff --git a/src/image.h b/src/image.h index b6c6dfbd..e1160c18 100644 --- a/src/image.h +++ b/src/image.h @@ -108,3 +108,8 @@ Image *monochrome(); Image *zoom(); void compress(); + +Pixmap XImage_to_Pixmap(Display *, Window, XImageInfo *); +XImageInfo *Image_to_XImage(Display *, int, Visual *, unsigned int, Image *); +void XImage_to_Drawable(XImageInfo *, int, int, int, int, + unsigned int, unsigned int); diff --git a/src/new.c b/src/new.c index d1744d5e..95926b37 100644 --- a/src/new.c +++ b/src/new.c @@ -3,103 +3,3 @@ #include "image.h" #include "misc.h" - -/* this table is useful for quick conversions between depth and ncolors - */ - -unsigned long DepthToColorsTable[] = -{ - /* 0 */ 1, - /* 1 */ 2, - /* 2 */ 4, - /* 3 */ 8, - /* 4 */ 16, - /* 5 */ 32, - /* 6 */ 64, - /* 7 */ 128, - /* 8 */ 256, - /* 9 */ 512, - /* 10 */ 1024, - /* 11 */ 2048, - /* 12 */ 4096, - /* 13 */ 8192, - /* 14 */ 16384, - /* 15 */ 32768, - /* 16 */ 65536, - /* 17 */ 131072, - /* 18 */ 262144, - /* 19 */ 524288, - /* 20 */ 1048576, - /* 21 */ 2097152, - /* 22 */ 4194304, - /* 23 */ 8388608, - /* 24 */ 16777216 -}; - -void newRGBMapData(RGBMap *rgb, unsigned int size) -{ - rgb->used = 0; - rgb->size = size; - rgb->compressed = FALSE; - rgb->red = (Intensity *)checked_malloc(sizeof(Intensity) * size); - rgb->green = (Intensity *)checked_malloc(sizeof(Intensity) * size); - rgb->blue = (Intensity *)checked_malloc(sizeof(Intensity) * size); -} - -void freeRGBMapData(RGBMap *rgb) -{ - free((byte *)rgb->red); - free((byte *)rgb->green); - free((byte *)rgb->blue); -} - -Image *newBitImage(unsigned int width, unsigned int height) -{ - Image *image; - unsigned int linelen; - - image = (Image *)checked_malloc(sizeof(Image)); - image->type = IBITMAP; - newRGBMapData(&(image->rgb), (unsigned int)2); - *(image->rgb.red)= *(image->rgb.green) = *(image->rgb.blue)= 65535; - *(image->rgb.red + 1)= *(image->rgb.green + 1) = *(image->rgb.blue + 1)= 0; - image->rgb.used = 2; - image->width = width; - image->height = height; - image->depth = 1; - linelen = ((width + 7) / 8); - image->data = (unsigned char *)checked_calloc(linelen * height); - return(image); -} - -Image *newRGBImage(unsigned int width, unsigned int height, unsigned int depth) -{ - Image *image; - unsigned int pixlen, numcolors; - - if (depth == 0) /* special case for `zero' depth image, which is */ - depth = 1; /* sometimes interpreted as `one color' */ - pixlen = ((depth+7) / 8); - numcolors = depthToColors(depth); - image = (Image *)checked_malloc(sizeof(Image)); - image->type = IRGB; - newRGBMapData(&(image->rgb), numcolors); - image->width = width; - image->height = height; - image->depth = depth; - image->pixlen = pixlen; - image->data = (unsigned char *)checked_malloc(width * height * pixlen); - return(image); -} - -void freeImageData(Image *image) -{ - freeRGBMapData(&(image->rgb)); - free(image->data); -} - -void freeImage(Image *image) -{ - freeImageData(image); - free((byte *)image); -} diff --git a/src/send.c b/src/send.c new file mode 100644 index 00000000..f0aeee1a --- /dev/null +++ b/src/send.c @@ -0,0 +1,890 @@ + +/* send.c */ + +#include "xli.h" + +/* extra colors to try allocating in private color maps to minimise flashing */ +#define NOFLASH_COLORS 256 + +Image *monochrome(Image *cimage) +{ + Image *image; + unsigned char *sp, *dp, *dp2; /* data pointers */ + unsigned int spl; /* source pixel length in bytes */ + unsigned int dll; /* destination line length in bytes */ + Pixel color; /* pixel color */ + unsigned int x, y; /* random counters */ + int bitmap_pixel; + + if (BITMAPP(cimage)) + return(NULL); + + /* + printf(" Converting to monochrome..."); + fflush(stdout); + */ + + image= newBitImage(cimage->width, cimage->height); + if (cimage->title) + { + image->title= (char *)lmalloc(strlen(cimage->title) + 13); + sprintf(image->title, "%s (monochrome)", cimage->title); + } + + spl = cimage->pixlen; + dll = (image->width / 8) + (image->width % 8 ? 1 : 0); + + sp = cimage->data; + dp = image->data; + + for (y= 0; y < cimage->height; y++) + { + for (x= 0; x < cimage->width; x++) + { + dp2 = dp + (x / 8); /* dp + x/8 */ + color= memToVal(sp, spl); + + if (cimage->rgb.red[color] > 0x0000 || + cimage->rgb.green[color] > 0x0000 || + cimage->rgb.blue[color] > 0x0000) + bitmap_pixel = 0x00; + else + bitmap_pixel = 0x80; + + *dp2 |= bitmap_pixel >> ( x % 8); + sp += spl; + } + + dp += dll; /* next row */ + } + + /* + printf("done\n"); + */ + + return(image); +} + +static unsigned int *buildIndex(unsigned int width, + unsigned int zoom, + unsigned int *rwidth) +{ + float fzoom; + unsigned int *index; + unsigned int a; + + if (!zoom) + { + fzoom= 100.0; + *rwidth= width; + } + else + { + fzoom= (float)zoom / 100.0; + *rwidth= (unsigned int)(fzoom * width + 0.5); + } + index= (unsigned int *)lmalloc(sizeof(unsigned int) * *rwidth); + for (a= 0; a < *rwidth; a++) + { + if (zoom) + *(index + a)= (unsigned int)((float)a / fzoom + 0.5); + else + *(index + a)= a; + } + return(index); +} + +Image *zoom(Image *oimage, unsigned int xzoom, unsigned int yzoom) +{ + Image *image; + unsigned int *xindex, *yindex; + unsigned int xwidth, ywidth; + unsigned int x, y, xsrc, ysrc; + unsigned int pixlen; + unsigned int srclinelen; + unsigned int destlinelen; + byte *srcline, *srcptr; + byte *destline, *destptr; + byte srcmask, destmask, bit; + Pixel value; + + if ((!xzoom || xzoom==100) && (!yzoom || yzoom==100)) + return(oimage); + + if (!xzoom) + printf(" Zooming image Y axis by %d%%...", yzoom); + else if (!yzoom) + printf(" Zooming image X axis by %d%%...", xzoom); + else if (xzoom == yzoom) + printf(" Zooming image by %d%%...", xzoom); + else + printf(" Zooming image X axis by %d%% and Y axis by %d%%...", + xzoom, yzoom); + fflush(stdout); + + xindex= buildIndex(oimage->width, xzoom, &xwidth); + yindex= buildIndex(oimage->height, yzoom, &ywidth); + + switch (oimage->type) + { + case IBITMAP: + image= newBitImage(xwidth, ywidth); + for (x= 0; x < oimage->rgb.used; x++) + { + *(image->rgb.red + x)= *(oimage->rgb.red + x); + *(image->rgb.green + x)= *(oimage->rgb.green + x); + *(image->rgb.blue + x)= *(oimage->rgb.blue + x); + } + image->rgb.used= oimage->rgb.used; + destline= image->data; + destlinelen= (xwidth / 8) + (xwidth % 8 ? 1 : 0); + srcline= oimage->data; + srclinelen= (oimage->width / 8) + (oimage->width % 8 ? 1 : 0); + for (y= 0, ysrc= *(yindex + y); y < ywidth; y++) + { + while (ysrc != *(yindex + y)) + { + ysrc++; + srcline += srclinelen; + } + srcptr= srcline; + destptr= destline; + srcmask= 0x80; + destmask= 0x80; + bit= srcmask & *srcptr; + for (x= 0, xsrc= *(xindex + x); x < xwidth; x++) + { + if (xsrc != *(xindex + x)) + { + do + { + xsrc++; + if (!(srcmask >>= 1)) + { + srcmask= 0x80; + srcptr++; + } + } + while (xsrc != *(xindex + x)); + + bit= srcmask & *srcptr; + } + if (bit) + *destptr |= destmask; + if (!(destmask >>= 1)) + { + destmask= 0x80; + destptr++; + } + } + destline += destlinelen; + } + break; + + case IRGB: + image= newRGBImage(xwidth, ywidth, oimage->depth); + for (x= 0; x < oimage->rgb.used; x++) + { + *(image->rgb.red + x)= *(oimage->rgb.red + x); + *(image->rgb.green + x)= *(oimage->rgb.green + x); + *(image->rgb.blue + x)= *(oimage->rgb.blue + x); + } + image->rgb.used= oimage->rgb.used; + + pixlen= oimage->pixlen; + destptr= image->data; + srcline= oimage->data; + srclinelen= oimage->width * pixlen; + for (y= 0, ysrc= *(yindex + y); y < ywidth; y++) + { + while (ysrc != *(yindex + y)) + { + ysrc++; + srcline += srclinelen; + } + + srcptr = srcline; + value = memToVal(srcptr, image->pixlen); + + for (x=0, xsrc= *(xindex + x); xtitle = dupString(oimage->title); + free((byte *)xindex); + free((byte *)yindex); + + printf("done\n"); + + return(image); +} + +void compress(Image *image) +{ + unsigned char *used, fast[32][32][32]; + unsigned int dmask; /* Depth mask protection */ + Pixel *map; + unsigned int next_index; + Intensity *red = image->rgb.red, + *green = image->rgb.green, + *blue = image->rgb.blue; + Intensity r,g,b; + unsigned int x, y, badcount = 0, dupcount = 0, unusedcount = 0; + unsigned char *pixptr, *pixend; + + if (!RGBP(image) || image->rgb.compressed) + return; + + /* + printf(" Compressing colormap..."); + fflush(stdout); + */ + + used = (unsigned char *)lcalloc(sizeof(unsigned char) * depthToColors(image->depth)); + dmask = (1 << image->depth) -1; /* Mask any illegal bits for that depth */ + map = (Pixel *)lcalloc(sizeof(Pixel) * depthToColors(image->depth)); + + /* init fast duplicate check table */ + for(r=0;r<32;r++) + for(g=0;g<32;g++) + for(b=0;b<32;b++) + fast[r][g][b] = 0; + + /* do pass 1 through the image to check index usage */ + + pixptr = image->data; + pixend = pixptr + (image->height * image->width); + for(;pixptr < pixend; pixptr++) + used[(*pixptr) & dmask] = 1; + + /* count the bad pixels */ + for (x = image->rgb.used; x < depthToColors(image->depth); x++) + if (used[x]) + badcount++; + + /* figure out duplicates and unuseds, and create the new mapping */ + next_index = 0; + for (x = 0; x < image->rgb.used; x++) + { + if (!used[x]) + { + unusedcount++; + continue; /* delete this index */ + } + + /* check for duplicate */ + r = red[x]; + g = green[x]; + b = blue[x]; + if (fast[r>>11][g>>11][b>>11]) /* if matches fast check */ + { + /* then do a linear search */ + for (y = x+1; y < image->rgb.used; y++) + { + if (r == red[y] && g == green[y] && b == blue[y]) + break; + } + if (y < image->rgb.used) /* found match */ + { + map[x] = y; + dupcount++; + continue; /* delete this index */ + } + fast[r>>11][g>>11][b>>11] = 1; + } + /* will map to this index */ + map[x] = next_index; + next_index++; + } + + /* change the image pixels */ + pixptr = image->data; + pixend = pixptr + (image->height * image->width); + for(;pixptr < pixend; pixptr++) + *pixptr = map[(*pixptr) & dmask]; + + /* change the colormap */ + for (x = 0; x < image->rgb.used; x++) + { + if (!used[x]) + continue; + red[map[x]] = red[x]; + green[map[x]] = green[x]; + blue[map[x]] = blue[x]; + } + image->rgb.used = next_index; + + /* clean up */ + free(map); + free(used); + + /* + if (badcount) + printf("%d out-of-range pixels, ", badcount); + + if (!unusedcount && !dupcount) + printf("no improvment\n"); + else + { + if (dupcount) + printf("%d duplicate%s and %d unused color%s removed...", + dupcount, (dupcount == 1 ? "" : "s"), + unusedcount, (unusedcount == 1 ? "" : "s")); + printf("%d unique color%s\n", + next_index, (next_index == 1 ? "" : "s")); + } + */ + + image->rgb.compressed= TRUE; /* don't do it again */ +} + + + + +Pixmap ximageToPixmap(Display *disp, Window parent, XImageInfo *ximageinfo) +{ + Pixmap pixmap; + + pixmap = XCreatePixmap(disp, parent, + ximageinfo->ximage->width, ximageinfo->ximage->height, + ximageinfo->depth); + + ximageinfo->drawable = pixmap; + + sendXImage(ximageinfo, 0, 0, 0, 0, + ximageinfo->ximage->width, ximageinfo->ximage->height); + return(pixmap); +} + +/* find the best pixmap depth supported by the server for a particular + * visual and return that depth. + * + * this is complicated by R3's lack of XListPixmapFormats so we fake it + * by looking at the structure ourselves. + */ + +static unsigned int bitsPerPixelAtDepth(Display *disp, int scrn, + unsigned int depth) +{ +#if defined(XlibSpecificationRelease) && (XlibSpecificationRelease >= 4) + /* the way things are */ + XPixmapFormatValues *xf; + int nxf, a; + + xf = XListPixmapFormats(disp, &nxf); + for (a = 0; a < nxf; a++) + { + if (xf[a].depth == depth) + { + int bpp; + bpp = xf[a].bits_per_pixel; + XFree(xf); + return (unsigned int) bpp; + } + } + XFree(xf); +#else /* the way things were (X11R3) */ + unsigned int a; + + for (a= 0; a < disp->nformats; a++) + if (disp->pixmap_format[a].depth == depth) + return(disp->pixmap_format[a].bits_per_pixel); +#endif + + /* this should never happen; if it does, we're in trouble + */ + + fprintf(stderr, "bitsPerPixelAtDepth: Can't find pixmap depth info!\n"); + exit(1); +} + +XImageInfo *imageToXImage(Display *disp, int scrn, Visual *visual, + unsigned int ddepth, Image *image) +{ + static XColor xcolor_private[NOFLASH_COLORS]; + static int colorcell_used[NOFLASH_COLORS]; + static Colormap global_cmap = 0; + static Pixel *global_cmap_index; + static int num_cmap_entries, free_cmap_entries; + static private_cmap = FALSE; + Pixel *redvalue, *greenvalue, *bluevalue; + unsigned int a, c=0, x, y, linelen, dpixlen, dbits; + XColor xcolor; + XGCValues gcv; + XImageInfo *ximageinfo; + + if (!global_cmap) + { + if (visual == DefaultVisual(disp, scrn)) + global_cmap = DefaultColormap(disp, scrn); + else + { + global_cmap = XCreateColormap(disp, RootWindow(disp, scrn), + visual, AllocNone); + private_cmap = TRUE; + } + } + + xcolor.flags = DoRed | DoGreen | DoBlue; + redvalue = greenvalue = bluevalue = NULL; + ximageinfo = (XImageInfo *)lmalloc(sizeof(XImageInfo)); + ximageinfo->disp = disp; + ximageinfo->scrn = scrn; + ximageinfo->depth = 0; + ximageinfo->drawable = None; + ximageinfo->index = NULL; + ximageinfo->rootimage = FALSE; + ximageinfo->foreground = ximageinfo->background= 0; + ximageinfo->gc = NULL; + ximageinfo->ximage = NULL; + + switch (visual->class) + { + case TrueColor: + case DirectColor: + { + Pixel pixval; + unsigned int redcolors, greencolors, bluecolors; + unsigned int redstep, greenstep, bluestep; + unsigned int redbottom, greenbottom, bluebottom; + unsigned int redtop, greentop, bluetop; + + redvalue = (Pixel *)lmalloc(sizeof(Pixel) * 256); + greenvalue = (Pixel *)lmalloc(sizeof(Pixel) * 256); + bluevalue = (Pixel *)lmalloc(sizeof(Pixel) * 256); + + ximageinfo->cmap = global_cmap; + + retry_direct: /* tag we hit if a DirectColor allocation fails on + * default colormap */ + + /* calculate number of distinct colors in each band + */ + + redcolors = greencolors = bluecolors = 1; + for (pixval=1; pixval; pixval <<= 1) + { + if (pixval & visual->red_mask) + redcolors <<= 1; + if (pixval & visual->green_mask) + greencolors <<= 1; + if (pixval & visual->blue_mask) + bluecolors <<= 1; + } + + /* sanity check + */ + + if ((redcolors > visual->map_entries) || + (greencolors > visual->map_entries) || + (bluecolors > visual->map_entries)) + { + fprintf(stderr, "Warning: inconsistency in color information (this may be ugly)\n"); + } + + redstep = 256 / redcolors; + greenstep = 256 / greencolors; + bluestep = 256 / bluecolors; + redbottom = greenbottom = bluebottom = 0; + redtop = greentop = bluetop = 0; + for (a=0; amap_entries; a++) + { + if (redbottom < 256) + redtop = redbottom + redstep; + if (greenbottom < 256) + greentop = greenbottom + greenstep; + if (bluebottom < 256) + bluetop = bluebottom + bluestep; + + xcolor.red = (redtop - 1) << 8; + xcolor.green = (greentop - 1) << 8; + xcolor.blue = (bluetop - 1) << 8; + if (!XAllocColor(disp, ximageinfo->cmap, &xcolor)) + { + /* if an allocation fails for a DirectColor default visual then + * we should create a private colormap and try again. + */ + + if ((visual->class == DirectColor) && + (visual == DefaultVisual(disp, scrn))) + { + global_cmap = XCopyColormapAndFree(disp, global_cmap); + ximageinfo->cmap = global_cmap; + private_cmap = TRUE; + + goto retry_direct; + } + + /* something completely unexpected happened + */ + + fprintf(stderr, "imageToXImage: XAllocColor failed on a TrueColor/Directcolor visual\n"); + free((byte *)redvalue); + free((byte *)greenvalue); + free((byte *)bluevalue); + free((byte *)ximageinfo); + return(NULL); + } + + /* fill in pixel values for each band at this intensity + */ + + while ((redbottom < 256) && (redbottom < redtop)) + redvalue[redbottom++] = xcolor.pixel & visual->red_mask; + while ((greenbottom < 256) && (greenbottom < greentop)) + greenvalue[greenbottom++] = xcolor.pixel & visual->green_mask; + while ((bluebottom < 256) && (bluebottom < bluetop)) + bluevalue[bluebottom++] = xcolor.pixel & visual->blue_mask; + } + break; + } + + case PseudoColor: + + ximageinfo->cmap = global_cmap; + ximageinfo->index = (Pixel *)lmalloc(sizeof(Pixel) * image->rgb.used); + + for (a=0; argb.used; a++) + { + XColor xcolor2; + unsigned short mask; + int color_found; + int i; + + xcolor.red = *(image->rgb.red + a); + xcolor.green = *(image->rgb.green + a); + xcolor.blue = *(image->rgb.blue + a); + + /* look if this color already exists in our colormap */ + if (!XAllocColor(disp, ximageinfo->cmap, &xcolor)) + { + if (!private_cmap) + { + /* + printf("switching to private colormap...\n"); + */ + + /* we just filled up the default colormap -- get a private one + which contains all already allocated colors */ + + global_cmap = XCopyColormapAndFree(disp, global_cmap); + ximageinfo->cmap = global_cmap; + private_cmap = TRUE; + + /* allocate the rest of the color cells read/write */ + global_cmap_index = + (Pixel *)lmalloc(sizeof(Pixel) * NOFLASH_COLORS); + for (i=0; i=0; i--) + { + xcolor2.pixel = *(global_cmap_index + i); + xcolor2 = xcolor_private[xcolor2.pixel]; + + if (colorcell_used[xcolor2.pixel]) + continue; + + if ((xcolor.red & mask) == (xcolor2.red & mask) && + (xcolor.green & mask) == (xcolor2.green & mask) && + (xcolor.blue & mask) == (xcolor2.blue & mask)) + { + /* + printf("replacing color cell %ld with a close color\n", + xcolor2.pixel); + */ + color_found = TRUE; + break; + } + } + + if (mask == 0x0000) + break; + + mask = (mask << 1) & 0xffff; + } + + if (!color_found) /* no more free color cells */ + { + printf("Sorry, cannot allocate enough colors!\n"); + exit(0); + } + + xcolor.pixel = xcolor2.pixel; + xcolor_private[xcolor.pixel] = xcolor; + colorcell_used[xcolor.pixel] = TRUE; + XStoreColor(disp, ximageinfo->cmap, &xcolor); + free_cmap_entries--; + } + + *(ximageinfo->index + a) = xcolor.pixel; + } + + /* + printf("still %d free colormap entries\n", free_cmap_entries); + */ + + ximageinfo->no = a; /* number of pixels allocated for this image */ + break; + + default: + printf("Sorry, only DirectColor, TrueColor and PseudoColor supported\n"); + exit(0); + break; + } + + /* create an XImage and related colormap based on the image type + * we have. + */ + + /* + printf(" Building XImage..."); + fflush(stdout); + */ + + switch (image->type) + { + case IBITMAP: + { + byte *data; + + /* we copy the data to be more consistent + */ + + linelen = ((image->width + 7) / 8); + data= lmalloc(linelen * image->height); + + memcpy((char *)data, (char *)image->data, linelen * image->height); + + gcv.function= GXcopy; + ximageinfo->ximage= XCreateImage(disp, visual, 1, XYBitmap, + 0, (char *)data, image->width, image->height, + 8, linelen); + + /* use this if you want to use the bitmap as a mask */ + ximageinfo->depth = image->depth; + + if(visual->class == DirectColor || visual->class == TrueColor) + { + Pixel pixval; + dbits= bitsPerPixelAtDepth(disp, scrn, ddepth); + dpixlen= (dbits + 7) / 8; + pixval= redvalue[image->rgb.red[0] >> 8] | + greenvalue[image->rgb.green[0] >> 8] | + bluevalue[image->rgb.blue[0] >> 8]; + ximageinfo->background = pixval; + pixval= redvalue[image->rgb.red[1] >> 8] | + greenvalue[image->rgb.green[1] >> 8] | + bluevalue[image->rgb.blue[1] >> 8]; + ximageinfo->foreground = pixval; + } + else /* Not Direct or True Color */ + { + ximageinfo->foreground = BlackPixel(disp,scrn); + ximageinfo->background = WhitePixel(disp,scrn); + } + ximageinfo->ximage->bitmap_bit_order= MSBFirst; + ximageinfo->ximage->byte_order= MSBFirst; + + break; + } + + case IRGB: + { + /* modify image data to match visual and colormap + */ + + byte *data, *destptr, *srcptr; + + dbits = bitsPerPixelAtDepth(disp, scrn, ddepth); /* bits per pixel */ + dpixlen = (dbits + 7) / 8; /* bytes per pixel */ + + ximageinfo->ximage = XCreateImage(disp, visual, ddepth, ZPixmap, 0, + NULL, image->width, image->height, + 8, image->width * dpixlen); + + data = (byte *)lmalloc(image->width * image->height * dpixlen); + ximageinfo->depth = ddepth; + ximageinfo->ximage->data = (char *)data; + ximageinfo->ximage->byte_order = MSBFirst; + srcptr = image->data; + destptr = data; + + switch (visual->class) + { + case DirectColor: + case TrueColor: + { + Pixel pixval; + + for (y=0; yheight; y++) + { + for (x=0; xwidth; x++) + { + pixval = memToVal(srcptr, 1); + pixval = redvalue[image->rgb.red[pixval] >> 8] | + greenvalue[image->rgb.green[pixval] >> 8] | + bluevalue[image->rgb.blue[pixval] >> 8]; + valToMem(pixval, destptr, dpixlen); + srcptr += 1; + destptr += dpixlen; + } + } + break; + } + + default: + { + if (dpixlen == 1) /* most common */ + { + for (y=0; yheight; y++) + { + for (x=0; xwidth; x++) + { + *destptr = ximageinfo->index[c + *srcptr]; + srcptr++; + destptr++; + } + } + } + else /* less common */ + { + for (y=0; yheight; y++) + { + for (x=0; xwidth; x++) + { + register unsigned long temp; + temp = memToVal(srcptr, 1); + valToMem(ximageinfo->index[c + temp], destptr, dpixlen); + srcptr += 1; + destptr += dpixlen; + } + } + } + } + break; + } + } + } + + /* + printf("done\n"); + */ + + if (redvalue) + { + free((byte *)redvalue); + free((byte *)greenvalue); + free((byte *)bluevalue); + } + + return(ximageinfo); +} + +/* Given an XImage and a drawable, move a rectangle from the Ximage + * to the drawable. + */ + +void sendXImage(XImageInfo *ximageinfo, + int src_x, int src_y, int dst_x, int dst_y, + unsigned int w, unsigned int h) +{ + XGCValues gcv; + + /* build and cache the GC + */ + + if (!ximageinfo->gc) + { + gcv.function = GXcopy; + if (ximageinfo->ximage->depth == 1) + { + gcv.foreground = ximageinfo->foreground; + gcv.background = ximageinfo->background; + ximageinfo->gc = XCreateGC(ximageinfo->disp, ximageinfo->drawable, + GCFunction | GCForeground | GCBackground, + &gcv); + } + else + ximageinfo->gc = XCreateGC(ximageinfo->disp, ximageinfo->drawable, + GCFunction, &gcv); + } + + XPutImage(ximageinfo->disp, ximageinfo->drawable, ximageinfo->gc, + ximageinfo->ximage, src_x, src_y, dst_x, dst_y, w, h); +} + +/* free up anything cached in the local Ximage structure. + */ + +void freeXImage(Image *image, XImageInfo *ximageinfo) +{ + if (ximageinfo->index != NULL) /* if we allocated colors */ + { + if (ximageinfo->no > 0 && !ximageinfo->rootimage) /* don't free root colors */ + XFreeColors(ximageinfo->disp, ximageinfo->cmap, ximageinfo->index, ximageinfo->no, 0); + free(ximageinfo->index); + } + if (ximageinfo->gc) + XFreeGC(ximageinfo->disp, ximageinfo->gc); + free((byte *)ximageinfo->ximage->data); + ximageinfo->ximage->data= NULL; + XDestroyImage(ximageinfo->ximage); + free((byte *)ximageinfo); + /* should we free private color map to ??? */ +} diff --git a/src/xli.h b/src/xli.h new file mode 100644 index 00000000..50826558 --- /dev/null +++ b/src/xli.h @@ -0,0 +1,153 @@ + +/* xli.h: + * + * jim frost 06.21.89 + * + * Copyright 1989 Jim Frost. See included file "copyright.h" for complete + * copyright information. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +typedef unsigned long Pixel; /* what X thinks a pixel is */ +typedef unsigned short Intensity; /* what X thinks an RGB intensity is */ +typedef unsigned char byte; /* unsigned byte type */ + +#define FALSE 0 +#define TRUE (!FALSE) + +/* Display device dependent Information structure */ +typedef struct +{ + int width; /* Display width and height */ + int height; + + Display *disp; + int scrn; + Colormap colormap; +} DisplayInfo; + +/* This struct holds the X-client side bits for a rendered image. */ +typedef struct +{ + Display *disp; /* destination display */ + int scrn; /* destination screen */ + int depth; /* depth of drawable we want/have */ + Drawable drawable; /* drawable to send image to */ + Pixel *index; /* array of pixel values allocated */ + int no; /* number of pixels in the array */ + int rootimage; /* True if is a root image - eg, retain colors */ + Pixel foreground; /* foreground and background pixels for mono images */ + Pixel background; + Colormap cmap; /* colormap used for image */ + GC gc; /* cached gc for sending image */ + XImage *ximage; /* ximage structure */ +} XImageInfo; + +/* Function declarations */ +void sendXImage(); /* send.c */ +XImageInfo *imageToXImage(); +Pixmap ximageToPixmap(); +void freeXImage(); + + +typedef struct rgbmap { + unsigned int size; /* size of RGB map */ + unsigned int used; /* number of colors used in RGB map */ + int compressed; /* image uses colormap fully */ + Intensity *red; /* color values in X style */ + Intensity *green; + Intensity *blue; +} RGBMap; + +/* image structure + */ + +typedef struct { + char *title; /* name of image */ + unsigned int type; /* type of image */ + RGBMap rgb; /* RGB map of image if IRGB type */ + unsigned int width; /* width of image in pixels */ + unsigned int height; /* height of image in pixels */ + unsigned int depth; /* depth of image in bits if IRGB type */ + unsigned int pixlen; /* length of pixel if IRGB type */ + byte *data; /* data rounded to full byte for each row */ + float gamma; /* gamma of display the image is adjusted for */ +} Image; + +#define IBITMAP 0 /* image is a bitmap */ +#define IRGB 1 /* image is RGB */ + +#define BITMAPP(IMAGE) ((IMAGE)->type == IBITMAP) +#define RGBP(IMAGE) ((IMAGE)->type == IRGB) + +#define depthToColors(n) DepthToColorsTable[((n) < 24 ? (n) : 24)] + +/* + * Architecture independent memory to value conversions. + * Note the "Normal" internal format is big endian. + */ + +#define memToVal(PTR,LEN) ( \ +(LEN) == 1 ? (unsigned long)( *( (byte *)(PTR)) ) : \ +(LEN) == 2 ? (unsigned long)(((unsigned long)(*( (byte *)(PTR)) ))<< 8) \ + + ( *(((byte *)(PTR))+1) ) : \ +(LEN) == 3 ? (unsigned long)(((unsigned long)(*( (byte *)(PTR)) ))<<16) \ + + (((unsigned long)(*(((byte *)(PTR))+1)))<< 8) \ + + ( *(((byte *)(PTR))+2) ) : \ + (unsigned long)(((unsigned long)(*( (byte *)(PTR)) ))<<24) \ + + (((unsigned long)(*(((byte *)(PTR))+1)))<<16) \ + + (((unsigned long)(*(((byte *)(PTR))+2)))<< 8) \ + + ( *(((byte *)(PTR))+3) ) ) + +#define valToMem(VAL,PTR,LEN) ( \ +(LEN) == 1 ? (*( (byte *)(PTR) ) = ( VAL ) ) : \ +(LEN) == 2 ? (*( (byte *)(PTR) ) = (((unsigned long)(VAL))>> 8), \ + *(((byte *)(PTR))+1) = ( VAL ) ) : \ +(LEN) == 3 ? (*( (byte *)(PTR) ) = (((unsigned long)(VAL))>>16), \ + *(((byte *)(PTR))+1) = (((unsigned long)(VAL))>> 8), \ + *(((byte *)(PTR))+2) = ( VAL ) ) : \ + (*( (byte *)(PTR) ) = (((unsigned long)(VAL))>>24), \ + *(((byte *)(PTR))+1) = (((unsigned long)(VAL))>>16), \ + *(((byte *)(PTR))+2) = (((unsigned long)(VAL))>> 8), \ + *(((byte *)(PTR))+3) = ( VAL ) )) + + +/* functions */ + +void cleanUpWindow(); /* window.c */ +char imageInWindow(); + +int visualClassFromName(); +char *nameOfVisualClass(); + +extern unsigned long DepthToColorsTable[]; /* new.c */ +char *dupString(); +Image *newBitImage(); +Image *newRGBImage(); +void freeImage(); +void freeImageData(); +void newRGBMapData(); +void freeRGBMapData(); +byte *lcalloc(); +byte *lmalloc(); + +Image *gifLoad(); +Image *monochrome(); +Image *zoom(); + +void compress(); /* compress.c */ + +int xliOpenDisplay(); +void tellAboutDisplay(DisplayInfo *); +void xliCloseDisplay(DisplayInfo *); -- 2.34.1