![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to XImUtil.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / X|
Return to XImUtil.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / X |
1.1 root 1: #include "copyright.h"
2:
3: /* $Header: XImUtil.c,v 11.17 87/09/01 14:53:59 toddb Exp $ */
4: /* Copyright Massachusetts Institute of Technology 1986 */
5:
6: #include "Xlibint.h"
7: #include "Xutil.h"
8: #include <stdio.h>
9:
10: extern char _reverse_byte[0x100]; /* found in XPutImage */
11: static char _lomask[0x09] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
12: static char _himask[0x09] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00 };
13:
14: /* These two convenience routines return the scanline_pad and bits_per_pixel
15: associated with a specific depth of ZPixmap format image for a
16: display. */
17:
18: _XGetScanlinePad(dpy, depth)
19: Display *dpy;
20: int depth;
21: {
22: register ScreenFormat *fmt = dpy->pixmap_format;
23: register int i;
24:
25: for (i = dpy->nformats + 1; --i; ++fmt)
26: if (fmt->depth == depth)
27: return(fmt->scanline_pad);
28:
29: return(dpy->bitmap_pad);
30: }
31:
32: _XGetBitsPerPixel(dpy, depth)
33: Display *dpy;
34: int depth;
35: {
36: register ScreenFormat *fmt = dpy->pixmap_format;
37: register int i;
38:
39: for (i = dpy->nformats + 1; --i; ++fmt)
40: if (fmt->depth == depth)
41: return(fmt->bits_per_pixel);
42:
43: return(depth);
44: }
45:
46:
47: /*
48: * This module provides rudimentary manipulation routines for image data
49: * structures. The functions provided are:
50: *
51: * XCreateImage Creates a default XImage data structure
52: * _XDestroyImage Deletes an XImage data structure
53: * _XGetPixel Reads a pixel from an image data structure
54: * _XPutPixel Writes a pixel into an image data structure
55: * _XSubImage Clones a new (sub)image from an existing one
56: * _XSetImage Writes an image data pattern into another image
57: * _XAddPixel Adds a constant value to every pixel in an image
58: *
59: * The logic contained in these routines makes several assumptions about
60: * the image data structures, and at least for current implementations
61: * these assumptions are believed to be true. They are:
62: *
63: * For all formats, bits_per_pixel is less than or equal to 32.
64: * For XY formats, bitmap_unit is 8, 16, 24, or 32 bits.
65: * For Z format, bits_per_pixel is 4, 8, 12, 16, 20, 24, 28 or 32 bits.
66: */
67: static _normalizeimagebits (bpt, nb, byteorder, unitsize, bitorder)
68: unsigned char *bpt; /* beginning pointer to image bits */
69: long nb; /* number of bytes to normalize */
70: int byteorder; /* swap bytes if byteorder == MSBFirst */
71: int unitsize; /* size of the bitmap_unit or Zpixel */
72: int bitorder; /* swap bits if bitorder == MSBFirst */
73: {
74: if (byteorder == MSBFirst) {
75: register char c;
76: register unsigned char *bp = bpt;
77: register unsigned char *ep = bpt + nb;
78: register unsigned char *sp;
79: switch (unitsize) {
80:
81: case 4:
82: do { /* swap nibble */
83: *bp = ((*bp >> 4) & 0xF) | ((*bp << 4) & ~0xF);
84: bp++;
85: }
86: while (bp < ep);
87: break;
88:
89: case 16:
90: do { /* swap short */
91: c = *bp;
92: *bp = *(bp + 1);
93: bp++;
94: *bp = c;
95: bp++;
96: }
97: while (bp < ep);
98: break;
99:
100: case 24:
101: do { /* swap three */
102: c = *(bp + 2);
103: *(bp + 2) = *bp;
104: *bp = c;
105: bp += 3;
106: }
107: while (bp < ep);
108: break;
109:
110: case 32:
111: do { /* swap long */
112: sp = bp + 3;
113: c = *sp;
114: *sp = *bp;
115: *bp++ = c;
116: sp = bp + 1;
117: c = *sp;
118: *sp = *bp;
119: *bp++ = c;
120: bp += 2;
121: }
122: while (bp < ep);
123: break;
124: }
125: }
126: if (bitorder == MSBFirst) {
127: do {
128: *bpt = _reverse_byte[*bpt];
129: bpt++;
130: }
131: while (--nb > 0);
132: }
133: }
134:
135: static _putbits (src, dstoffset, numbits, dst)
136: register char *src; /* address of source bit string */
137: long dstoffset; /* bit offset into destination; range is 0-31 */
138: register int numbits;/* number of bits to copy to destination */
139: register char *dst; /* address of destination bit string */
140: {
141: register unsigned char chlo, chhi;
142: int hibits;
143: dst = dst + (dstoffset >> 3);
144: dstoffset = dstoffset % 8;
145: hibits = 8 - dstoffset;
146: chlo = *dst & _lomask[dstoffset];
147: for (;;) {
148: chhi = (*src << dstoffset) & _himask[dstoffset];
149: if (numbits <= hibits) {
150: chhi = chhi & _lomask[dstoffset + numbits];
151: *dst = (*dst & _himask[dstoffset + numbits]) | chlo | chhi;
152: break;
153: }
154: *dst = chhi | chlo;
155: dst++;
156: numbits = numbits - hibits;
157: chlo = (unsigned char) (*src & _himask[hibits]) >> hibits;
158: src++;
159: if (numbits <= dstoffset) {
160: chlo = chlo & _lomask[numbits];
161: *dst = (*dst & _himask[numbits]) | chlo;
162: break;
163: }
164: numbits = numbits - dstoffset;
165: }
166: }
167:
168:
169: /*
170: * Macros
171: *
172: * The ROUNDUP macro rounds up a quantity to the specified boundary.
173: *
174: * The XYNORMALIZE macro determines whether XY format data requires
175: * normalization and calls a routine to do so if needed. The logic in
176: * this module is designed for LSBFirst byte and bit order, so
177: * normalization is done as required to present the data in this order.
178: *
179: * The ZNORMALIZE macro performs byte and nibble order normalization if
180: * required for Z format data.
181: *
182: * The XYINDEX macro computes the index to the starting byte (char) boundary
183: * for a bitmap_unit containing a pixel with coordinates x and y for image
184: * data in XY format.
185: *
186: * The ZINDEX macro computes the index to the starting byte (char) boundary
187: * for a pixel with coordinates x and y for image data in ZPixmap format.
188: *
189: */
190:
191: #define ROUNDUP(nbytes, pad) (((((nbytes) - 1) + (pad)) / (pad)) * (pad))
192:
193: #define XYNORMALIZE(bp, nbytes, img) \
194: if ((img->byte_order == MSBFirst) || (img->bitmap_bit_order == MSBFirst)) \
195: _normalizeimagebits((unsigned char *)(bp), (nbytes), img->byte_order, img->bitmap_unit, \
196: img->bitmap_bit_order)
197:
198: #define ZNORMALIZE(bp, nbytes, img) \
199: if (img->byte_order == MSBFirst) \
200: _normalizeimagebits((unsigned char *)(bp), (nbytes), MSBFirst, img->bits_per_pixel, \
201: LSBFirst)
202:
203: #define XYINDEX(x, y, img) \
204: ((y) * img->bytes_per_line) + \
205: (((x) + img->xoffset) / img->bitmap_unit) * (img->bitmap_unit >> 3)
206:
207: #define ZINDEX(x, y, img) ((y) * img->bytes_per_line) + \
208: (((x) * img->bits_per_pixel) >> 3)
209:
210:
211: /*
212: * CreateImage
213: *
214: * Allocates the memory necessary for an XImage data structure.
215: * Initializes the structure with "default" values and returns XImage.
216: *
217: */
218:
219: XImage *XCreateImage (dpy, visual, depth, format, offset, data, width, height,
220: xpad, image_bytes_per_line)
221: register Display *dpy;
222: register Visual *visual;
223: unsigned int depth;
224: int format;
225: int offset; /*How many pixels from the start of the data does the
226: picture to be transmitted start?*/
227:
228: char *data;
229: unsigned int width;
230: unsigned int height;
231: int xpad;
232: int image_bytes_per_line;
233: /*How many bytes between a pixel on one line and the pixel with
234: the same X coordinate on the next line? 0 means
235: XCreateImage can calculate it.*/
236: {
237: register XImage *image;
238: int bits_per_pixel = 1;
239: int byte_offset;
240: image = (XImage *) Xcalloc (1, (unsigned) sizeof (XImage));
241: image->width = width;
242: image->height = height;
243: image->format = format;
244: image->byte_order = dpy->byte_order;
245: image->bitmap_unit = dpy->bitmap_unit;
246: image->bitmap_bit_order = dpy->bitmap_bit_order;
247: if (visual != NULL) {
248: image->red_mask = visual->red_mask;
249: image->green_mask = visual->green_mask;
250: image->blue_mask = visual->blue_mask;
251: }
252: else {
253: image->red_mask = image->green_mask = image->blue_mask = 0;
254: }
255: if (format == ZPixmap)
256: {
257: bits_per_pixel = _XGetBitsPerPixel(dpy, depth);
258: }
259:
260: image->xoffset = offset;
261: image->bitmap_pad = xpad;
262: image->depth = depth;
263: image->data = data;
264: /*
265: * compute per line accelerator.
266: */
267: if (image_bytes_per_line == 0)
268: {
269: if (format == ZPixmap)
270: image->bytes_per_line =
271: ROUNDUP((bits_per_pixel * width), image->bitmap_pad) >> 3;
272: else
273: image->bytes_per_line =
274: ROUNDUP((width + offset), image->bitmap_pad) >> 3;
275: }
276: else image->bytes_per_line = image_bytes_per_line;
277:
278: image->bits_per_pixel = bits_per_pixel;
279: image->obdata = NULL;
280: _XInitImageFuncPtrs (image);
281:
282: return image;
283:
284: }
285:
286:
287: /*
288: * _DestroyImage
289: *
290: * Deallocates the memory associated with the ximage data structure.
291: * this version handles the case of the image data being malloc'd
292: * entirely by the library.
293: */
294:
295: int _XDestroyImage (ximage)
296: XImage *ximage;
297:
298: {
299: Xfree((char *)ximage->data);
300: if (ximage->obdata != NULL) Xfree((char *)ximage->obdata);
301: Xfree((char *)ximage);
302: return 1;
303: }
304:
305:
306: /*
307: * GetPixel
308: *
309: * Returns the specified pixel. The X and Y coordinates are relative to
310: * the origin (upper left [0,0]) of the image. The pixel value is returned
311: * in normalized format, i.e. the LSB of the long is the LSB of the pixel.
312: * The algorithm used is:
313: *
314: * copy the source bitmap_unit or Zpixel into temp
315: * normalize temp if needed
316: * extract the pixel bits into return value
317: *
318: */
319:
320: unsigned long _XGetPixel (ximage, x, y)
321: register XImage *ximage;
322: int x;
323: int y;
324:
325: {
326: unsigned long pixel, px;
327: register char *src;
328: register char *dst;
329: register long i, j;
330: int plane;
331: long nbytes;
332: switch (ximage->format) {
333:
334: case XYBitmap:
335: src = &ximage->data[XYINDEX(x, y, ximage)];
336: dst = (char *)&pixel;
337: pixel = 0;
338: nbytes = ximage->bitmap_unit >> 3;
339: for (i=0; i < nbytes; i++) *dst++ = *src++;
340: XYNORMALIZE(&pixel, nbytes, ximage);
341: pixel = pixel >> ((x + ximage->xoffset) % ximage->bitmap_unit);
342: pixel = pixel & 1;
343: break;
344:
345: case XYPixmap:
346: pixel = 0;
347: plane = 0;
348: nbytes = ximage->bitmap_unit >> 3;
349: for (i=0; i < ximage->depth; i++) {
350: src = &ximage->data[XYINDEX(x, y, ximage)+ plane];
351: dst = (char *)&px;
352: px = 0;
353: for (j=0; j < nbytes; j++) *dst++ = *src++;
354: XYNORMALIZE(&px, nbytes, ximage);
355: px = px >> ((x + ximage->xoffset) % ximage->bitmap_unit);
356: px = px & 1;
357: pixel = (pixel << 1) | px;
358: plane = plane + (ximage->bytes_per_line * ximage->height);
359: }
360: break;
361:
362: case ZPixmap:
363: src = &ximage->data[ZINDEX(x, y, ximage)];
364: dst = (char *)&pixel;
365: pixel = 0;
366: nbytes = ROUNDUP(ximage->bits_per_pixel, 8) >> 3;
367: for (i=0; i < nbytes; i++) *dst++ = *src++;
368: ZNORMALIZE(&pixel, nbytes, ximage);
369: pixel = pixel >> ((x * ximage->bits_per_pixel) % 8);
370: break;
371:
372: default: /* should never get here */
373: _XReportBadImage("format", ximage->format, "_XGetPixel");
374: break;
375: }
376: return pixel;
377: }
378:
379:
380: /*
381: * PutPixel
382: *
383: * Overwrites the specified pixel. The X and Y coordinates are relative to
384: * the origin (upper left [0,0]) of the image. The input pixel value must be
385: * in normalized format, i.e. the LSB of the long is the LSB of the pixel.
386: * The algorithm used is:
387: *
388: * copy the destination bitmap_unit or Zpixel to temp
389: * normalize temp if needed
390: * copy the pixel bits into the temp
391: * renormalize temp if needed
392: * copy the temp back into the destination image data
393: *
394: */
395:
396: int _XPutPixel (ximage, x, y, pixel)
397: register XImage *ximage;
398: int x;
399: int y;
400: unsigned long pixel;
401:
402: {
403: unsigned long px;
404: register char *src;
405: register char *dst;
406: register long i;
407: int plane, j;
408: register long nbytes;
409:
410: switch (ximage->format) {
411:
412: case XYBitmap:
413: src = &ximage->data[XYINDEX(x, y, ximage)];
414: dst = (char *)&px;
415: px = 0;
416: nbytes = ximage->bitmap_unit >> 3;
417: for (i=0; i < nbytes; i++) *dst++ = *src++;
418: XYNORMALIZE(&px, nbytes, ximage);
419: i = ((x + ximage->xoffset) % ximage->bitmap_unit);
420: _putbits ((char *)&pixel, i, 1, (char *)&px);
421: XYNORMALIZE(&px, nbytes, ximage);
422: src = (char *) &px;
423: dst = &ximage->data[XYINDEX(x, y, ximage)];
424: for (i=0; i < nbytes; i++) *dst++ = *src++;
425: break;
426:
427: case XYPixmap:
428: plane = (ximage->bytes_per_line * ximage->height) *
429: (ximage->depth - 1); /* do least signif plane 1st */
430: nbytes = ximage->bitmap_unit >> 3;
431: for (j=0; j < ximage->depth; j++) {
432: src = &ximage->data[XYINDEX(x, y, ximage) + plane];
433: dst = (char *) &px;
434: px = 0;
435: for (i=0; i < nbytes; i++) *dst++ = *src++;
436: XYNORMALIZE(&px, nbytes, ximage);
437: i = ((x + ximage->xoffset) % ximage->bitmap_unit);
438: _putbits ((char *)&pixel, i, 1, (char *)&px);
439: XYNORMALIZE(&px, nbytes, ximage);
440: src = (char *)&px;
441: dst = &ximage->data[XYINDEX(x, y, ximage) + plane];
442: for (i=0; i < nbytes; i++) *dst++ = *src++;
443: pixel = pixel >> 1;
444: plane = plane - (ximage->bytes_per_line * ximage->height);
445: }
446: break;
447:
448: case ZPixmap:
449: src = &ximage->data[ZINDEX(x, y, ximage)];
450: dst = (char *)&px;
451: px = 0;
452: nbytes = ROUNDUP(ximage->bits_per_pixel, 8) >> 3;
453: for (i=0; i < nbytes; i++) *dst++ = *src++;
454: ZNORMALIZE(&px, nbytes, ximage);
455: _putbits ((char *)&pixel,
456: (long) (x * ximage->bits_per_pixel) % 8,
457: ximage->bits_per_pixel, (char *)&px);
458: ZNORMALIZE(&px, nbytes, ximage);
459: src = (char *)&px;
460: dst = &ximage->data[ZINDEX(x, y, ximage)];
461: for (i=0; i < nbytes; i++) *dst++ = *src++;
462: break;
463:
464: default: /* should never get here */
465: _XReportBadImage("format", ximage->format, "_XPutPixel");
466: break;
467: }
468: return 1;
469: }
470:
471:
472: /*
473: * SubImage
474: *
475: * Creates a new image that is a subsection of an existing one.
476: * Allocates the memory necessary for the new XImage data structure.
477: * Pointer to new image is returned. The algorithm used is repetitive
478: * calls to get and put pixel.
479: *
480: */
481:
482: XImage *_XSubImage (ximage, x, y, width, height)
483: XImage *ximage;
484: register int x; /* starting x coordinate in existing image */
485: register int y; /* starting y coordinate in existing image */
486: int width; /* width in pixels of new subimage */
487: int height; /* height in pixels of new subimage */
488:
489: {
490: register XImage *subimage;
491: int dsize;
492: register int row, col;
493: register unsigned long pixel;
494: char *data;
495: subimage = (XImage *) Xcalloc (1, sizeof (XImage));
496: subimage->width = width;
497: subimage->height = height;
498: subimage->xoffset = 0;
499: subimage->format = ximage->format;
500: subimage->byte_order = ximage->byte_order;
501: subimage->bitmap_unit = ximage->bitmap_unit;
502: subimage->bitmap_bit_order = ximage->bitmap_bit_order;
503: subimage->bitmap_pad = ximage->bitmap_pad;
504: subimage->bits_per_pixel = ximage->bits_per_pixel;
505: subimage->depth = ximage->depth;
506: /*
507: * compute per line accelarator.
508: */
509: if (subimage->format == ZPixmap)
510: subimage->bytes_per_line =
511: ROUNDUP(((subimage->bits_per_pixel * width) >> 3),
512: subimage->bitmap_pad >> 3);
513: else
514: subimage->bytes_per_line =
515: ROUNDUP((width >> 3), subimage->bitmap_pad >> 3);
516: subimage->obdata = NULL;
517: _XInitImageFuncPtrs (subimage);
518: dsize = subimage->bytes_per_line * height;
519: if (subimage->format == XYPixmap) dsize = dsize * subimage->depth;
520: data = Xcalloc (1, (unsigned) dsize);
521: subimage->data = data;
522:
523: /*
524: * Test for cases where the new subimage is larger than the region
525: * that we are copying from the existing data. In those cases,
526: * copy the area of the existing image, and allow the "uncovered"
527: * area of new subimage to remain with zero filled pixels.
528: */
529: if (height > ximage->height - y ) height = ximage->height - y;
530: if (width > ximage->width - x ) width = ximage->width - x;
531:
532: for (row = y; row < (y + height); row++) {
533: for (col = x; col < (x + width); col++) {
534: pixel = XGetPixel(ximage, col, row);
535: XPutPixel(subimage, (col - x), (row - y), pixel);
536: }
537: }
538: return subimage;
539: }
540:
541:
542: /*
543: * SetImage
544: *
545: * Overwrites a section of one image with all of the data from another.
546: * If the two images are not of the same format (i.e. XYPixmap and ZPixmap),
547: * the image data is converted to the destination format. The following
548: * restrictions apply:
549: *
550: * 1. The depths of the source and destination images must be equal.
551: *
552: * 2. If the height of the source image is too large to fit between
553: * the specified x starting point and the bottom of the image,
554: * then scanlines are truncated on the bottom.
555: *
556: * 3. If the width of the source image is too large to fit between
557: * the specified y starting point and the end of the scanline,
558: * then pixels are truncated on the right.
559: *
560: * The images need not have the same bitmap_bit_order, byte_order,
561: * bitmap_unit, bits_per_pixel, bitmap_pad, or xoffset.
562: *
563: */
564:
565: int _XSetImage (srcimg, dstimg, x, y)
566: XImage *srcimg;
567: register XImage *dstimg;
568: register int x;
569: register int y;
570:
571: {
572: register unsigned long pixel;
573: register int row, col;
574: if (srcimg->depth != dstimg->depth)
575: _XReportBadImage ("depth", dstimg->depth, "_XSetImage");
576:
577: /* this is slow, will do better later */
578: for (row = y; row < dstimg->height; row++) {
579: for (col = x; col < dstimg->width; col++) {
580: pixel = XGetPixel(srcimg, col - x, row - y);
581: XPutPixel(dstimg, col, row, pixel);
582: }
583: }
584: return 1;
585: }
586:
587:
588: /*
589: * AddPixel
590: *
591: * Adds a constant value to every pixel in a pixmap.
592: *
593: */
594:
595: int _XAddPixel (ximage, value)
596: register XImage *ximage;
597: int value;
598:
599: {
600: unsigned long pixel;
601: register unsigned char *dp, *src, *dst, *tmp;
602: register int x;
603: int y;
604: long nbytes, i;
605: if (value != 0) {
606: switch(ximage->format) {
607:
608: case XYBitmap:
609: /* The only value that we can add here to an XYBitmap
610: * is one. Since 1 + value = ~value for one bit wide
611: * data, we do this quickly by taking the ones complement
612: * of the entire bitmap data (offset and pad included!).
613: * Note that we don't need to be concerned with bit or
614: * byte order at all.
615: */
616: dp = (unsigned char *) &ximage->data[0];
617: y = ximage->bytes_per_line * ximage->height;
618: for (x=0; x < y; x++) {
619: *dp = ~(*dp);
620: dp++;
621: }
622: break;
623:
624: case XYPixmap:
625: /* this is slow, may do better later */
626: for (y = 0; y < ximage->height; y++) {
627: for (x = 0; x < ximage->width; x++) {
628: pixel = XGetPixel(ximage, x, y);
629: pixel = pixel + value;
630: XPutPixel(ximage, x, y, pixel);
631: }
632: }
633: break;
634:
635: case ZPixmap:
636: /* If the bits_per_pixel makes the alignment occur on even
637: * byte boundaries, perform the addition by stepping thru
638: * the data one pixel at a time. Otherwise, do it the slow
639: * way by calling get and put pixel.
640: */
641: if ((ximage->bits_per_pixel % 8) == 0) {
642: nbytes = ROUNDUP(ximage->bits_per_pixel, 8) >> 3;
643: for (y = 0; y < ximage->height; y++) {
644: src = (unsigned char *) &ximage->data[ZINDEX(0, y, ximage)];
645: dst = src;
646: for (x = 0; x < ximage->width; x++) {
647: pixel = 0;
648: tmp = (unsigned char *)&pixel;
649: for (i = 0; i < nbytes; i++) *tmp++ = *src++;
650: ZNORMALIZE(&pixel, nbytes, ximage);
651: pixel = pixel + value;
652: ZNORMALIZE(&pixel, nbytes, ximage);
653: tmp = (unsigned char *)&pixel;
654: for (i = 0; i < nbytes; i++) *dst++ = *tmp++;
655: }
656: }
657: break;
658: }
659: else for (y = 0; y < ximage->height; y++) {
660: for (x = 0; x < ximage->width; x++) {
661: pixel = XGetPixel(ximage, x, y);
662: pixel = pixel + value;
663: XPutPixel(ximage, x, y, pixel);
664: }
665: }
666: break;
667:
668: default: /* should never get here */
669: _XReportBadImage("format", ximage->format, "_XAddPixel");
670: break;
671: }
672: }
673: return 1;
674: }
675:
676: /*
677: * This routine initializes the image object function pointers. The
678: * intent is to provide native (i.e. fast) routines for native format images
679: * only using the generic (i.e. slow) routines when fast ones don't exist.
680: * For now, just insert the generic routines.
681: */
682: _XInitImageFuncPtrs (image)
683: register XImage *image;
684: {
685: image->f.create_image = XCreateImage;
686: image->f.destroy_image = _XDestroyImage;
687: image->f.get_pixel = _XGetPixel;
688: image->f.put_pixel = _XPutPixel;
689: image->f.sub_image = _XSubImage;
690: /* image->f.set_image = _XSetImage;*/
691: image->f.add_pixel = _XAddPixel;
692: }
693:
694: void exit();
695: int _XReportBadImage (errtype, error, routine)
696: char errtype[];
697: int error;
698: char routine[];
699: {
700: (void) fprintf(stderr, "Bad image %s: %d found in routine: %s\n",
701: errtype, error, routine );
702: exit(1);
703: }
704:
705:
706: #ifdef notdef
707: _getbits (src, srcoffset, numbits, dst)
708: register char *src; /* address of source bit string */
709: int srcoffset; /* bit offset into source; range is 0-31 */
710: register int numbits; /* number of bits to copy to destination */
711: register char *dst; /* address of destination bit string */
712: {
713: register unsigned char chlo, chhi;
714: int lobits;
715: src = src + (srcoffset >> 3);
716: srcoffset = srcoffset % 8;
717: lobits = 8 - srcoffset;
718: for (;;) {
719: chlo = (unsigned char) (*src & _himask[srcoffset]) >> srcoffset;
720: src++;
721: if (numbits <= lobits) {
722: chlo = chlo & _lomask[numbits];
723: *dst = (*dst & _himask[numbits]) | chlo;
724: break;
725: }
726: numbits = numbits - lobits;
727: chhi = *src & _lomask[srcoffset];
728: if (numbits <= srcoffset) {
729: chhi = (chhi & _lomask[numbits]) << lobits;
730: *dst = (*dst & _himask[lobits + numbits]) | chlo | chhi;
731: break;
732: }
733: chhi = chhi << lobits;
734: *(dst++) = chhi | chlo;
735: numbits = numbits - srcoffset;
736: }
737: }
738: #endif
739:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.