VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/x11include/xorg-server-1.5.3/maskbits.h@ 99743

Last change on this file since 99743 was 17471, checked in by vboxsync, 16 years ago

export to OSE

  • Property svn:eol-style set to native
File size: 20.8 KB
Line 
1/* Combined Purdue/PurduePlus patches, level 2.1, 1/24/89 */
2/***********************************************************
3Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
4
5 All Rights Reserved
6
7Permission to use, copy, modify, and distribute this software and its
8documentation for any purpose and without fee is hereby granted,
9provided that the above copyright notice appear in all copies and that
10both that copyright notice and this permission notice appear in
11supporting documentation, and that the name of Digital not be
12used in advertising or publicity pertaining to distribution of the
13software without specific, written prior permission.
14
15DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
16ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
17DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
18ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
19WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
20ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
21SOFTWARE.
22
23******************************************************************/
24
25#ifdef HAVE_DIX_CONFIG_H
26#include <dix-config.h>
27#endif
28
29#include <X11/X.h>
30#include <X11/Xmd.h>
31#include "servermd.h"
32
33
34/* the following notes use the following conventions:
35SCREEN LEFT SCREEN RIGHT
36in this file and maskbits.c, left and right refer to screen coordinates,
37NOT bit numbering in registers.
38
39starttab[n]
40 bits[0,n-1] = 0 bits[n,PLST] = 1
41endtab[n] =
42 bits[0,n-1] = 1 bits[n,PLST] = 0
43
44startpartial[], endpartial[]
45 these are used as accelerators for doing putbits and masking out
46bits that are all contained between longword boudaries. the extra
47256 bytes of data seems a small price to pay -- code is smaller,
48and narrow things (e.g. window borders) go faster.
49
50the names may seem misleading; they are derived not from which end
51of the word the bits are turned on, but at which end of a scanline
52the table tends to be used.
53
54look at the tables and macros to understand boundary conditions.
55(careful readers will note that starttab[n] = ~endtab[n] for n != 0)
56
57-----------------------------------------------------------------------
58these two macros depend on the screen's bit ordering.
59in both of them x is a screen position. they are used to
60combine bits collected from multiple longwords into a
61single destination longword, and to unpack a single
62source longword into multiple destinations.
63
64SCRLEFT(dst, x)
65 takes dst[x, PPW] and moves them to dst[0, PPW-x]
66 the contents of the rest of dst are 0.
67 this is a right shift on LSBFirst (forward-thinking)
68 machines like the VAX, and left shift on MSBFirst
69 (backwards) machines like the 680x0 and pc/rt.
70
71SCRRIGHT(dst, x)
72 takes dst[0,x] and moves them to dst[PPW-x, PPW]
73 the contents of the rest of dst are 0.
74 this is a left shift on LSBFirst, right shift
75 on MSBFirst.
76
77
78the remaining macros are cpu-independent; all bit order dependencies
79are built into the tables and the two macros above.
80
81maskbits(x, w, startmask, endmask, nlw)
82 for a span of width w starting at position x, returns
83a mask for ragged bits at start, mask for ragged bits at end,
84and the number of whole longwords between the ends.
85
86maskpartialbits(x, w, mask)
87 works like maskbits(), except all the bits are in the
88 same longword (i.e. (x&PIM + w) <= PPW)
89
90maskPPWbits(x, w, startmask, endmask, nlw)
91 as maskbits, but does not calculate nlw. it is used by
92 mfbGlyphBlt to put down glyphs <= PPW bits wide.
93
94-------------------------------------------------------------------
95
96NOTE
97 any pointers passed to the following 4 macros are
98 guranteed to be PPW-bit aligned.
99 The only non-PPW-bit-aligned references ever made are
100 to font glyphs, and those are made with getleftbits()
101 and getshiftedleftbits (qq.v.)
102
103 For 64-bit server, it is assumed that we will never have font padding
104 of more than 4 bytes. The code uses int's to access the fonts
105 intead of longs.
106
107getbits(psrc, x, w, dst)
108 starting at position x in psrc (x < PPW), collect w
109 bits and put them in the screen left portion of dst.
110 psrc is a longword pointer. this may span longword boundaries.
111 it special-cases fetching all w bits from one longword.
112
113 +--------+--------+ +--------+
114 | | m |n| | ==> | m |n| |
115 +--------+--------+ +--------+
116 x x+w 0 w
117 psrc psrc+1 dst
118 m = PPW - x
119 n = w - m
120
121 implementation:
122 get m bits, move to screen-left of dst, zeroing rest of dst;
123 get n bits from next word, move screen-right by m, zeroing
124 lower m bits of word.
125 OR the two things together.
126
127putbits(src, x, w, pdst)
128 starting at position x in pdst, put down the screen-leftmost
129 w bits of src. pdst is a longword pointer. this may
130 span longword boundaries.
131 it special-cases putting all w bits into the same longword.
132
133 +--------+ +--------+--------+
134 | m |n| | ==> | | m |n| |
135 +--------+ +--------+--------+
136 0 w x x+w
137 dst pdst pdst+1
138 m = PPW - x
139 n = w - m
140
141 implementation:
142 get m bits, shift screen-right by x, zero screen-leftmost x
143 bits; zero rightmost m bits of *pdst and OR in stuff
144 from before the semicolon.
145 shift src screen-left by m, zero bits n-PPW;
146 zero leftmost n bits of *(pdst+1) and OR in the
147 stuff from before the semicolon.
148
149putbitsrop(src, x, w, pdst, ROP)
150 like putbits but calls DoRop with the rasterop ROP (see mfb.h for
151 DoRop)
152
153putbitsrrop(src, x, w, pdst, ROP)
154 like putbits but calls DoRRop with the reduced rasterop ROP
155 (see mfb.h for DoRRop)
156
157-----------------------------------------------------------------------
158 The two macros below are used only for getting bits from glyphs
159in fonts, and glyphs in fonts are gotten only with the following two
160mcros.
161 You should tune these macros toyour font format and cpu
162byte ordering.
163
164NOTE
165getleftbits(psrc, w, dst)
166 get the leftmost w (w<=32) bits from *psrc and put them
167 in dst. this is used by the mfbGlyphBlt code for glyphs
168 <=PPW bits wide.
169 psrc is declared (unsigned char *)
170
171 psrc is NOT guaranteed to be PPW-bit aligned. on many
172 machines this will cause problems, so there are several
173 versions of this macro.
174
175 this macro is called ONLY for getting bits from font glyphs,
176 and depends on the server-natural font padding.
177
178 for blazing text performance, you want this macro
179 to touch memory as infrequently as possible (e.g.
180 fetch longwords) and as efficiently as possible
181 (e.g. don't fetch misaligned longwords)
182
183getshiftedleftbits(psrc, offset, w, dst)
184 used by the font code; like getleftbits, but shifts the
185 bits SCRLEFT by offset.
186 this is implemented portably, calling getleftbits()
187 and SCRLEFT().
188 psrc is declared (unsigned char *).
189*/
190
191/* to match CFB and allow algorithm sharing ...
192 * name mfb32 mfb64 explanation
193 * ---- ------ ----- -----------
194 * PGSZ 32 64 pixel group size (in bits; same as PPW for mfb)
195 * PGSZB 4 8 pixel group size (in bytes)
196 * PPW 32 64 pixels per word (pixels per pixel group)
197 * PLST 31 63 index of last pixel in a word (should be PPW-1)
198 * PIM 0x1f 0x3f pixel index mask (index within a pixel group)
199 * PWSH 5 6 pixel-to-word shift (should be log2(PPW))
200 *
201 * The MFB_ versions are here so that cfb can include maskbits.h to get
202 * the bitmap constants without conflicting with its own P* constants.
203 *
204 * Keith Packard ([email protected]):
205 * Note mfb64 is no longer supported; it requires DIX support
206 * for realigning images which costs too much
207 */
208
209/* warning: PixelType definition duplicated in mfb.h */
210#ifndef PixelType
211#define PixelType CARD32
212#endif /* PixelType */
213#ifndef MfbBits
214#define MfbBits CARD32
215#endif
216
217#define MFB_PGSZB 4
218#define MFB_PPW (MFB_PGSZB<<3) /* assuming 8 bits per byte */
219#define MFB_PGSZ MFB_PPW
220#define MFB_PLST (MFB_PPW-1)
221#define MFB_PIM MFB_PLST
222
223/* set PWSH = log2(PPW) using brute force */
224
225#if MFB_PPW == 32
226#define MFB_PWSH 5
227#endif /* MFB_PPW == 32 */
228
229/* XXX don't use these five */
230extern PixelType starttab[];
231extern PixelType endtab[];
232extern PixelType partmasks[MFB_PPW][MFB_PPW];
233extern PixelType rmask[];
234extern PixelType mask[];
235/* XXX use these five */
236extern PixelType mfbGetstarttab(int);
237extern PixelType mfbGetendtab(int);
238extern PixelType mfbGetpartmasks(int, int);
239extern PixelType mfbGetrmask(int);
240extern PixelType mfbGetmask(int);
241
242#ifndef MFB_CONSTS_ONLY
243
244#define PGSZB MFB_PGSZB
245#define PPW MFB_PPW
246#define PGSZ MFB_PGSZ
247#define PLST MFB_PLST
248#define PIM MFB_PIM
249#define PWSH MFB_PWSH
250
251#define BitLeft(b,s) SCRLEFT(b,s)
252#define BitRight(b,s) SCRRIGHT(b,s)
253
254#if 1
255#define LONG2CHARSSAMEORDER(x) ((MfbBits)(x))
256#define LONG2CHARSDIFFORDER( x ) ( ( ( ( x ) & (MfbBits)0x000000FF ) << 0x18 ) \
257 | ( ( ( x ) & (MfbBits)0x0000FF00 ) << 0x08 ) \
258 | ( ( ( x ) & (MfbBits)0x00FF0000 ) >> 0x08 ) \
259 | ( ( ( x ) & (MfbBits)0xFF000000 ) >> 0x18 ) )
260#endif /* XFree86Server */
261
262#if (BITMAP_BIT_ORDER == IMAGE_BYTE_ORDER)
263#define LONG2CHARS(x) ((MfbBits)(x))
264#else
265/*
266 * the unsigned case below is for compilers like
267 * the Danbury C and i386cc
268 */
269#define LONG2CHARS( x ) ( ( ( ( x ) & (MfbBits)0x000000FF ) << 0x18 ) \
270 | ( ( ( x ) & (MfbBits)0x0000FF00 ) << 0x08 ) \
271 | ( ( ( x ) & (MfbBits)0x00FF0000 ) >> 0x08 ) \
272 | ( ( ( x ) & (MfbBits)0xFF000000 ) >> 0x18 ) )
273#endif /* BITMAP_BIT_ORDER */
274
275#ifdef STRICT_ANSI_SHIFT
276#define SHL(x,y) ((y) >= PPW ? 0 : LONG2CHARS(LONG2CHARS(x) << (y)))
277#define SHR(x,y) ((y) >= PPW ? 0 : LONG2CHARS(LONG2CHARS(x) >> (y)))
278#else
279#define SHL(x,y) LONG2CHARS(LONG2CHARS(x) << (y))
280#define SHR(x,y) LONG2CHARS(LONG2CHARS(x) >> (y))
281#endif
282
283#if (BITMAP_BIT_ORDER == MSBFirst) /* pc/rt, 680x0 */
284#define SCRLEFT(lw, n) SHL((PixelType)(lw),(n))
285#define SCRRIGHT(lw, n) SHR((PixelType)(lw),(n))
286#else /* vax, intel */
287#define SCRLEFT(lw, n) SHR((PixelType)(lw),(n))
288#define SCRRIGHT(lw, n) SHL((PixelType)(lw),(n))
289#endif
290
291#define DoRRop(alu, src, dst) \
292(((alu) == RROP_BLACK) ? ((dst) & ~(src)) : \
293 ((alu) == RROP_WHITE) ? ((dst) | (src)) : \
294 ((alu) == RROP_INVERT) ? ((dst) ^ (src)) : \
295 (dst))
296
297/* A generalized form of a x4 Duff's Device */
298#define Duff(counter, block) { \
299 while (counter >= 4) {\
300 { block; } \
301 { block; } \
302 { block; } \
303 { block; } \
304 counter -= 4; \
305 } \
306 switch (counter & 3) { \
307 case 3: { block; } \
308 case 2: { block; } \
309 case 1: { block; } \
310 case 0: \
311 counter = 0; \
312 } \
313}
314
315#define maskbits(x, w, startmask, endmask, nlw) \
316 startmask = mfbGetstarttab((x) & PIM); \
317 endmask = mfbGetendtab(((x)+(w)) & PIM); \
318 if (startmask) \
319 nlw = (((w) - (PPW - ((x) & PIM))) >> PWSH); \
320 else \
321 nlw = (w) >> PWSH;
322
323#define maskpartialbits(x, w, mask) \
324 mask = mfbGetpartmasks((x) & PIM, (w) & PIM);
325
326#define maskPPWbits(x, w, startmask, endmask) \
327 startmask = mfbGetstarttab((x) & PIM); \
328 endmask = mfbGetendtab(((x)+(w)) & PIM);
329
330#ifdef __GNUC__ /* XXX don't want for Alpha? */
331#ifdef vax
332#define FASTGETBITS(psrc,x,w,dst) \
333 __asm ("extzv %1,%2,%3,%0" \
334 : "=g" (dst) \
335 : "g" (x), "g" (w), "m" (*(char *)(psrc)))
336#define getbits(psrc,x,w,dst) FASTGETBITS(psrc,x,w,dst)
337
338#define FASTPUTBITS(src, x, w, pdst) \
339 __asm ("insv %3,%1,%2,%0" \
340 : "=m" (*(char *)(pdst)) \
341 : "g" (x), "g" (w), "g" (src))
342#define putbits(src, x, w, pdst) FASTPUTBITS(src, x, w, pdst)
343#endif /* vax */
344#ifdef mc68020
345#define FASTGETBITS(psrc, x, w, dst) \
346 __asm ("bfextu %3{%1:%2},%0" \
347 : "=d" (dst) : "di" (x), "di" (w), "o" (*(char *)(psrc)))
348
349#define getbits(psrc,x,w,dst) \
350{ \
351 FASTGETBITS(psrc, x, w, dst);\
352 dst = SHL(dst,(32-(w))); \
353}
354
355#define FASTPUTBITS(src, x, w, pdst) \
356 __asm ("bfins %3,%0{%1:%2}" \
357 : "=o" (*(char *)(pdst)) \
358 : "di" (x), "di" (w), "d" (src), "0" (*(char *) (pdst)))
359
360#define putbits(src, x, w, pdst) FASTPUTBITS(SHR((src),32-(w)), x, w, pdst)
361
362#endif /* mc68020 */
363#endif /* __GNUC__ */
364
365/* The following flag is used to override a bugfix for sun 3/60+CG4 machines,
366 */
367
368/* We don't need to be careful about this unless we're dealing with sun3's
369 * We will default its usage for those who do not know anything, but will
370 * override its effect if the machine doesn't look like a sun3
371 */
372#if !defined(mc68020) || !defined(sun)
373#define NO_3_60_CG4
374#endif
375
376/* This is gross. We want to #define u_putbits as something which can be used
377 * in the case of the 3/60+CG4, but if we use /bin/cc or are on another
378 * machine type, we want nothing to do with u_putbits. What a hastle. Here
379 * I used slo_putbits as something which either u_putbits or putbits could be
380 * defined as.
381 *
382 * putbits gets it iff it is not already defined with FASTPUTBITS above.
383 * u_putbits gets it if we have FASTPUTBITS (putbits) from above and have not
384 * overridden the NO_3_60_CG4 flag.
385 */
386
387#define slo_putbits(src, x, w, pdst) \
388{ \
389 register int n = (x)+(w)-PPW; \
390 \
391 if (n <= 0) \
392 { \
393 register PixelType tmpmask; \
394 maskpartialbits((x), (w), tmpmask); \
395 *(pdst) = (*(pdst) & ~tmpmask) | \
396 (SCRRIGHT(src, x) & tmpmask); \
397 } \
398 else \
399 { \
400 register int d = PPW-(x); \
401 *(pdst) = (*(pdst) & mfbGetendtab(x)) | (SCRRIGHT((src), x)); \
402 (pdst)[1] = ((pdst)[1] & mfbGetstarttab(n)) | \
403 (SCRLEFT(src, d) & mfbGetendtab(n)); \
404 } \
405}
406
407#if defined(putbits) && !defined(NO_3_60_CG4)
408#define u_putbits(src, x, w, pdst) slo_putbits(src, x, w, pdst)
409#else
410#define u_putbits(src, x, w, pdst) putbits(src, x, w, pdst)
411#endif
412
413#if !defined(putbits)
414#define putbits(src, x, w, pdst) slo_putbits(src, x, w, pdst)
415#endif
416
417/* Now if we have not gotten any really good bitfield macros, try some
418 * moderately fast macros. Alas, I don't know how to do asm instructions
419 * without gcc.
420 */
421
422#ifndef getbits
423#define getbits(psrc, x, w, dst) \
424{ \
425 dst = SCRLEFT(*(psrc), (x)); \
426 if ( ((x) + (w)) > PPW) \
427 dst |= (SCRRIGHT(*((psrc)+1), PPW-(x))); \
428}
429#endif
430
431/* We have to special-case putbitsrop because of 3/60+CG4 combos
432 */
433
434#define u_putbitsrop(src, x, w, pdst, rop) \
435{\
436 register PixelType t1, t2; \
437 register int n = (x)+(w)-PPW; \
438 \
439 t1 = SCRRIGHT((src), (x)); \
440 DoRop(t2, rop, t1, *(pdst)); \
441 \
442 if (n <= 0) \
443 { \
444 register PixelType tmpmask; \
445 \
446 maskpartialbits((x), (w), tmpmask); \
447 *(pdst) = (*(pdst) & ~tmpmask) | (t2 & tmpmask); \
448 } \
449 else \
450 { \
451 int m = PPW-(x); \
452 *(pdst) = (*(pdst) & mfbGetendtab(x)) | (t2 & mfbGetstarttab(x)); \
453 t1 = SCRLEFT((src), m); \
454 DoRop(t2, rop, t1, (pdst)[1]); \
455 (pdst)[1] = ((pdst)[1] & mfbGetstarttab(n)) | (t2 & mfbGetendtab(n)); \
456 } \
457}
458
459/* If our getbits and putbits are FAST enough,
460 * do this brute force, it's faster
461 */
462
463#if defined(FASTPUTBITS) && defined(FASTGETBITS) && defined(NO_3_60_CG4)
464#if (BITMAP_BIT_ORDER == MSBFirst)
465#define putbitsrop(src, x, w, pdst, rop) \
466{ \
467 register PixelType _tmp, _tmp2; \
468 FASTGETBITS(pdst, x, w, _tmp); \
469 _tmp2 = SCRRIGHT(src, PPW-(w)); \
470 DoRop(_tmp, rop, _tmp2, _tmp) \
471 FASTPUTBITS(_tmp, x, w, pdst); \
472}
473#define putbitsrrop(src, x, w, pdst, rop) \
474{ \
475 register PixelType _tmp, _tmp2; \
476 \
477 FASTGETBITS(pdst, x, w, _tmp); \
478 _tmp2 = SCRRIGHT(src, PPW-(w)); \
479 _tmp= DoRRop(rop, _tmp2, _tmp); \
480 FASTPUTBITS(_tmp, x, w, pdst); \
481}
482#undef u_putbitsrop
483#else
484#define putbitsrop(src, x, w, pdst, rop) \
485{ \
486 register PixelType _tmp; \
487 FASTGETBITS(pdst, x, w, _tmp); \
488 DoRop(_tmp, rop, src, _tmp) \
489 FASTPUTBITS(_tmp, x, w, pdst); \
490}
491#define putbitsrrop(src, x, w, pdst, rop) \
492{ \
493 register PixelType _tmp; \
494 \
495 FASTGETBITS(pdst, x, w, _tmp); \
496 _tmp= DoRRop(rop, src, _tmp); \
497 FASTPUTBITS(_tmp, x, w, pdst); \
498}
499#undef u_putbitsrop
500#endif
501#endif
502
503#ifndef putbitsrop
504#define putbitsrop(src, x, w, pdst, rop) u_putbitsrop(src, x, w, pdst, rop)
505#endif
506
507#ifndef putbitsrrop
508#define putbitsrrop(src, x, w, pdst, rop) \
509{\
510 register PixelType t1, t2; \
511 register int n = (x)+(w)-PPW; \
512 \
513 t1 = SCRRIGHT((src), (x)); \
514 t2 = DoRRop(rop, t1, *(pdst)); \
515 \
516 if (n <= 0) \
517 { \
518 register PixelType tmpmask; \
519 \
520 maskpartialbits((x), (w), tmpmask); \
521 *(pdst) = (*(pdst) & ~tmpmask) | (t2 & tmpmask); \
522 } \
523 else \
524 { \
525 int m = PPW-(x); \
526 *(pdst) = (*(pdst) & mfbGetendtab(x)) | (t2 & mfbGetstarttab(x)); \
527 t1 = SCRLEFT((src), m); \
528 t2 = DoRRop(rop, t1, (pdst)[1]); \
529 (pdst)[1] = ((pdst)[1] & mfbGetstarttab(n)) | (t2 & mfbGetendtab(n)); \
530 } \
531}
532#endif
533
534#if GETLEFTBITS_ALIGNMENT == 1
535#define getleftbits(psrc, w, dst) dst = *((CARD32 *)(pointer) psrc)
536#endif /* GETLEFTBITS_ALIGNMENT == 1 */
537
538#if GETLEFTBITS_ALIGNMENT == 2
539#define getleftbits(psrc, w, dst) \
540 { \
541 if ( ((int)(psrc)) & 0x01 ) \
542 getbits( ((CARD32 *)(((char *)(psrc))-1)), 8, (w), (dst) ); \
543 else \
544 getbits(psrc, 0, w, dst); \
545 }
546#endif /* GETLEFTBITS_ALIGNMENT == 2 */
547
548#if GETLEFTBITS_ALIGNMENT == 4
549#define getleftbits(psrc, w, dst) \
550 { \
551 int off, off_b; \
552 off_b = (off = ( ((int)(psrc)) & 0x03)) << 3; \
553 getbits( \
554 (CARD32 *)( ((char *)(psrc)) - off), \
555 (off_b), (w), (dst) \
556 ); \
557 }
558#endif /* GETLEFTBITS_ALIGNMENT == 4 */
559
560
561#define getshiftedleftbits(psrc, offset, w, dst) \
562 getleftbits((psrc), (w), (dst)); \
563 dst = SCRLEFT((dst), (offset));
564
565/* FASTGETBITS and FASTPUTBITS are not necessarily correct implementations of
566 * getbits and putbits, but they work if used together.
567 *
568 * On a MSBFirst machine, a cpu bitfield extract instruction (like bfextu)
569 * could normally assign its result to a 32-bit word register in the screen
570 * right position. This saves canceling register shifts by not fighting the
571 * natural cpu byte order.
572 *
573 * Unfortunately, these fail on a 3/60+CG4 and cannot be used unmodified. Sigh.
574 */
575#if defined(FASTGETBITS) && defined(FASTPUTBITS)
576#ifdef NO_3_60_CG4
577#define u_FASTPUT(aa, bb, cc, dd) FASTPUTBITS(aa, bb, cc, dd)
578#else
579#define u_FASTPUT(aa, bb, cc, dd) u_putbits(SCRLEFT(aa, PPW-(cc)), bb, cc, dd)
580#endif
581
582#define getandputbits(psrc, srcbit, dstbit, width, pdst) \
583{ \
584 register PixelType _tmpbits; \
585 FASTGETBITS(psrc, srcbit, width, _tmpbits); \
586 u_FASTPUT(_tmpbits, dstbit, width, pdst); \
587}
588
589#define getandputrop(psrc, srcbit, dstbit, width, pdst, rop) \
590{ \
591 register PixelType _tmpsrc, _tmpdst; \
592 FASTGETBITS(pdst, dstbit, width, _tmpdst); \
593 FASTGETBITS(psrc, srcbit, width, _tmpsrc); \
594 DoRop(_tmpdst, rop, _tmpsrc, _tmpdst); \
595 u_FASTPUT(_tmpdst, dstbit, width, pdst); \
596}
597
598#define getandputrrop(psrc, srcbit, dstbit, width, pdst, rop) \
599{ \
600 register PixelType _tmpsrc, _tmpdst; \
601 FASTGETBITS(pdst, dstbit, width, _tmpdst); \
602 FASTGETBITS(psrc, srcbit, width, _tmpsrc); \
603 _tmpdst = DoRRop(rop, _tmpsrc, _tmpdst); \
604 u_FASTPUT(_tmpdst, dstbit, width, pdst); \
605}
606
607#define getandputbits0(psrc, srcbit, width, pdst) \
608 getandputbits(psrc, srcbit, 0, width, pdst)
609
610#define getandputrop0(psrc, srcbit, width, pdst, rop) \
611 getandputrop(psrc, srcbit, 0, width, pdst, rop)
612
613#define getandputrrop0(psrc, srcbit, width, pdst, rop) \
614 getandputrrop(psrc, srcbit, 0, width, pdst, rop)
615
616
617#else /* Slow poke */
618
619/* pairs of getbits/putbits happen frequently. Some of the code can
620 * be shared or avoided in a few specific instances. It gets us a
621 * small advantage, so we do it. The getandput...0 macros are the only ones
622 * which speed things here. The others are here for compatibility w/the above
623 * FAST ones
624 */
625
626#define getandputbits(psrc, srcbit, dstbit, width, pdst) \
627{ \
628 register PixelType _tmpbits; \
629 getbits(psrc, srcbit, width, _tmpbits); \
630 putbits(_tmpbits, dstbit, width, pdst); \
631}
632
633#define getandputrop(psrc, srcbit, dstbit, width, pdst, rop) \
634{ \
635 register PixelType _tmpbits; \
636 getbits(psrc, srcbit, width, _tmpbits) \
637 putbitsrop(_tmpbits, dstbit, width, pdst, rop) \
638}
639
640#define getandputrrop(psrc, srcbit, dstbit, width, pdst, rop) \
641{ \
642 register PixelType _tmpbits; \
643 getbits(psrc, srcbit, width, _tmpbits) \
644 putbitsrrop(_tmpbits, dstbit, width, pdst, rop) \
645}
646
647
648#define getandputbits0(psrc, sbindex, width, pdst) \
649{ /* unroll the whole damn thing to see how it * behaves */ \
650 register int _flag = PPW - (sbindex); \
651 register PixelType _src; \
652 \
653 _src = SCRLEFT (*(psrc), (sbindex)); \
654 if ((width) > _flag) \
655 _src |= SCRRIGHT (*((psrc) + 1), _flag); \
656 \
657 *(pdst) = (*(pdst) & mfbGetstarttab((width))) | (_src & mfbGetendtab((width))); \
658}
659
660
661#define getandputrop0(psrc, sbindex, width, pdst, rop) \
662{ \
663 register int _flag = PPW - (sbindex); \
664 register PixelType _src; \
665 \
666 _src = SCRLEFT (*(psrc), (sbindex)); \
667 if ((width) > _flag) \
668 _src |= SCRRIGHT (*((psrc) + 1), _flag); \
669 DoRop(_src, rop, _src, *(pdst)); \
670 \
671 *(pdst) = (*(pdst) & mfbGetstarttab((width))) | (_src & mfbGetendtab((width))); \
672}
673
674#define getandputrrop0(psrc, sbindex, width, pdst, rop) \
675{ \
676 int _flag = PPW - (sbindex); \
677 register PixelType _src; \
678 \
679 _src = SCRLEFT (*(psrc), (sbindex)); \
680 if ((width) > _flag) \
681 _src |= SCRRIGHT (*((psrc) + 1), _flag); \
682 _src = DoRRop(rop, _src, *(pdst)); \
683 \
684 *(pdst) = (*(pdst) & mfbGetstarttab((width))) | (_src & mfbGetendtab((width))); \
685}
686
687#endif /* FASTGETBITS && FASTPUTBITS */
688
689#endif /* MFB_CONSTS_ONLY */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette