![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitblt_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / bitblt|
Return to bitblt_subr.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / bitblt |
1.1 root 1: #ifndef lint
2: static char *rcsid_bitblt_subr_c = "$Header: bitblt_subr.c,v 10.1 86/11/19 10:51:21 jg Exp $";
3: #endif lint
4: /*
5: * Copyright (c) 1986 Brown University
6: *
7: * Permission to use, copy, modify and distribute this software and its
8: * documentation for any purpose and without fee is hereby granted, provided
9: * that the above copyright notice appear in all copies, and that both
10: * that copyright notice and this permission notice appear in supporting
11: * documentation, and that the name of Brown University not be used in
12: * advertising or publicity pertaining to distribution of the software without
13: * specific, written prior permission. Brown University makes no
14: * representations about the suitability of this software for any purpose.
15: * It is provided "as-is" without express or implied warranty.
16: *
17: * Written by Daniel Stone, Brown University/IRIS (des@iris)
18: */
19:
20: /*
21: * CURRENT HISTORY:
22: *
23: * $Log: bitblt_subr.c,v $
24: * Revision 10.1 86/11/19 10:51:21 jg
25: * Device dependent code for IBM displays. General blitter...
26: *
27: * Revision 4.0 86/09/25 10:03:10 des
28: * Version 4.0. Works with all IBM screens.
29: *
30: * Revision 3.6 86/09/22 16:47:44 des
31: * Added a third argument to blt_init.
32: *
33: * Revision 3.5 86/09/22 13:37:29 des
34: * Version 3.5. Removed all ifdef's that did not pertain to X.
35: *
36: * Revision 3.0 86/09/17 10:29:59 des
37: * Version 3.0. Works but has ifdef's for all systems.
38: *
39: * Revision 7.0 86/07/03 10:40:03 des
40: * Release 7.0.
41: *
42: * Revision 6.1 86/07/03 10:29:10 des
43: * Replaced certain mask rules.
44: *
45: * Revision 6.0 86/06/18 11:19:59 des
46: * Changed unsigned short pointers to unsigned char pointers for efficiency
47: * reasons. This change ment multiplying by 2 every variable added to
48: * these pointers.
49: *
50: * Revision 5.0 86/05/21 14:26:02 des
51: * Revision 5.0. No longer uses unsigned short pointers.
52: *
53: * Revision 4.7 86/05/15 16:03:45 des
54: * Latest and faster version of the new copyBitPos loop. Runs 5% to 7% faster
55: * than the old loop.
56: *
57: * Revision 4.6 86/05/14 10:54:46 des
58: * Changed smallcopyBitPos_LOOP so that it checks for 1 or 2 words changed
59: * and branches to that loop.
60: *
61: * Revision 4.5 86/05/14 10:31:57 des
62: * bitblt with NEW_LOOP (needs work.)
63: *
64: * Revision 4.0 86/05/09 13:52:25 des
65: * Revision 4.0. Apa-16 hardware enhancements Version 0.6.
66: *
67: * Revision 3.2 86/04/30 15:34:16 des
68: * This version has smallcopyBitPos and the old copyBitPos. The new copyBitPos
69: * took off .1 second on a 111 second blt. (new: 111.1 old:111.2) so what right?
70: * The old copyBitPos did not need smallcopyBitPos around so I figured it was
71: * better.
72: *
73: * Revision 2.2 86/04/29 16:31:53 des
74: * Added the smallcopyBitPos routine for speeding up small blts.
75: *
76: * Revision 3.0 86/04/28 16:59:20 des
77: * Runs with X. Version 0.5.
78: *
79: * Revision 2.2 86/04/09 09:36:41 des
80: * Fixed APA-8 and APA-8C software locator problem.
81: *
82: * Revision 2.1 86/04/04 12:19:38 des
83: * Moved copyBitNeg,copyBitPos,copyTile,maskBitNeg,maskBitPos,maskTile,
84: * clip_and_maskBitNeg,clip_and_maskBitPos and clip_and_maskTile to
85: * bitblt_subr.c.
86: */
87:
88: #ifndef lint
89: static char rcsid[] =
90: "$Header: bitblt_subr.c,v 10.1 86/11/19 10:51:21 jg Exp $ (Brown/IRIS)";
91: #endif
92:
93: #include "bitblt_int.h"
94:
95: /*
96: * Keep track of the first and one beyond the last address of the screen,
97: * so that current_screen.firstaddr <= some_base < current_screen.lastaddr
98: * is true if some_base is a pointer to a section of the screen.
99: */
100: Blt_screen_info blt_cur_screen;
101:
102: static Blt_Tile blt_black = {
103: 0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,
104: 0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff
105: };
106:
107: extern Blt_Rectangle changed_rect;/* describes the area changed by the bltter */
108:
109: /*
110: * Set 'ans' to the largest value and set 'diff' equal to the difference
111: * between 'ans' and 'a'.
112: */
113: #define max_a(a,b,c,ans,diff) { \
114: if (a >= b) { \
115: if (a >= c) { \
116: diff = 0; \
117: ans = a; \
118: } \
119: else { \
120: diff = c - a; \
121: ans = c; \
122: } \
123: } \
124: else if (b > c) { \
125: diff = b - a; \
126: ans = b; \
127: } \
128: else { \
129: diff = c - a; \
130: ans = c; \
131: } \
132: }
133:
134: /*
135: * Set 'ans' to the smallest value and set 'diff' equal to the difference
136: * between 'ans' and 'a'.
137: */
138: #define min_a(a,b,c,ans,diff) { \
139: if (a <= b) { \
140: if (a <= c) { \
141: diff = 0; \
142: ans = a; \
143: } \
144: else { \
145: diff = a - c; \
146: ans = c; \
147: } \
148: } \
149: else if (b < c) { \
150: diff = a - b; \
151: ans = b; \
152: } \
153: else { \
154: diff = a - c; \
155: ans = c; \
156: } \
157: }
158:
159: /*
160: * Initialize the bitblt so that it knows where in the address space the
161: * screen is and whether or not it uses a hardware or software cursor.
162: */
163: bitblt_init(screen_base,screen_wd,screen_ht,flags)
164: unsigned short *screen_base; /* The first address of the bitmap */
165: long screen_wd; /* Screen width in BITS (will round up) */
166: long screen_ht; /* Screen height in scan lines */
167: unsigned long flags; /* Indicates the type of cursor on the screen.*/
168: {
169: blt_cur_screen.firstaddr = screen_base;
170: blt_cur_screen.lastaddr = (unsigned short *)((long)screen_base +
171: (((screen_wd+7)/8) * screen_ht));
172: blt_cur_screen.cursortype = flags;
173: }
174:
175: /*
176: * Blt_setup takes information from the user data and creates data
177: * to be used internally. Specificly it creates clipped source rectangle
178: * if a source combination rule is given, a clipped destination rectangle
179: * the number of destination words to be changed across a scanline
180: * (nshorts) and masking bitmap rectangle masking is to be done.
181: * Finally the width and height and rule are filled in as width,
182: * height and rule.
183: *
184: * If a bad pointer was encountered (or something else is wrong) then
185: * blt_setup returns -1. Returns 0 if combination rule was a no-op and
186: * 1 if blt_setup finished ok.
187: */
188: blt_setup(u_info,s_info)
189: register Blt_userdata *u_info; /* User bitblt data */
190: register Blt_sysdata *s_info; /* bitblt internal data (This is modified
191: bitblt user data depending on the clipping
192: to be done. */
193: {
194: register int x_orig,y_orig;/* because the destination x,y origin
195: is used so much, it will be put in
196: registers. */
197: register int Oxdiff,Cxdiff;/* If the destination rectangle is clipped
198: then these variables contain the
199: difference between the destination
200: rectangle and the rectangle used
201: to clip. */
202: register int Oydiff,Cydiff;/* If the destination rectangle is clipped
203: then these variables contain the
204: difference between the destination
205: rectangle and the rectangle used
206: to clip. */
207:
208: DEBUGF((blt_debug > 1),
209: printf("Enter blt_setup.0x%x\r\n",u_info->blt_flags));
210:
211: /*
212: * Set up the internal bltters combination rule.
213: */
214: s_info->rule = u_info->comb_rule;
215:
216: /*
217: * Set a flag indicating that the rule uses the source.
218: */
219: s_info->is_src = IS_SRC(s_info->rule);
220:
221: /*
222: * Make sure s_info->tile_ptr = 0.
223: */
224: s_info->tile_ptr = (unsigned short *)0;
225:
226: /*
227: * Check the bltstruct to make sure every pointer is valid.
228: */
229: if (u_info == (Blt_userdata *)0) {
230: printf("Error: NULL bltstruct given!\n");
231: return(-1);
232: }
233:
234: if (u_info->dst_bitmap.base == (unsigned short *)0) {
235: printf("Error: NULL destination bitmap!\n");
236: return(-1);
237: }
238:
239: /*
240: * If a source combination rule was given and no bitmap was given then
241: * we assume the user wants US to assume that the source is infinitely
242: * large and is set to all one's. This is the same thing as using
243: * the coorisponding tile rule and an all black tile.
244: */
245: if (s_info->is_src && u_info->src_bitmap.base == (unsigned short *)0) {
246: s_info->is_src = 0;
247: s_info->rule += SRC_TO_TILE;
248: s_info->tile_ptr = &blt_black.tile[0];
249: }
250:
251: /*
252: * Check the rule and if its a no-op then return immediately.
253: */
254: if (s_info->rule == DstCopy || s_info->rule == TileDstCopy) {
255: return(0);
256: }
257:
258: if (u_info->blt_flags & BLT_CLIPON) {
259: /* DEBUGF(blt_debug,printf("Clip.\r\n")); */
260: /*
261: * Do some clipping. We clip to the clipping rectangle,
262: * the destination bitmap's rect and the destination
263: * rectangle. NOTE that if the destination rectangle
264: * is clipped in any way then the source rectangle must
265: * also be changed, thats why we keep track of the difference
266: * in Oxdiff.
267: *
268: * Set the origin to be a zero based coorinate system.
269: */
270: max_a(u_info->dst_rect.origin_x,
271: u_info->clp_rect.origin_x,
272: u_info->dst_bitmap.rect.origin_x,
273: x_orig,Oxdiff);
274:
275: x_orig -= u_info->dst_bitmap.rect.origin_x;
276:
277: /*
278: * Take the min value of the clipping rectangle X corner
279: * coord, bitmap rectangle X corner coord. and the
280: * destination rectangle X corner coord.. Cxdiff
281: * contains the difference between dst_rect.corner_x and
282: * the value returned. Then convert to a zero based
283: * coordinate system.
284: */
285: min_a(u_info->dst_rect.corner_x,
286: u_info->clp_rect.corner_x,
287: u_info->dst_bitmap.rect.corner_x,
288: s_info->dst.rect.corner_x,Cxdiff);
289:
290: s_info->dst.rect.corner_x -= u_info->dst_bitmap.rect.origin_x;
291:
292: /*
293: * Take the max value of the clipping rectangle Y origin
294: * coord, bitmap rectangle Y origin coord. and the
295: * destination rectangle Y origin coord.. Oydiff
296: * contains the difference between dst_rect.origin_y and
297: * the value returned. Then convert to a zero based
298: * coordinate system.
299: */
300: max_a(u_info->dst_rect.origin_y,
301: u_info->clp_rect.origin_y,
302: u_info->dst_bitmap.rect.origin_y,
303: y_orig,Oydiff);
304:
305: y_orig -= u_info->dst_bitmap.rect.origin_y;
306:
307: /*
308: * Take the min value of the clipping rectangle Y corner
309: * coord, bitmap rectangle Y corner coord. and the
310: * destination rectangle Y corner coord.. Cydiff
311: * contains the difference between dst_rect.corner_y and
312: * the value returned. Then convert to a zero based
313: * coordinate system.
314: */
315: min_a(u_info->dst_rect.corner_y,
316: u_info->clp_rect.corner_y,
317: u_info->dst_bitmap.rect.corner_y,
318: s_info->dst.rect.corner_y,Cydiff);
319:
320: s_info->dst.rect.corner_y -= u_info->dst_bitmap.rect.origin_y;
321: /*
322: * printf("dst:\t%4d,%4d,%4d,%4d\n",x_orig,
323: * y_orig,s_info->dst.rect.corner_x,
324: * s_info->dst.rect.corner_y);
325: * printf("diffs:\t%4d,%4d,%4d,%4d\n",Oxdiff,Oydiff,Cxdiff,Cydiff);
326: */
327:
328: /*
329: * Adjust source if necessary. (May only be using a tile.)
330: */
331: if (s_info->is_src) {
332: /*
333: * We may have done some clipping. If X was clipped
334: * then the section of the source that would have
335: * been mapped to the clipped section of the
336: * destination must also be clipped.
337: * In other words if one clips the destination one
338: * must also clip the source. Anyways 'Oxdiff' is set
339: * to the difference. Then we subtract the rect
340: * of the source bitmap so as to get the source into
341: * the same coordinate system as the destination,
342: * a zero based system.
343: */
344: s_info->src.rect.origin_x = u_info->src_rect.origin_x +
345: Oxdiff -
346: u_info->src_bitmap.rect.origin_x;
347:
348: /*
349: * If Y was clipped then the section of source
350: * that would have mapped to the clipped section
351: * of the destination must also be clipped.
352: */
353: s_info->src.rect.origin_y = u_info->src_rect.origin_y +
354: Oydiff -
355: u_info->src_bitmap.rect.origin_y;
356:
357: /*
358: * Now clip to the source bitmap's origin which is
359: * now 0,0 because we subtracted its origin above.
360: */
361: if (s_info->src.rect.origin_x < 0) {
362: /*
363: * The source rectangle has been clipped so
364: * the destination rectangle must also be
365: * clipped.
366: */
367: x_orig -= s_info->src.rect.origin_x;
368: s_info->src.rect.origin_x = 0;
369: }
370: if (s_info->src.rect.origin_y < 0) {
371: /*
372: * The source rectangle has been clipped so
373: * the destination rectangle must also be
374: * clipped.
375: */
376: y_orig -= s_info->src.rect.origin_y;
377: s_info->src.rect.origin_y = 0;
378: }
379:
380: /*
381: * Calculate the source rectangle's corner rect.
382: * NOTE: We are not setting these rect to a zero
383: * based system yet.
384: */
385: s_info->src.rect.corner_x = u_info->src_rect.corner_x -
386: Cxdiff;
387: s_info->src.rect.corner_y = u_info->src_rect.corner_y -
388: Cydiff;
389:
390: /*
391: * Clip these rect to the corner of the source
392: * bitmap corner rect.
393: */
394: if (s_info->src.rect.corner_x >
395: u_info->src_bitmap.rect.corner_x) {
396: s_info->src.rect.corner_x =
397: u_info->src_bitmap.rect.corner_x;
398: }
399: if (s_info->src.rect.corner_y >
400: u_info->src_bitmap.rect.corner_y) {
401: s_info->src.rect.corner_y =
402: u_info->src_bitmap.rect.corner_y;
403: }
404:
405: /*
406: * Now set these rect to a zero based coordinate
407: * system.
408: */
409: s_info->src.rect.corner_x -=
410: u_info->src_bitmap.rect.origin_x;
411: s_info->src.rect.corner_y -=
412: u_info->src_bitmap.rect.origin_y;
413:
414: /*
415: * Calculate the width in pixels of the blt area
416: * using the smaller of the two widths found in
417: * the source and destination rectangles.
418: */
419: if ((s_info->src.rect.corner_x -
420: s_info->src.rect.origin_x) >
421: (s_info->dst.rect.corner_x - x_orig)) {
422: s_info->width = s_info->dst.rect.corner_x -
423: x_orig;
424: }
425: else {
426: s_info->width = s_info->src.rect.corner_x -
427: s_info->src.rect.origin_x;
428:
429: /*
430: * Must change the destination corner.
431: */
432: s_info->dst.rect.corner_x = x_orig +
433: s_info->width;
434: }
435:
436: /*
437: * Calculate the height in scanlines of the blt area
438: * using the smaller of the two heights found in
439: * the source and destination rectangles.
440: */
441: if ((s_info->src.rect.corner_y -
442: s_info->src.rect.origin_y) >
443: (s_info->dst.rect.corner_y - y_orig)) {
444: s_info->height = s_info->dst.rect.corner_y -
445: y_orig;
446: }
447: else {
448: s_info->height = s_info->src.rect.corner_y -
449: s_info->src.rect.origin_y;
450:
451: /*
452: * Must change the destination corner.
453: */
454: s_info->dst.rect.corner_y = y_orig +
455: s_info->height;
456: }
457:
458: /*
459: * Set up source corners to BE CLOSED CORNERS.
460: * This is done because alot of -1's are being used in
461: * calculations of pointers when copying bitmaps from
462: * corner_y to origin_y, corner_x to origin_x.
463: * (for copyBitNeg(), see calculateOffsets())
464: */
465: s_info->src.rect.origin_x = s_info->src.rect.origin_x;
466: s_info->src.rect.origin_y = s_info->src.rect.origin_y;
467: s_info->src.rect.corner_x = s_info->src.rect.origin_x +
468: s_info->width - 1;
469: s_info->src.rect.corner_y = s_info->src.rect.origin_y +
470: s_info->height - 1;
471: }
472: else {
473: /*
474: * Calculate the width in pixels and the height in
475: * scanlines.
476: */
477: s_info->width = s_info->dst.rect.corner_x - x_orig;
478: s_info->height = s_info->dst.rect.corner_y - y_orig;
479: }
480: }
481: else {
482: /*
483: * Assume that the user has set everything up legally and
484: * all we have to do is set up our bltter (internal)
485: * coordinates.
486: *
487: * Set up the x origin and width.
488: */
489: x_orig = u_info->dst_rect.origin_x;
490: s_info->width = u_info->dst_rect.corner_x - x_orig;
491:
492: /*
493: * Set up y origin and height.
494: */
495: y_orig = u_info->dst_rect.origin_y;
496: s_info->height = u_info->dst_rect.corner_y - y_orig;
497:
498: /*
499: * Convert to zero based coordinate system.
500: */
501: x_orig -= u_info->dst_bitmap.rect.origin_x;
502: y_orig -= u_info->dst_bitmap.rect.origin_y;
503:
504: /*
505: * Set up the destination corners.
506: */
507: s_info->dst.rect.corner_x = x_orig + s_info->width;
508: s_info->dst.rect.corner_y = y_orig + s_info->height;
509:
510:
511: /*
512: * Adjust source if necessary. (May only be using a tile.)
513: */
514: if (s_info->is_src) {
515: /*
516: * We must have source and destination coordinates
517: * which are in the same coordinate system, a
518: * zero-based coordinate system in this case.
519: */
520: s_info->src.rect.origin_x = u_info->src_rect.origin_x -
521: u_info->src_bitmap.rect.origin_x;
522: s_info->src.rect.origin_y = u_info->src_rect.origin_y -
523: u_info->src_bitmap.rect.origin_y;
524:
525: /*
526: * Set up source corners to BE CLOSED CORNERS.
527: * This is done because alot of -1's are being used in
528: * calculations of pointers when copying bitmaps from
529: * corner_y to origin_y, corner_x to origin_x.
530: * (for copyBitNeg(), see calculateOffsets())
531: */
532: s_info->src.rect.corner_x = s_info->src.rect.origin_x +
533: s_info->width - 1;
534: s_info->src.rect.corner_y = s_info->src.rect.origin_y +
535: s_info->height - 1;
536: }
537: }
538:
539: /*
540: * Keep the final rectangle for outside use. (Others can extern
541: * changed_rect.)
542: */
543: changed_rect.origin_x = x_orig;
544: changed_rect.origin_y = y_orig;
545: changed_rect.corner_x = s_info->dst.rect.corner_x;
546: changed_rect.corner_y = s_info->dst.rect.corner_y;
547:
548: /*
549: * Set up destination corners to BE CLOSED CORNERS. This is done
550: * because alot of -1's are being used in calculations of pointers when
551: * copying bitmaps from corner_y to origin_y, corner_x to
552: * origin_x. (for copyBitNeg(), see calculateOffsets())
553: */
554: s_info->dst.rect.corner_x -= 1;
555: s_info->dst.rect.corner_y -= 1;
556:
557: /*
558: * Set up the number of words across the destination that will be
559: * affected. (Because we subracted one we don't have to subtract one
560: * from dst.rect.corner_x.)
561: */
562: if ((s_info->nshorts = (DIV_BPW(s_info->dst.rect.corner_x) -
563: DIV_BPW(x_orig)) + 1) < 1) {
564: /*
565: * nshorts should always be positive.
566: */
567: DEBUGF((blt_debug),
568: printf("dst cx,ox: %d,%d nshorts = %d - %d\n",
569: s_info->dst.rect.corner_x,x_orig,
570: DIV_BPW(s_info->dst.rect.corner_x),
571: DIV_BPW(x_orig)));
572: return(0);
573: }
574: DEBUGF((blt_debug),
575: printf("dst cx,ox: %d,%d nshorts = %d - %d, (IS %d)\n",
576: s_info->dst.rect.corner_x,x_orig,
577: DIV_BPW(s_info->dst.rect.corner_x),
578: DIV_BPW(x_orig),s_info->nshorts));
579:
580: /*
581: * NOTE: This program ASSUMES that msk_bitmap's bounds are within
582: * the bounds of the msk_bitmap. If not, bummer.
583: *
584: * Mask bitmap specified?? Set up mask corners.
585: */
586: if (u_info->blt_flags & BLT_MASKON) {
587: /*
588: * Currently, the msk_bitmap's rect is in destination
589: * coordinates and msk_bitmap.rect picks out the area of the
590: * mask to be used.
591: *
592: * Align the mask bitmap with the destination rectangle.
593: * Because the x_orig is zero based and the
594: * msk_bitmap box is not we add back the dst_bitmap.rect.
595: * This has the effect of putting the mask corners into
596: * a zero based coordinate system.
597: */
598: s_info->msk.rect.origin_x = x_orig +
599: u_info->dst_bitmap.rect.origin_x -
600: u_info->msk_bitmap.rect.origin_x;
601: s_info->msk.rect.corner_x = s_info->msk.rect.origin_x +
602: s_info->width - 1;
603: s_info->msk.rect.origin_y = y_orig +
604: u_info->dst_bitmap.rect.origin_y -
605: u_info->msk_bitmap.rect.origin_y;
606: s_info->msk.rect.corner_y = s_info->msk.rect.origin_y +
607: s_info->height - 1;
608:
609: /*
610: * At some point it may be smart to check the clip flag and
611: * clip this also.
612: *
613: * if (u_info->blt_flags & BLT_CLIPON) {
614: * }
615: */
616: }
617:
618: /*
619: * Set the temp varibles into the system data structure.
620: */
621: s_info->dst.rect.origin_x = x_orig;
622: s_info->dst.rect.origin_y = y_orig;
623:
624: return(1);
625: }
626:
627: /*
628: * This part of this file should be moved to another file someday.
629: */
630:
631: #define MSK_SKEW 0x01
632: #define SRC_SKEW 0x02
633:
634: /*
635: * Macros for the operations.
636: */
637:
638: #define SrcCopy_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
639: ((src) & mask)
640:
641: /*
642: * Old SrcOr rule.
643: * #define SrcOr_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
644: * (((dst) | (src)) & mask)
645: */
646: #define SrcOr_MASK(src,dst,mask) dst = ((dst) | ((src) & mask))
647:
648: /*
649: * Old SrcXor rule.
650: * #define SrcXor_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
651: * (((dst) ^ (src)) & mask)
652: */
653: #define SrcXor_MASK(src,dst,mask) dst = ((dst) ^ ((src) & mask))
654:
655: #define SrcAnd_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
656: (((dst) & (src)) & mask)
657:
658: #define NotSrcCopy_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
659: (~(src) & mask)
660:
661: /*
662: * Old NotSrcOr rule.
663: * #define NotSrcOr_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
664: * (((dst) | ~(src)) & mask)
665: */
666: #define NotSrcOr_MASK(src,dst,mask) dst = ((dst) | (~(src) & mask))
667:
668: /*
669: * Old NotSrcXor rule.
670: * #define NotSrcXor_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
671: * (((dst) ^ ~(src)) & mask)
672: */
673: #define NotSrcXor_MASK(src,dst,mask) dst = ((dst) ^ (~(src) & mask))
674:
675: #define NotSrcAnd_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
676: (((dst) & ~(src)) & mask)
677: /*
678: * DstCopy is a no-op.
679: */
680:
681: #define SrcAndNotDst_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
682: ((~(dst) & (src)) & mask)
683:
684: #define SrcOrNotDst_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
685: ((~(dst) | (src)) & mask)
686:
687: #define NotDstCopy_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
688: (~(dst) & (mask))
689:
690: #define NotSrcAndNotDst_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
691: ((~(dst) & ~(src)) & mask)
692:
693: #define NotSrcOrNotDst_MASK(src,dst,mask) dst = ((dst) & ~(mask)) | \
694: ((~(dst) | ~(src)) & mask)
695:
696: #define SrcCopy_OP(src,dst) dst = (src)
697: #define SrcOr_OP(src,dst) dst = (dst) | (src)
698: #define SrcXor_OP(src,dst) dst = (dst) ^ (src)
699: #define SrcAnd_OP(src,dst) dst = (dst) & (src)
700: #define NotSrcCopy_OP(src,dst) dst = ~(src)
701: #define NotSrcOr_OP(src,dst) dst = (dst) | ~(src)
702: #define NotSrcXor_OP(src,dst) dst = (dst) ^ ~(src)
703: #define NotSrcAnd_OP(src,dst) dst = (dst) & ~(src)
704: /*
705: * DstCopy is a no-op (dst = (dst)).
706: */
707: #define SrcOrNotDst_OP(src,dst) dst = (~(dst) | (src))
708: #define SrcAndNotDst_OP(src,dst) dst = (~(dst) & (src))
709: #define NotDstCopy_OP(src,dst) dst = ~(dst)
710: #define NotSrcOrNotDst_OP(src,dst) dst = (~(dst) | ~(src))
711: #define NotSrcAndNotDst_OP(src,dst) dst = (~(dst) & ~(src))
712:
713: /*
714: * Make the mask and operation macros for tiles.
715: */
716: #define TileCopy_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
717: ((tile) & mask)
718:
719: #define TileOr_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
720: (((dst) | (tile)) & mask)
721:
722: #define TileXor_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
723: (((dst) ^ (tile)) & mask)
724:
725: #define NotTileAnd_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
726: (((dst) & ~(tile)) & mask)
727:
728: #define NotTileCopy_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
729: (~(tile) & mask)
730:
731: #define NotTileOr_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
732: (((dst) | ~(tile)) & mask)
733:
734: #define NotTileXor_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
735: (((dst) ^ ~(tile)) & mask)
736:
737: #define TileAnd_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
738: (((dst) & (tile)) & mask)
739:
740: #define TileOrNotDst_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
741: ((~(dst) | (tile)) & mask)
742:
743: #define NotTileAndNotDst_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
744: ((~(dst) & ~(tile)) & mask)
745:
746: #define NotTileOrNotDst_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
747: ((~(dst) | ~(tile)) & mask)
748:
749: #define TileAndNotDst_MASK(tile,dst,mask) dst = ((dst) & ~(mask)) | \
750: ((~(dst) & (tile)) & mask)
751:
752: #define TileCopy_OP(tile,dst) dst = (tile)
753: #define TileOr_OP(tile,dst) dst = (dst) | (tile)
754: #define TileXor_OP(tile,dst) dst = (dst) ^ (tile)
755: #define NotTileAnd_OP(tile,dst) dst = (dst) & ~(tile)
756: #define NotTileCopy_OP(tile,dst) dst = ~(tile)
757: #define NotTileOr_OP(tile,dst) dst = (dst) | ~(tile)
758: #define NotTileXor_OP(tile,dst) dst = (dst) ^ ~(tile)
759: #define TileAnd_OP(tile,dst) dst = (dst) & (tile)
760:
761: #define TileOrNotDst_OP(tile,dst) dst = ~(dst) | (tile)
762: #define NotTileAndNotDst_OP(tile,dst) dst = ~(dst) & ~(tile)
763: #define NotTileOrNotDst_OP(tile,dst) dst = ~(dst) | ~(tile)
764: #define TileAndNotDst_OP(tile,dst) dst = ~(dst) & (tile)
765:
766: #if (APA8 || APA8C)
767: /*
768: * Defines for how a pointer is incremented. This is needed because one must
769: * increment a pointer to the APA-8 bitmap by 2.
770: */
771: #define DECR_SRC(src) src -= src_plus
772: #define DECR_DST(dst) dst -= dst_plus
773: #define INCR_SRC(src) src += src_plus
774: #define INCR_DST(dst) dst += dst_plus
775: #define MINUS_SRC(src) ((unsigned short *)(src - src_plus))
776: #define PLUS_SRC(src) ((unsigned short *)(src + src_plus))
777: #else no APA8 stuff
778: /*
779: * Defines for how normal pointers are incremented.
780: */
781: #define DECR_SRC(src) (src -= 2)
782: #define DECR_DST(dst) (dst -= 2)
783: #define INCR_SRC(src) (src += 2)
784: #define INCR_DST(dst) (dst += 2)
785: #define MINUS_SRC(src) ((unsigned short *)(src - 2))
786: #define PLUS_SRC(src) ((unsigned short *)(src + 2))
787: #endif
788:
789: #define SRC ((unsigned short *)src)
790: #define DST ((unsigned short *)dst)
791: #define TILE ((unsigned short *)tile)
792: #define MSK ((unsigned short *)msk)
793: #define CLP ((unsigned short *)clp)
794:
795: #define DECR_MSK(msk) (msk -= 2)
796: #define INCR_MSK(msk) (msk += 2)
797: #define MINUS_MSK(msk) ((unsigned short *)(msk - 2))
798: #define PLUS_MSK(msk) ((unsigned short *)(msk + 2))
799:
800: #define DECR_CLP(clp) (clp -= 2)
801: #define INCR_CLP(clp) (clp += 2)
802: #define MINUS_CLP(clp) ((unsigned short *)(clp - 2))
803: #define PLUS_CLP(clp) ((unsigned short *)(clp + 2))
804:
805: /*
806: * Macro to increment the tile pointer. If last_ptr is reached then the
807: * pointer is decremented back to the beginning of the tile struct.
808: */
809: #define INCR_TILE_PTR(ptr,last_ptr) ((ptr==last_ptr) ? (ptr -= 30) : (ptr += 2))
810:
811: /*
812: * This loop copies bits from right to left, bottom to top. It takes as
813: * arguments 1 of 8 masking macros and the coorisponding generic macro.
814: * The general scheme is this:
815: * Foreach row do
816: * Take care of the first word priming if necessary. (Done because
817: * the first word uses the RIGHT edge mask.)
818: *
819: * If there is a skew then (Means parts of 2 source words make one
820: * destination word.)
821: * For each word between the first and last word do
822: * Shift the source word and source word -1 and
823: * write the word to the destination.
824: * endfor
825: *
826: * Take care of the last word. (Done here and not in
827: * the loop because the last word uses the
828: * LEFT edge mask.)
829: *
830: * else The skew is zero meaning 1 source word per destination
831: * word.
832: *
833: * For each word between the first and last word do
834: * Write the source word into the destination word.
835: * endfor
836: *
837: * Take care of the last word. (Done here and not in
838: * the loop because the last word uses the
839: * LEFT edge mask.)
840: * endif
841: *
842: * DECREMENT the source and destination pointers to point to the
843: * next row.
844: * endfor
845: *
846: */
847: #define copyBitNeg_LOOP(EDGE_OP,OP) { \
848: while (--s_info->height) { \
849: wordnum = s_info->nshorts; \
850: if (s_info->preload_src) { \
851: EDGE_OP((*SRC >> skew_src) | \
852: (*(MINUS_SRC(src)) << (inv_skew_src)), \
853: *DST,s_info->right_mask); \
854: DECR_SRC(src); \
855: } \
856: else { \
857: EDGE_OP((*SRC << (inv_skew_src)),*DST, \
858: s_info->right_mask); \
859: } \
860: if (--wordnum != 0) { \
861: DECR_DST(dst); \
862: if (skew_src & 0xf) { \
863: while (wordnum > 1) { \
864: OP((*SRC >> skew_src) | \
865: (*(MINUS_SRC(src))<<(inv_skew_src)),\
866: *DST); \
867: DECR_SRC(src); \
868: DECR_DST(dst); \
869: wordnum--; \
870: } \
871: EDGE_OP((*SRC >> skew_src) | \
872: (*(MINUS_SRC(src)) << (inv_skew_src)),\
873: *DST,s_info->left_mask); \
874: DECR_SRC(src); \
875: } \
876: else { \
877: while (wordnum > 1) { \
878: DECR_SRC(src); \
879: OP(*SRC,*DST); \
880: DECR_DST(dst); \
881: wordnum--; \
882: } \
883: DECR_SRC(src); \
884: EDGE_OP(*SRC,*DST,s_info->left_mask); \
885: } \
886: } \
887: src -= s_info->src.nextline; \
888: dst -= s_info->dst.nextline; \
889: } \
890: }
891:
892: /*
893: * Do setup and dereferencing of 5 of the most important Blt_sysdata variables.
894: * Then do a switch on the combination rule to do the correct loop. Each loop
895: * copies from right to left, bottom to top.
896: */
897: copyBitNeg(s_info)
898: register Blt_sysdata *s_info;
899: {
900: register unsigned char *src; /* Register pointers are declared as */
901: /* unsigned char pointers. This is an */
902: register unsigned char *dst; /* optimization to get around extra */
903: /* addressing in the assembler. */
904: #if (APA8 || APA8C)
905: register int src_plus;
906: register int dst_plus;
907: #endif
908: register int wordnum;
909: register int skew_src;
910: register int inv_skew_src;
911:
912: #if (APA8 || APA8C)
913: src_plus = s_info->src_plus;
914: dst_plus = s_info->dst_plus;
915: #endif
916:
917: src = (unsigned char *)s_info->src.data;
918: dst = (unsigned char *)s_info->dst.data;
919:
920: /*
921: * Set up the inverted skew number which is used to shift stuff the
922: * other direction.
923: */
924: skew_src = s_info->skew_src;
925: inv_skew_src = BPW - skew_src;
926:
927: DEBUGF(blt_debug,
928: printf("Enter copyBitNeg s:%d,p:%d,ws:%d r:%d\r\n",
929: s_info->skew_src,s_info->preload_src,
930: s_info->nshorts,s_info->rule));
931:
932: /*
933: * Compiler optimization: a pre-decrement in a while loop saves a test
934: * in assembly language for every iteration.
935: */
936: s_info->height += 1;
937: switch (s_info->rule) {
938: case SrcCopy:
939: copyBitNeg_LOOP(SrcCopy_MASK,SrcCopy_OP);
940: break;
941:
942: case SrcOr:
943: copyBitNeg_LOOP(SrcOr_MASK,SrcOr_OP);
944: break;
945:
946: case SrcXor:
947: copyBitNeg_LOOP(SrcXor_MASK,SrcXor_OP);
948: break;
949:
950: case NotSrcAnd:
951: copyBitNeg_LOOP(NotSrcAnd_MASK,NotSrcAnd_OP);
952: break;
953:
954: case NotSrcCopy:
955: copyBitNeg_LOOP(NotSrcCopy_MASK,NotSrcCopy_OP);
956: break;
957:
958: case NotSrcOr:
959: copyBitNeg_LOOP(NotSrcOr_MASK,NotSrcOr_OP);
960: break;
961:
962: case NotSrcXor:
963: copyBitNeg_LOOP(NotSrcXor_MASK,NotSrcXor_OP);
964: break;
965:
966: case SrcAnd:
967: copyBitNeg_LOOP(SrcAnd_MASK,SrcAnd_OP);
968: break;
969:
970: case SrcAndNotDst:
971: copyBitNeg_LOOP(SrcAndNotDst_MASK,SrcAndNotDst_OP);
972: break;
973:
974: case NotSrcAndNotDst:
975: copyBitNeg_LOOP(NotSrcAndNotDst_MASK,NotSrcAndNotDst_OP);
976: break;
977:
978: case SrcOrNotDst:
979: copyBitNeg_LOOP(SrcOrNotDst_MASK,SrcOrNotDst_OP);
980: break;
981:
982: case NotSrcOrNotDst:
983: copyBitNeg_LOOP(NotSrcOrNotDst_MASK,NotSrcOrNotDst_OP);
984: break;
985:
986: default:
987: break;
988: }
989: }
990:
991: #if (APA8 || APA8C)
992: #define I_SRC src_plus
993: #define I_DST dst_plus
994: #else no APA8 stuff
995: #define I_SRC 2
996: #define I_DST 2
997: #endif
998:
999: /*
1000: * This loop copies bits from left to right, top to bottom. It takes as
1001: * arguments 1 of 8 masking macros and the coorisponding generic macro.
1002: * The general scheme is this:
1003: * Foreach row do
1004: * Take care of the first word priming if necessary. (Done because
1005: * the first word uses the LEFT edge mask.)
1006: *
1007: * If there is a skew then (Means parts of 2 source words make one
1008: * destination word.)
1009: * For each word between the first and last word do
1010: * Shift the source word and source word +1 and
1011: * write the word to the destination.
1012: * endfor
1013: *
1014: * Take care of the last word. (Done here and not in
1015: * the loop because the last word uses the
1016: * RIGHT edge mask.)
1017: *
1018: * else The skew is zero meaning 1 source word per destination
1019: * word.
1020: *
1021: * For each word between the first and last word do
1022: * Write the source word into the destination word
1023: * endfor
1024: *
1025: * Take care of the last word. (Done here and not in
1026: * the loop because the last word uses the
1027: * RIGHT edge mask.)
1028: * endif
1029: *
1030: * INCREMENT the source and destination pointers to point to the
1031: * next row.
1032: * endfor
1033: *
1034: */
1035: #define copyBitPos_LOOP(EDGE_OP,OP) { \
1036: while (--s_info->height) { \
1037: wordnum = s_info->nshorts; \
1038: if (s_info->preload_src) { \
1039: EDGE_OP((*SRC << skew_src) | \
1040: (*(PLUS_SRC(src)) >> (inv_skew_src)),*DST,\
1041: s_info->left_mask); \
1042: INCR_SRC(src); \
1043: } \
1044: else { \
1045: EDGE_OP((*SRC>>(inv_skew_src)),*DST,s_info->left_mask);\
1046: } \
1047: if (--wordnum != 0) { \
1048: INCR_DST(dst); \
1049: if (skew_src & 0xf) { \
1050: while (wordnum-- > 1) { \
1051: OP((*SRC << skew_src) | \
1052: (*(PLUS_SRC(src)) >> (inv_skew_src)),\
1053: *DST); \
1054: INCR_DST(dst); \
1055: INCR_SRC(src); \
1056: } \
1057: EDGE_OP((*SRC << skew_src) | \
1058: (*(PLUS_SRC(src)) >> (inv_skew_src)),\
1059: *DST,s_info->right_mask); \
1060: INCR_SRC(src); \
1061: } \
1062: else { \
1063: while (wordnum-- > 1) { \
1064: INCR_SRC(src); \
1065: OP(*SRC,*DST); \
1066: INCR_DST(dst); \
1067: } \
1068: INCR_SRC(src); \
1069: EDGE_OP(*SRC,*DST,s_info->right_mask); \
1070: } \
1071: } \
1072: src += s_info->src.nextline; \
1073: dst += s_info->dst.nextline; \
1074: } \
1075: }
1076:
1077: /*
1078: * Do setup and dereferencing of 5 of the most important Blt_sysdata variables.
1079: * Then do a switch on the combination rule to do the correct loop. Each loop
1080: * copies from left to right, top to bottom .
1081: */
1082: copyBitPos(s_info)
1083: register Blt_sysdata *s_info;
1084: {
1085: register unsigned char *src; /* Register pointers are declared as */
1086: /* unsigned char pointers. This is an */
1087: register unsigned char *dst; /* optimization to get around extra */
1088: /* addressing in the assembler. */
1089: #if (APA8 || APA8C)
1090: register int src_plus;
1091: register int dst_plus;
1092: #endif
1093: register int wordnum;
1094: register int skew_src;
1095: register int inv_skew_src;
1096:
1097: #if (APA8 || APA8C)
1098: src_plus = s_info->src_plus;
1099: dst_plus = s_info->dst_plus;
1100: #endif
1101: src = (unsigned char *)s_info->src.data;
1102: dst = (unsigned char *)s_info->dst.data;
1103:
1104: skew_src = s_info->skew_src;
1105: inv_skew_src = BPW - skew_src;
1106:
1107: DEBUGF(blt_debug,
1108: printf("Enter copyBitPos:%d,%d,%d,%d\r\n",s_info->skew_src,
1109: inv_skew_src,s_info->preload_src,s_info->rule));
1110:
1111: /*
1112: * foreach row do.
1113: *
1114: * Compiler optimization: a pre-decrement in a while loop saves a test
1115: * in assembly language for every iteration.
1116: */
1117: s_info->height += 1;
1118: switch (s_info->rule) {
1119: case SrcCopy:
1120: copyBitPos_LOOP(SrcCopy_MASK,SrcCopy_OP);
1121: break;
1122:
1123: case SrcOr:
1124: copyBitPos_LOOP(SrcOr_MASK,SrcOr_OP);
1125: break;
1126:
1127: case SrcXor:
1128: copyBitPos_LOOP(SrcXor_MASK,SrcXor_OP);
1129: break;
1130:
1131: case NotSrcAnd:
1132: copyBitPos_LOOP(NotSrcAnd_MASK,NotSrcAnd_OP);
1133: break;
1134:
1135: case NotSrcCopy:
1136: copyBitPos_LOOP(NotSrcCopy_MASK,NotSrcCopy_OP);
1137: break;
1138:
1139: case NotSrcOr:
1140: copyBitPos_LOOP(NotSrcOr_MASK,NotSrcOr_OP);
1141: break;
1142:
1143: case NotSrcXor:
1144: copyBitPos_LOOP(NotSrcXor_MASK,NotSrcXor_OP);
1145: break;
1146:
1147: case SrcAnd:
1148: copyBitPos_LOOP(SrcAnd_MASK,SrcAnd_OP);
1149: break;
1150:
1151: case SrcAndNotDst:
1152: copyBitPos_LOOP(SrcAndNotDst_MASK,SrcAndNotDst_OP);
1153: break;
1154:
1155: case NotSrcAndNotDst:
1156: copyBitPos_LOOP(NotSrcAndNotDst_MASK,NotSrcAndNotDst_OP);
1157: break;
1158:
1159: case SrcOrNotDst:
1160: copyBitPos_LOOP(SrcOrNotDst_MASK,SrcOrNotDst_OP);
1161: break;
1162:
1163: case NotSrcOrNotDst:
1164: copyBitPos_LOOP(NotSrcOrNotDst_MASK,NotSrcOrNotDst_OP);
1165: break;
1166:
1167: default:
1168: break;
1169: }
1170: }
1171:
1172: #define MYDEBUG_PR(n,s)
1173: #define smallcopyBitPos_LOOP(EDGE_OP,OP) { \
1174: if (s_info->preload_src) { \
1175: if (s_info->nshorts == 2) { \
1176: MYDEBUG_PR(blt_debug,printf("preload 2\r\n")); \
1177: while (--height) { \
1178: EDGE_OP((*SRC << skew_src) | \
1179: (*(PLUS_SRC(src)) >> (inv_skew_src)),\
1180: *DST,s_info->left_mask); \
1181: INCR_SRC(src); \
1182: INCR_DST(dst); \
1183: EDGE_OP((*SRC << skew_src) | \
1184: (*(PLUS_SRC(src)) >> (inv_skew_src)),\
1185: *DST,s_info->right_mask); \
1186: src += (s_info->src.nextline + I_SRC); \
1187: dst += s_info->dst.nextline; \
1188: } \
1189: } \
1190: else { \
1191: MYDEBUG_PR(blt_debug,printf("preload 1\r\n")); \
1192: while (--height) { \
1193: EDGE_OP((*SRC << skew_src) | \
1194: (*(PLUS_SRC(src)) >> (inv_skew_src)),\
1195: *DST,s_info->left_mask); \
1196: src += (s_info->src.nextline + I_SRC); \
1197: dst += s_info->dst.nextline; \
1198: } \
1199: } \
1200: } \
1201: else if (skew_src & 0xf) { \
1202: if (s_info->nshorts == 2) { \
1203: MYDEBUG_PR(blt_debug,printf("skew_src 2\r\n")); \
1204: while (--height) { \
1205: EDGE_OP((*SRC>>(inv_skew_src)), \
1206: *DST,s_info->left_mask); \
1207: INCR_DST(dst); \
1208: EDGE_OP((*SRC << skew_src) | \
1209: (*(PLUS_SRC(src)) >> (inv_skew_src)),\
1210: *DST,s_info->right_mask); \
1211: src += (s_info->src.nextline + I_SRC); \
1212: dst += s_info->dst.nextline; \
1213: } \
1214: } \
1215: else { \
1216: MYDEBUG_PR(blt_debug,printf("skew_src 1\r\n")); \
1217: while (--height) { \
1218: EDGE_OP((*SRC>>(inv_skew_src)), \
1219: *DST,s_info->left_mask); \
1220: src += s_info->src.nextline; \
1221: dst += s_info->dst.nextline; \
1222: } \
1223: } \
1224: } \
1225: else if (s_info->nshorts == 2) { \
1226: MYDEBUG_PR(blt_debug,printf("lines up 2\r\n")); \
1227: while (--height) { \
1228: EDGE_OP(*SRC,*DST,s_info->left_mask); \
1229: INCR_DST(dst); \
1230: INCR_SRC(src); \
1231: EDGE_OP(*SRC,*DST,s_info->right_mask); \
1232: src += s_info->src.nextline; \
1233: dst += s_info->dst.nextline; \
1234: } \
1235: } \
1236: else { \
1237: MYDEBUG_PR(blt_debug,printf("lines up 1\r\n")); \
1238: while (--height) { \
1239: EDGE_OP(*SRC,*DST,s_info->left_mask); \
1240: src += s_info->src.nextline; \
1241: dst += s_info->dst.nextline; \
1242: } \
1243: } \
1244: }
1245:
1246: /*
1247: * Do setup and dereferencing of 5 of the most important Blt_sysdata variables.
1248: * Then do a switch on the combination rule to do the correct loop. Each loop
1249: * copies from left to right, top to bottom .
1250: */
1251: smallcopyBitPos(s_info)
1252: register Blt_sysdata *s_info;
1253: {
1254: register unsigned char *src; /* Register pointers are declared as */
1255: /* unsigned char pointers. This is an */
1256: register unsigned char *dst; /* optimization to get around extra */
1257: /* addressing in the assembler. */
1258: #if (APA8 || APA8C)
1259: register int src_plus;
1260: register int dst_plus;
1261: #endif
1262: register long height;
1263: register int skew_src;
1264: register int inv_skew_src;
1265:
1266: #if (APA8 || APA8C)
1267: src_plus = s_info->src_plus;
1268: dst_plus = s_info->dst_plus;
1269: #endif
1270: src = (unsigned char *)s_info->src.data;
1271: dst = (unsigned char *)s_info->dst.data;
1272:
1273: height = s_info->height;
1274: skew_src = s_info->skew_src;
1275: inv_skew_src = BPW - skew_src;
1276:
1277: DEBUGF(blt_debug,
1278: printf("Enter smallcopyBitPos:%d,%d,%d,%d\r\n",skew_src,
1279: inv_skew_src,s_info->preload_src,s_info->rule));
1280:
1281: /*
1282: * foreach row do.
1283: *
1284: * Compiler optimization: a pre-decrement in a while loop saves a test
1285: * in assembly language for every iteration.
1286: */
1287: height += 1;
1288: switch (s_info->rule) {
1289: case SrcCopy:
1290: smallcopyBitPos_LOOP(SrcCopy_MASK,SrcCopy_OP);
1291: break;
1292:
1293: case SrcOr:
1294: smallcopyBitPos_LOOP(SrcOr_MASK,SrcOr_OP);
1295: break;
1296:
1297: case SrcXor:
1298: smallcopyBitPos_LOOP(SrcXor_MASK,SrcXor_OP);
1299: break;
1300:
1301: case NotSrcAnd:
1302: smallcopyBitPos_LOOP(NotSrcAnd_MASK,NotSrcAnd_OP);
1303: break;
1304:
1305: case NotSrcCopy:
1306: smallcopyBitPos_LOOP(NotSrcCopy_MASK,NotSrcCopy_OP);
1307: break;
1308:
1309: case NotSrcOr:
1310: smallcopyBitPos_LOOP(NotSrcOr_MASK,NotSrcOr_OP);
1311: break;
1312:
1313: case NotSrcXor:
1314: smallcopyBitPos_LOOP(NotSrcXor_MASK,NotSrcXor_OP);
1315: break;
1316:
1317: case SrcAnd:
1318: smallcopyBitPos_LOOP(SrcAnd_MASK,SrcAnd_OP);
1319: break;
1320:
1321: case SrcAndNotDst:
1322: smallcopyBitPos_LOOP(SrcAndNotDst_MASK,SrcAndNotDst_OP);
1323: break;
1324:
1325: case NotSrcAndNotDst:
1326: smallcopyBitPos_LOOP(NotSrcAndNotDst_MASK,NotSrcAndNotDst_OP);
1327: break;
1328:
1329: case SrcOrNotDst:
1330: smallcopyBitPos_LOOP(SrcOrNotDst_MASK,SrcOrNotDst_OP);
1331: break;
1332:
1333: case NotSrcOrNotDst:
1334: smallcopyBitPos_LOOP(NotSrcOrNotDst_MASK,NotSrcOrNotDst_OP);
1335: break;
1336:
1337: default:
1338: break;
1339: }
1340: }
1341:
1342: /*
1343: * This loop copies the tile to the destination. It takes as
1344: * arguments 1 of 8 masking tile macros and the coorisponding generic
1345: * tile macro. The general scheme is this:
1346: * Foreach row do
1347: * Copy the tile to the first word using the left edge mask.
1348: *
1349: * For each word between the first and last word do
1350: * Copy the tile to the destination word.
1351: * endfor
1352: *
1353: * Copy the tile to the first word using the right edge mask.
1354: *
1355: * INCREMENT the tile and destination pointers to point to the
1356: * next row.
1357: * endfor
1358: *
1359: */
1360: #define copyTile_LOOP(EDGE_OP,OP) { \
1361: while (--height) { \
1362: wordnum = s_info->nshorts; \
1363: EDGE_OP(*TILE,*DST,s_info->left_mask); \
1364: if (--wordnum != 0) { \
1365: INCR_DST(dst); \
1366: while (wordnum > 1) { \
1367: OP(*TILE,*DST); \
1368: INCR_DST(dst); \
1369: wordnum--; \
1370: } \
1371: EDGE_OP(*TILE,*DST,s_info->right_mask);\
1372: } \
1373: INCR_TILE_PTR(tile,last_tile); \
1374: dst += s_info->dst.nextline; \
1375: } \
1376: }
1377:
1378: /*
1379: * Tiles the destination.
1380: */
1381: copyTile(s_info)
1382: register Blt_sysdata *s_info;
1383: {
1384: /*
1385: * For optimization, these registers are placed in order of importance.
1386: */
1387: register unsigned char *dst; /* All register pointers are declared as */
1388: /* unsigned char pointers. This is an */
1389: /* optimization to get around extra */
1390: /* addressing in the assembler. */
1391: register unsigned char *tile;
1392: #if (APA8 || APA8C)
1393: register int dst_plus;
1394: #endif
1395: register int wordnum;
1396: register unsigned char *last_tile;
1397: register long height;
1398:
1399: #if (APA8 || APA8C)
1400: DEBUGF(blt_debug,
1401: printf("Enter copyTile r:%d p:%d, i:%d dw:%d\r\n",s_info->rule,
1402: s_info->dst_plus,s_info->dst.nextline,s_info->nshorts));
1403: #else
1404: DEBUGF(blt_debug,
1405: printf("Enter copyTile r:%d i:%d dw:%d\r\n",s_info->rule,
1406: s_info->dst.nextline,s_info->nshorts));
1407: #endif
1408:
1409: dst = (unsigned char *)s_info->dst.data;
1410: tile = (unsigned char *)&s_info->tile_ptr[
1411: MOD_BPW(s_info->dst.rect.origin_y)];
1412: last_tile = (unsigned char *)&s_info->tile_ptr[15];
1413:
1414: #if (APA8 || APA8C)
1415: dst_plus = s_info->dst_plus;
1416: #endif
1417:
1418: /*
1419: * Compiler optimization: a pre-decrement in a while loop saves a test
1420: * in assembly language for every iteration.
1421: */
1422: height = s_info->height + 1;
1423: switch (s_info->rule) {
1424: case DstClear:
1425: case DstSet:
1426: case TileDstClear:
1427: case TileDstSet:
1428: case TileCopy:
1429: copyTile_LOOP(TileCopy_MASK,TileCopy_OP);
1430: break;
1431:
1432: case TileOr:
1433: copyTile_LOOP(TileOr_MASK,TileOr_OP);
1434: break;
1435:
1436: case TileXor:
1437: copyTile_LOOP(TileXor_MASK,TileXor_OP);
1438: break;
1439:
1440: case NotTileAnd:
1441: copyTile_LOOP(NotTileAnd_MASK,NotTileAnd_OP);
1442: break;
1443:
1444: case NotTileCopy:
1445: copyTile_LOOP(NotTileCopy_MASK,NotTileCopy_OP);
1446: break;
1447:
1448: case NotTileOr:
1449: copyTile_LOOP(NotTileOr_MASK,NotTileOr_OP);
1450: break;
1451:
1452: case NotTileXor:
1453: copyTile_LOOP(NotTileXor_MASK,NotTileXor_OP);
1454: break;
1455:
1456: case TileAnd:
1457: copyTile_LOOP(TileAnd_MASK,TileAnd_OP);
1458: break;
1459:
1460: case TileNotDstCopy:
1461: case NotDstCopy:
1462: copyTile_LOOP(NotDstCopy_MASK,NotDstCopy_OP);
1463: break;
1464:
1465: case TileAndNotDst:
1466: copyTile_LOOP(TileAndNotDst_MASK,TileAndNotDst_OP);
1467: break;
1468:
1469: case NotTileAndNotDst:
1470: copyTile_LOOP(NotTileAndNotDst_MASK,NotTileAndNotDst_OP);
1471: break;
1472:
1473: case TileOrNotDst:
1474: copyTile_LOOP(TileOrNotDst_MASK,TileOrNotDst_OP);
1475: break;
1476:
1477: case NotTileOrNotDst:
1478: copyTile_LOOP(NotTileOrNotDst_MASK,NotTileOrNotDst_OP);
1479: break;
1480:
1481: default:
1482: break;
1483: }
1484: }
1485:
1486: /*
1487: * This loop copies bits from right to left, bottom to top. It takes as
1488: * arguments 1 of 8 masking macros. This loop has the same general structure
1489: * as copyBitNeg_LOOP except that work must be done on the mask bitmap.
1490: * This adds complexity because for optimization purposes, there are 4 loops
1491: * instead of 2.
1492: * The general scheme is this:
1493: * Foreach row do
1494: * Calculate the first MASK word priming if necessary.
1495: *
1496: * Take care of the first word priming if necessary and using
1497: * the mask just calculated. (Done because
1498: * the first word uses the RIGHT edge mask.)
1499: *
1500: * If the source and the MASK is skewed then
1501: * (Means parts of 2 source words make one
1502: * destination word and parts of 2 mask words are used
1503: * to mask this one destination word.)
1504: *
1505: * For each word between the first and last word do
1506: * Calculate the MASK word.
1507: * Shift the source word and source word -1 and
1508: * write the word to the destination using
1509: * the mask just calculated.
1510: * endfor
1511: *
1512: * Calculate the MASK word.
1513: * Take care of the last word using the mask and left
1514: * edge mask. (Done here and not in
1515: * the loop because the last word uses the
1516: * LEFT edge mask.)
1517: *
1518: * else if the MASK is skewed then
1519: * For each word between the first and last word do
1520: * Calculate the MASK word.
1521: * Write the source word to the destination using
1522: * the mask just calculated.
1523: * endfor
1524: *
1525: * Calculate the MASK word.
1526: * Take care of the last word using the mask and left
1527: * edge mask.
1528: *
1529: * else if the source is skewed then
1530: *
1531: * For each word between the first and last word do
1532: * Shift the source word and source word -1 and
1533: * write the word to the destination using
1534: * the mask.
1535: * endfor
1536: *
1537: * Take care of the last word using the mask and left
1538: * edge mask.
1539: *
1540: * else The source and mask skew are zero meaning 1 source word,
1541: * one mask word are used per destination word.
1542: *
1543: * For each word between the first and last word do
1544: * Write the source word into the destination
1545: * using the mask word.
1546: * endfor
1547: *
1548: * Take care of the last word using the mask word and
1549: * the left edge mask.
1550: * endif
1551: *
1552: * DECREMENT the source,destination and mask pointers to point
1553: * to the next row in their respective bitmaps.
1554: * endfor
1555: *
1556: */
1557: #define maskBitNeg_LOOP(MASK_OP) { \
1558: while (--s_info->height) { \
1559: wordnum = s_info->nshorts; \
1560: if (s_info->preload_msk) { \
1561: mask = (*MSK >> s_info->skew_msk) | \
1562: (*MINUS_MSK(msk) << inv_skew_msk); \
1563: DECR_MSK(msk); \
1564: } \
1565: else { \
1566: mask = (*MSK << inv_skew_msk); \
1567: } \
1568: if (s_info->preload_src) { \
1569: MASK_OP((*SRC >> s_info->skew_src) | \
1570: (*(MINUS_SRC(src)) << (inv_skew_src)), \
1571: *DST,s_info->right_mask & mask); \
1572: DECR_SRC(src); \
1573: } \
1574: else { \
1575: MASK_OP((*SRC << (inv_skew_src)),*DST, \
1576: s_info->right_mask & mask); \
1577: } \
1578: if (--wordnum != 0) { \
1579: DECR_DST(dst); \
1580: if (write_mode == (MSK_SKEW | SRC_SKEW)) { \
1581: while (wordnum-- > 1) { \
1582: mask = (*MSK >> s_info->skew_msk) |\
1583: (*MINUS_MSK(msk)<<inv_skew_msk);\
1584: MASK_OP((*SRC >> s_info->skew_src) |\
1585: (*(MINUS_SRC(src)) << \
1586: inv_skew_src), \
1587: *DST,mask); \
1588: DECR_SRC(src); DECR_MSK(msk); \
1589: DECR_DST(dst); \
1590: } \
1591: mask = (*MSK >> s_info->skew_msk) | \
1592: (*MINUS_MSK(msk)<<inv_skew_msk); \
1593: MASK_OP((*SRC >> s_info->skew_src) | \
1594: (*(MINUS_SRC(src))<<inv_skew_src),\
1595: *DST,s_info->left_mask & mask); \
1596: DECR_SRC(src); DECR_MSK(msk); \
1597: } \
1598: else if (write_mode & MSK_SKEW) { \
1599: while (wordnum-- > 1) { \
1600: mask = (*MSK >> s_info->skew_msk) |\
1601: (*MINUS_MSK(msk)<<inv_skew_msk);\
1602: DECR_SRC(src); DECR_MSK(msk); \
1603: MASK_OP(*SRC,*DST,mask); \
1604: DECR_DST(dst); \
1605: } \
1606: mask = (*MSK >> s_info->skew_msk) | \
1607: (*MINUS_MSK(msk)<<inv_skew_msk); \
1608: DECR_SRC(src); DECR_MSK(msk); \
1609: MASK_OP(*SRC,*DST,s_info->left_mask&mask);\
1610: } \
1611: else if (write_mode & SRC_SKEW) { \
1612: while (wordnum-- > 1) { \
1613: DECR_MSK(msk); \
1614: MASK_OP((*SRC >> s_info->skew_src) |\
1615: (*(MINUS_SRC(src)) << \
1616: inv_skew_src), \
1617: *DST,*MSK); \
1618: DECR_SRC(src); \
1619: DECR_DST(dst); \
1620: } \
1621: DECR_MSK(msk); \
1622: MASK_OP((*SRC >> s_info->skew_src) | \
1623: (*(MINUS_SRC(src))<<inv_skew_src),\
1624: *DST,s_info->left_mask & *MSK); \
1625: DECR_SRC(src); \
1626: } \
1627: else { \
1628: while (wordnum-- > 1) { \
1629: DECR_SRC(src); DECR_MSK(msk); \
1630: MASK_OP(*SRC,*DST,*MSK); \
1631: DECR_DST(dst); \
1632: } \
1633: DECR_SRC(src); DECR_MSK(msk); \
1634: MASK_OP(*SRC,*DST,s_info->left_mask & *MSK);\
1635: } \
1636: } \
1637: src -= s_info->src.nextline; \
1638: dst -= s_info->dst.nextline; \
1639: msk -= s_info->msk.nextline; \
1640: } \
1641: }
1642:
1643: /*
1644: * Copies bits from bottom to top, right to left but only changes those bits
1645: * that have corrisponding ones in the mask bitmap.
1646: */
1647: maskBitNeg(s_info)
1648: register Blt_sysdata *s_info;
1649: {
1650: register unsigned char *src; /* Register pointers are declared as */
1651: /* unsigned char pointers. This is an */
1652: register unsigned char *dst; /* optimization to get around extra */
1653: /* addressing in the assembler. */
1654: register unsigned char *msk; /* register pointer to the mask */
1655: #if (APA8 || APA8C)
1656: register int src_plus;
1657: register int dst_plus;
1658: #endif
1659: register int wordnum; /* number of shorts per scanline */
1660: register int inv_skew_src; /* BPW - skew_src */
1661: register int inv_skew_msk; /* BPW - skew_msk */
1662: register int write_mode; /* One of 4 modes: 0. no skew.
1663: 1. skew just the msk.
1664: 2. skew just the src.
1665: 3. skew both. */
1666: register unsigned short mask;/* The local mask produced by shifting
1667: *MSK and *MINUS_MASK() */
1668:
1669: #if (APA8 || APA8C)
1670: src_plus = s_info->src_plus;
1671: dst_plus = s_info->dst_plus;
1672: #endif
1673:
1674: DEBUGF(blt_debug,
1675: printf("Enter maskBitNeg. rule:%d\r\n",s_info->rule));
1676:
1677: src = (unsigned char *)s_info->src.data;
1678: dst = (unsigned char *)s_info->dst.data;
1679: msk = (unsigned char *)s_info->msk.data;
1680:
1681: inv_skew_src = BPW - s_info->skew_src;
1682: inv_skew_msk = BPW - s_info->skew_msk;
1683:
1684: /*
1685: * Set the write mode so that the correct inner loop is picked.
1686: */
1687: write_mode = 0;
1688: if (s_info->skew_src & 0xf)
1689: write_mode |= SRC_SKEW;
1690: if (s_info->skew_msk & 0xf)
1691: write_mode |= MSK_SKEW;
1692:
1693: /*
1694: * Compiler optimization: a pre-decrement in a while loop saves a test
1695: * in assembly language for every iteration.
1696: */
1697: s_info->height += 1;
1698: switch (s_info->rule) {
1699: case SrcCopy:
1700: maskBitNeg_LOOP(SrcCopy_MASK);
1701: break;
1702:
1703: case SrcOr:
1704: maskBitNeg_LOOP(SrcOr_MASK);
1705: break;
1706:
1707: case SrcXor:
1708: maskBitNeg_LOOP(SrcXor_MASK);
1709: break;
1710:
1711: case NotSrcAnd:
1712: maskBitNeg_LOOP(NotSrcAnd_MASK);
1713: break;
1714:
1715: case NotSrcCopy:
1716: maskBitNeg_LOOP(NotSrcCopy_MASK);
1717: break;
1718:
1719: case NotSrcOr:
1720: maskBitNeg_LOOP(NotSrcOr_MASK);
1721: break;
1722:
1723: case NotSrcXor:
1724: maskBitNeg_LOOP(NotSrcXor_MASK);
1725: break;
1726:
1727: case SrcAnd:
1728: maskBitNeg_LOOP(SrcAnd_MASK);
1729: break;
1730:
1731: case SrcAndNotDst:
1732: maskBitNeg_LOOP(SrcAndNotDst_MASK);
1733: break;
1734:
1735: case NotSrcAndNotDst:
1736: maskBitNeg_LOOP(NotSrcAndNotDst_MASK);
1737: break;
1738:
1739: case SrcOrNotDst:
1740: maskBitNeg_LOOP(SrcOrNotDst_MASK);
1741: break;
1742:
1743: case NotSrcOrNotDst:
1744: maskBitNeg_LOOP(NotSrcOrNotDst_MASK);
1745: break;
1746:
1747: default:
1748: break;
1749: }
1750: }
1751:
1752: /*
1753: * This loop copies bits from left to right, top to bottom. It takes as
1754: * arguments 1 of 8 masking macros. This loop has the same general structure
1755: * as copyBitPos_LOOP except that work must be done on the mask bitmap.
1756: * This adds complexity because, for optimization purposes, there are 4 loops
1757: * instead of 2.
1758: * The general scheme is this:
1759: * Foreach row do
1760: * Calculate the first MASK word priming if necessary.
1761: *
1762: * Take care of the first word priming if necessary and using
1763: * the mask just calculated. (Done because
1764: * the first word uses the RIGHT edge mask.)
1765: *
1766: * If the source and the MASK is skewed then
1767: * (Means parts of 2 source words make one
1768: * destination word and parts of 2 mask words are used
1769: * to mask this one destination word.)
1770: *
1771: * For each word between the first and last word do
1772: * Calculate the MASK word.
1773: * Shift the source word and source word -1 and
1774: * write the word to the destination using
1775: * the mask just calculated.
1776: * endfor
1777: *
1778: * Calculate the MASK word.
1779: * Take care of the last word using the mask and left
1780: * edge mask. (Done here and not in
1781: * the loop because the last word uses the
1782: * LEFT edge mask.)
1783: *
1784: * else if the MASK is skewed then
1785: * For each word between the first and last word do
1786: * Calculate the MASK word.
1787: * Write the source word to the destination using
1788: * the mask just calculated.
1789: * endfor
1790: *
1791: * Calculate the MASK word.
1792: * Take care of the last word using the mask and left
1793: * edge mask.
1794: *
1795: * else if the source is skewed then
1796: *
1797: * For each word between the first and last word do
1798: * Shift the source word and source word -1 and
1799: * write the word to the destination using
1800: * the mask.
1801: * endfor
1802: *
1803: * Take care of the last word using the mask and left
1804: * edge mask.
1805: *
1806: * else The source and mask skew are zero meaning 1 source word,
1807: * one mask word are used per destination word.
1808: *
1809: * For each word between the first and last word do
1810: * Write the source word into the destination
1811: * using the mask word.
1812: * endfor
1813: *
1814: * Take care of the last word using the mask word and
1815: * the left edge mask.
1816: * endif
1817: *
1818: * INCREMENT the source,destination and mask pointers to point
1819: * to the next row in their respective bitmaps.
1820: * endfor
1821: *
1822: */
1823: #define maskBitPos_LOOP(MASK_OP) { \
1824: while (--s_info->height) { \
1825: wordnum = s_info->nshorts; \
1826: if (s_info->preload_msk) { \
1827: mask = (*MSK << s_info->skew_msk) | \
1828: (*PLUS_MSK(msk) >> inv_skew_msk); \
1829: INCR_MSK(msk); \
1830: } \
1831: else { \
1832: mask = (*MSK >> inv_skew_msk); \
1833: } \
1834: if (s_info->preload_src) { \
1835: MASK_OP((*SRC << s_info->skew_src) | \
1836: (*(PLUS_SRC(src)) >> (inv_skew_src)),*DST,\
1837: s_info->left_mask & mask); \
1838: INCR_SRC(src); \
1839: } \
1840: else { \
1841: MASK_OP((*SRC >> (inv_skew_src)),*DST, \
1842: s_info->left_mask & mask); \
1843: } \
1844: if (--wordnum != 0) { \
1845: INCR_DST(dst); \
1846: if (write_mode == (MSK_SKEW | SRC_SKEW)) { \
1847: while (wordnum-- > 1) { \
1848: mask = (*MSK << s_info->skew_msk) |\
1849: (*PLUS_MSK(msk)>>inv_skew_msk);\
1850: MASK_OP((*SRC << s_info->skew_src) |\
1851: (*(PLUS_SRC(src)) >> \
1852: (inv_skew_src)), \
1853: *DST,mask); \
1854: INCR_SRC(src); INCR_MSK(msk); \
1855: INCR_DST(dst); \
1856: } \
1857: mask = (*MSK << s_info->skew_msk) | \
1858: (*PLUS_MSK(msk) >> inv_skew_msk);\
1859: MASK_OP((*SRC << s_info->skew_src) | \
1860: (*(PLUS_SRC(src))>>(inv_skew_src)),\
1861: *DST, s_info->right_mask & mask);\
1862: INCR_SRC(src); INCR_MSK(msk); \
1863: } \
1864: else if (write_mode & MSK_SKEW) { \
1865: while (wordnum-- > 1) { \
1866: mask = (*MSK << s_info->skew_msk) |\
1867: (*PLUS_MSK(msk) >> \
1868: inv_skew_msk); \
1869: INCR_SRC(src); INCR_MSK(msk); \
1870: MASK_OP(*SRC,*DST,mask); \
1871: INCR_DST(dst); \
1872: } \
1873: mask = (*MSK << s_info->skew_msk) | \
1874: (*PLUS_MSK(msk) >> inv_skew_msk);\
1875: INCR_SRC(src); INCR_MSK(msk); \
1876: MASK_OP(*SRC,*DST, s_info->right_mask & mask);\
1877: } \
1878: else if (write_mode & SRC_SKEW) { \
1879: while (wordnum-- > 1) { \
1880: INCR_MSK(msk); \
1881: MASK_OP((*SRC << s_info->skew_src) |\
1882: (*(PLUS_SRC(src)) >> \
1883: (inv_skew_src)), \
1884: *DST,*MSK); \
1885: INCR_SRC(src); \
1886: INCR_DST(dst); \
1887: } \
1888: INCR_MSK(msk); \
1889: MASK_OP((*SRC << s_info->skew_src) | \
1890: (*(PLUS_SRC(src))>>(inv_skew_src)),\
1891: *DST, s_info->right_mask & *MSK);\
1892: INCR_SRC(src); \
1893: } \
1894: else { \
1895: while (wordnum-- > 1) { \
1896: INCR_SRC(src); INCR_MSK(msk); \
1897: MASK_OP(*SRC,*DST,*MSK); \
1898: INCR_DST(dst); \
1899: } \
1900: INCR_SRC(src); INCR_MSK(msk); \
1901: MASK_OP(*SRC,*DST,s_info->right_mask & *MSK);\
1902: } \
1903: } \
1904: src += s_info->src.nextline; \
1905: dst += s_info->dst.nextline; \
1906: msk += s_info->msk.nextline; \
1907: } \
1908: }
1909:
1910: /*
1911: * Copies bits from top to bottom , left to right but only changes those bits
1912: * that have corrisponding ones in mask bitmap given.
1913: */
1914: maskBitPos(s_info)
1915: register Blt_sysdata *s_info;
1916: {
1917: register unsigned char *src; /* Register pointers are declared as */
1918: /* unsigned char pointers. This is an */
1919: register unsigned char *dst; /* optimization to get around extra */
1920: /* addressing in the assembler. */
1921: register unsigned char *msk; /* register pointer to the mask */
1922: #if (APA8 || APA8C)
1923: register int src_plus;
1924: register int dst_plus;
1925: #endif
1926: register int wordnum; /* number of shorts per scanline */
1927: register int inv_skew_src; /* BPW - skew_src */
1928: register int inv_skew_msk; /* BPW - skew_msk */
1929: register int write_mode; /* One of 4 modes: 0. no skew.
1930: 1. skew just the msk.
1931: 2. skew just the src.
1932: 3. skew both. */
1933: register unsigned short mask;/* The local mask produced by shifting
1934: *MSK and *PLUS_MASK() */
1935:
1936: #if (APA8 || APA8C)
1937: src_plus = s_info->src_plus;
1938: dst_plus = s_info->dst_plus;
1939: #endif
1940:
1941: DEBUGF(blt_debug,printf("Enter maskBitPos. rule:%d\r\n",s_info->rule));
1942:
1943: src = (unsigned char *)s_info->src.data;
1944: dst = (unsigned char *)s_info->dst.data;
1945: msk = (unsigned char *)s_info->msk.data;
1946:
1947: inv_skew_msk = BPW - s_info->skew_msk;
1948: inv_skew_src = BPW - s_info->skew_src;
1949:
1950: /*
1951: * Set the write mode so that the correct inner loop is picked.
1952: */
1953: write_mode = 0;
1954: if (s_info->skew_src & 0xf)
1955: write_mode |= SRC_SKEW;
1956: if (s_info->skew_msk & 0xf)
1957: write_mode |= MSK_SKEW;
1958:
1959: /*
1960: * Compiler optimization: a pre-decrement in a while loop saves a test
1961: * in assembly language for every iteration.
1962: */
1963: s_info->height += 1;
1964: switch (s_info->rule) {
1965: case SrcCopy:
1966: maskBitPos_LOOP(SrcCopy_MASK);
1967: break;
1968:
1969: case SrcOr:
1970: maskBitPos_LOOP(SrcOr_MASK);
1971: break;
1972:
1973: case SrcXor:
1974: maskBitPos_LOOP(SrcXor_MASK);
1975: break;
1976:
1977: case NotSrcAnd:
1978: maskBitPos_LOOP(NotSrcAnd_MASK);
1979: break;
1980:
1981: case NotSrcCopy:
1982: maskBitPos_LOOP(NotSrcCopy_MASK);
1983: break;
1984:
1985: case NotSrcOr:
1986: maskBitPos_LOOP(NotSrcOr_MASK);
1987: break;
1988:
1989: case NotSrcXor:
1990: maskBitPos_LOOP(NotSrcXor_MASK);
1991: break;
1992:
1993: case SrcAnd:
1994: maskBitPos_LOOP(SrcAnd_MASK);
1995: break;
1996:
1997: case SrcAndNotDst:
1998: maskBitPos_LOOP(SrcAndNotDst_MASK);
1999: break;
2000:
2001: case NotSrcAndNotDst:
2002: maskBitPos_LOOP(NotSrcAndNotDst_MASK);
2003: break;
2004:
2005: case SrcOrNotDst:
2006: maskBitPos_LOOP(SrcOrNotDst_MASK);
2007: break;
2008:
2009: case NotSrcOrNotDst:
2010: maskBitPos_LOOP(NotSrcOrNotDst_MASK);
2011: break;
2012:
2013: default:
2014: break;
2015: }
2016: }
2017:
2018: /*
2019: * This loop copies the tile to the destination only changing those bits
2020: * in the destination that have coorisponding one's in the mask bitmap.
2021: * It takes as arguments 1 of 8 masking tile macros. The general scheme
2022: * is this:
2023: * Foreach row do
2024: * Calculate the MASK shifting if necessary.
2025: * Copy the tile to the first word using the left edge mask and
2026: * MASK.
2027: *
2028: * if the MASK is skewed then (2 mask words are needed for one
2029: * destination word.)
2030: * For each word between the first and last word do
2031: * Calculate the MASK.
2032: * Copy the tile to the destination word using
2033: * the mask calculated.
2034: * endfor
2035: *
2036: * Calculate the MASK.
2037: * Copy the tile to the first word using the right edge mask and
2038: * the mask calculated.
2039: *
2040: * else
2041: * For each word between the first and last word do
2042: * Copy the tile to the destination word using
2043: * the mask.
2044: * endfor
2045: *
2046: * Copy the tile to the first word using the
2047: * right edge mask and the mask.
2048: * endif
2049: *
2050: * INCREMENT the tile and destination pointers to point to the
2051: * next row.
2052: * endfor
2053: */
2054: #define maskTile_LOOP(MASK_OP) { \
2055: while (--s_info->height) { \
2056: wordnum = s_info->nshorts; \
2057: if (s_info->preload_msk) { \
2058: mask = (*MSK << s_info->skew_msk) | \
2059: (*PLUS_MSK(msk) >> inv_skew_msk); \
2060: INCR_MSK(msk); \
2061: } \
2062: else { \
2063: mask = (*MSK >> inv_skew_msk); \
2064: } \
2065: MASK_OP(*TILE,*DST,s_info->left_mask & mask); \
2066: if (--wordnum != 0) { \
2067: INCR_DST(dst); \
2068: if (s_info->skew_msk & 0xf) { \
2069: while (wordnum-- > 1) { \
2070: mask = (*MSK << s_info->skew_msk) |\
2071: (*PLUS_MSK(msk)>>inv_skew_msk);\
2072: MASK_OP(*TILE,*DST,mask); \
2073: INCR_DST(dst); INCR_MSK(msk); \
2074: } \
2075: mask = (*MSK << s_info->skew_msk) | \
2076: (*PLUS_MSK(msk) >> inv_skew_msk);\
2077: MASK_OP(*TILE,*DST, \
2078: s_info->right_mask & mask); \
2079: INCR_MSK(msk); \
2080: } \
2081: else { \
2082: while (wordnum-- > 1) { \
2083: INCR_MSK(msk); \
2084: MASK_OP(*TILE,*DST,*MSK); \
2085: INCR_DST(dst); \
2086: } \
2087: INCR_MSK(msk); \
2088: MASK_OP(*TILE,*DST,s_info->right_mask & *MSK);\
2089: } \
2090: } \
2091: INCR_TILE_PTR(tile,last_tile); \
2092: dst += s_info->dst.nextline; \
2093: msk += s_info->msk.nextline; \
2094: } \
2095: }
2096:
2097: /*
2098: * Copies a tile to the destination but only changes those bits
2099: * that have corrisponding ones in the mask bitmap given.
2100: */
2101: maskTile(s_info)
2102: register Blt_sysdata *s_info;
2103: {
2104: register unsigned char *dst; /* Register pointers are declared as */
2105: /* unsigned char pointers. This is an */
2106: register unsigned char *msk; /* optimization to get around extra */
2107: /* addressing in the assembler. */
2108: register unsigned char *tile;/* register pointer to the tile */
2109: #if (APA8 || APA8C)
2110: register int src_plus;
2111: register int dst_plus;
2112: #endif
2113: register unsigned char *last_tile;/* points to the last word in a tile*/
2114: register int wordnum; /* number of shorts per scanline */
2115: register int inv_skew_msk; /* BPW - skew_msk */
2116: register unsigned short mask;/* The local mask produced by shifting
2117: *MSK and *PLUS_MASK() */
2118: #if (APA8 || APA8C)
2119: src_plus = s_info->src_plus;
2120: dst_plus = s_info->dst_plus;
2121: #endif
2122: dst = (unsigned char *)s_info->dst.data;
2123: msk = (unsigned char *)s_info->msk.data;
2124: tile = (unsigned char *)&s_info->tile_ptr[
2125: MOD_BPW(s_info->dst.rect.origin_y)];
2126: last_tile = (unsigned char *)(&s_info->tile_ptr[15]);
2127:
2128:
2129: inv_skew_msk = BPW - s_info->skew_msk;
2130:
2131: DEBUGF(blt_debug,
2132: printf("Enter maskTile%d,%d %d %s %d\r\n",s_info->skew_msk,
2133: inv_skew_msk,s_info->preload_msk,
2134: ((s_info->tile_ptr[0] == 0xffff &&
2135: s_info->tile_ptr[5] == 0xffff) ?
2136: "black" : "not black"),s_info->rule));
2137:
2138: /*
2139: * Compiler optimization: a pre-decrement in a while loop saves a test
2140: * in assembly language for every iteration.
2141: */
2142: s_info->height += 1;
2143: switch (s_info->rule) {
2144: case DstClear:
2145: case DstSet:
2146: case TileDstClear:
2147: case TileDstSet:
2148: case TileCopy:
2149: maskTile_LOOP(TileCopy_MASK);
2150: break;
2151:
2152: case TileOr:
2153: maskTile_LOOP(TileOr_MASK);
2154: break;
2155:
2156: case TileXor:
2157: maskTile_LOOP(TileXor_MASK);
2158: break;
2159:
2160: case NotTileAnd:
2161: maskTile_LOOP(NotTileAnd_MASK);
2162: break;
2163:
2164: case NotTileCopy:
2165: maskTile_LOOP(NotTileCopy_MASK);
2166: break;
2167:
2168: case NotTileOr:
2169: maskTile_LOOP(NotTileOr_MASK);
2170: break;
2171:
2172: case NotTileXor:
2173: maskTile_LOOP(NotTileXor_MASK);
2174: break;
2175:
2176: case TileAnd:
2177: maskTile_LOOP(TileAnd_MASK);
2178: break;
2179:
2180: case TileNotDstCopy:
2181: case NotDstCopy:
2182: maskTile_LOOP(NotDstCopy_MASK);
2183: break;
2184:
2185: case TileAndNotDst:
2186: maskTile_LOOP(TileAndNotDst_MASK);
2187: break;
2188:
2189: case NotTileAndNotDst:
2190: maskTile_LOOP(NotTileAndNotDst_MASK);
2191: break;
2192:
2193: case TileOrNotDst:
2194: maskTile_LOOP(TileOrNotDst_MASK);
2195: break;
2196:
2197: case NotTileOrNotDst:
2198: maskTile_LOOP(NotTileOrNotDst_MASK);
2199: break;
2200:
2201: default:
2202: break;
2203: }
2204: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.