![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitblt.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.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / bitblt |
1.1 ! root 1: #ifndef lint ! 2: static char *rcsid_bitblt_c = "$Header: bitblt.c,v 10.1 86/11/19 10:50:19 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 November 21, 1985 and ! 18: * "enhanced" a number of times since. ! 19: * ! 20: * ABOUT BITBLT.C: This program and related 'C' files (bitblt_int.h, ! 21: * bitblt_subr.c, bitblt_apa16.c, bitblt_apa16.h) were originally written to go ! 22: * into the Unix 4.2 kernel as a "bitblt" driver. Later we were able ! 23: * to put in some ifdef's and use it for Smalltalk and X. Whatever ! 24: * version you have, there may be some strange ifdef's that may not ! 25: * make any sense at all. We tried to remove all ifdef's not relevant ! 26: * to the system being compiled but then no one's perfect. ! 27: * Also some strange things are done to support the APA8, APA8C and the AED ! 28: * (viking). You will encounter ifdef's for all these things. if you define ! 29: * all the screens (-DAED -DAPA8 -DAPA16 ... on the compile line) the bitblt ! 30: * routine will work on every screen. ! 31: */ ! 32: ! 33: #include "bitblt_int.h" ! 34: ! 35: #ifdef USE_APA16_HDWR ! 36: #include "bitblt_apa16.h" ! 37: #endif ! 38: ! 39: #ifdef BLT_DEBUG ! 40: int blt_debug = 0; ! 41: #endif ! 42: ! 43: #define MSK_SKEW 0x01 ! 44: #define SRC_SKEW 0x02 ! 45: ! 46: Blt_sysdata blt_info; /* internal variables used by bitblt() */ ! 47: Blt_Rectangle changed_rect; /* describes the area changed by the bltter */ ! 48: ! 49: /* ! 50: * Array of short masks used to compute the masks to mask out the edges ! 51: * of the destination that should not be affected. A one means that bit ! 52: * in the destination can be changed. The values in leftMasks are set up ! 53: * to be used with the left edge and the values in rightMasks are to be used ! 54: * in right edge. ! 55: */ ! 56: static unsigned short leftMasks[] = { ! 57: 0xffff,0x7fff,0x3fff,0x1fff,0x0fff,0x07ff,0x03ff,0x01ff, ! 58: 0x00ff,0x007f,0x003f,0x001f,0x000f,0x0007,0x0003,0x0001, ! 59: 0x0000 ! 60: }; ! 61: ! 62: static unsigned short rightMasks[] = { ! 63: 0xffff,0x8000,0xc000,0xe000,0xf000,0xf800,0xfc00,0xfe00, ! 64: 0xff00,0xff80,0xffc0,0xffe0,0xfff0,0xfff8,0xfffc,0xfffe, ! 65: 0x0000 ! 66: }; ! 67: ! 68: static Blt_Tile white = { ! 69: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, ! 70: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 ! 71: }; ! 72: static Blt_Tile black = { ! 73: 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, ! 74: 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff ! 75: }; ! 76: ! 77: /* ! 78: * Defines used to indicate whether 1 or 2 source words are needed to make ! 79: * the first destination word. ! 80: * NOTE: Changing the value of MUST_PRIME may have bad side effects because ! 81: * the variable "preload_src" is added to something in calculateOffsets. ! 82: * THIS IS SEMI-HOOKY BUT IT WORKS. ! 83: */ ! 84: #define MUST_PRIME 1 ! 85: #define DONT_PRIME 0 ! 86: ! 87: #define SAVE_LOCATOR() { \ ! 88: if (blt_cur_screen.cursortype & SOFT_CURSOR) { \ ! 89: saved_loc = 0; \ ! 90: if (IS_SCREEN(u_info->dst_bitmap)) { \ ! 91: if (sys_info->is_src && IS_SCREEN(u_info->src_bitmap)){\ ! 92: saved_loc = 1; \ ! 93: save_cursor(MIN(sys_info->dst.rect.origin_x, \ ! 94: sys_info->src.rect.origin_x), \ ! 95: MIN(sys_info->dst.rect.origin_y, \ ! 96: sys_info->src.rect.origin_y), \ ! 97: MAX(sys_info->dst.rect.corner_x, \ ! 98: sys_info->src.rect.corner_x)+1,\ ! 99: MAX(sys_info->dst.rect.corner_y, \ ! 100: sys_info->src.rect.corner_y)+1);\ ! 101: } \ ! 102: else { \ ! 103: saved_loc = 1; \ ! 104: save_cursor(sys_info->dst.rect.origin_x, \ ! 105: sys_info->dst.rect.origin_y, \ ! 106: sys_info->dst.rect.corner_x + 1, \ ! 107: sys_info->dst.rect.corner_y + 1);\ ! 108: } \ ! 109: } \ ! 110: else if (sys_info->is_src && IS_SCREEN(u_info->src_bitmap)) { \ ! 111: saved_loc = 1; \ ! 112: save_cursor(sys_info->src.rect.origin_x, \ ! 113: sys_info->src.rect.origin_y, \ ! 114: sys_info->src.rect.corner_x + 1, \ ! 115: sys_info->src.rect.corner_y + 1); \ ! 116: } \ ! 117: } \ ! 118: } ! 119: ! 120: #define RESTORE_LOCATOR() { \ ! 121: if ((blt_cur_screen.cursortype & SOFT_CURSOR) && saved_loc) { \ ! 122: restore_cursor(); \ ! 123: } \ ! 124: } ! 125: ! 126: /* ! 127: * Macros to calculate the skew and preload flag depending on the direction ! 128: * of the blt. ! 129: */ ! 130: #define computeSkewPos(SI) { \ ! 131: if ((MOD_BPW(SI->dst.rect.origin_x))<(MOD_BPW(SI->src.rect.origin_x))){\ ! 132: SI->skew_src = MOD_BPW(SI->src.rect.origin_x) - \ ! 133: MOD_BPW(SI->dst.rect.origin_x); \ ! 134: SI->preload_src = MUST_PRIME; \ ! 135: } \ ! 136: else { \ ! 137: SI->skew_src = BPW - (MOD_BPW(SI->dst.rect.origin_x) - \ ! 138: MOD_BPW(SI->src.rect.origin_x)); \ ! 139: SI->preload_src = DONT_PRIME; \ ! 140: } \ ! 141: } ! 142: ! 143: #define computeSkewMskPos(SI) { \ ! 144: if ((MOD_BPW(SI->dst.rect.origin_x))<(MOD_BPW(SI->msk.rect.origin_x))){\ ! 145: SI->skew_msk = MOD_BPW(SI->msk.rect.origin_x) - \ ! 146: MOD_BPW(SI->dst.rect.origin_x); \ ! 147: SI->preload_msk = MUST_PRIME; \ ! 148: } \ ! 149: else { \ ! 150: SI->skew_msk = BPW - (MOD_BPW(SI->dst.rect.origin_x) - \ ! 151: MOD_BPW(SI->msk.rect.origin_x)); \ ! 152: SI->preload_msk = DONT_PRIME; \ ! 153: } \ ! 154: } ! 155: ! 156: #define computeSkewNeg(SI) { \ ! 157: if ((MOD_BPW(SI->dst.rect.corner_x))>(MOD_BPW(SI->src.rect.corner_x))){\ ! 158: SI->skew_src = MOD_BPW(SI->dst.rect.corner_x) - \ ! 159: MOD_BPW(SI->src.rect.corner_x); \ ! 160: SI->preload_src = MUST_PRIME; \ ! 161: } \ ! 162: else { \ ! 163: SI->skew_src = BPW - (MOD_BPW(SI->src.rect.corner_x) - \ ! 164: MOD_BPW(SI->dst.rect.corner_x)); \ ! 165: SI->preload_src = DONT_PRIME; \ ! 166: } \ ! 167: } ! 168: ! 169: #define computeSkewMskNeg(SI) { \ ! 170: if ((MOD_BPW(SI->dst.rect.corner_x))>(MOD_BPW(SI->msk.rect.corner_x))){\ ! 171: SI->skew_msk = MOD_BPW(SI->dst.rect.corner_x) - \ ! 172: MOD_BPW(SI->msk.rect.corner_x); \ ! 173: SI->preload_msk = MUST_PRIME; \ ! 174: } \ ! 175: else { \ ! 176: SI->skew_msk = BPW - (MOD_BPW(SI->msk.rect.corner_x) - \ ! 177: MOD_BPW(SI->dst.rect.corner_x)); \ ! 178: SI->preload_msk = DONT_PRIME; \ ! 179: } \ ! 180: } ! 181: ! 182: /* ! 183: * Make a mask for the first and last destination word in each scanline. ! 184: * 1's mean those bits can be changed in the destination. ! 185: * Combine the masks if only one destination word is effected and set ! 186: * BOTH masks equal to it so as not to screw up copyBitNeg. ! 187: * ! 188: * NOTE: The +1 with dst.rect.corner_x. This is because dst.rect.corner_x was ! 189: * set to the rectangle size -1. (see blt_setup()) ! 190: */ ! 191: #define computeMasks(SI) { \ ! 192: if (SI->nshorts == 1) { \ ! 193: SI->right_mask = SI->left_mask = \ ! 194: leftMasks[MOD_BPW(SI->dst.rect.origin_x)] &\ ! 195: rightMasks[MOD_BPW(SI->dst.rect.corner_x+1)];\ ! 196: } \ ! 197: else { \ ! 198: SI->left_mask = leftMasks[MOD_BPW(SI->dst.rect.origin_x)];\ ! 199: SI->right_mask = rightMasks[MOD_BPW(SI->dst.rect.corner_x+1)];\ ! 200: } \ ! 201: } ! 202: ! 203: /* ! 204: * CheckOverlap checks for overlapping source and destination. ! 205: * (See checkOverlap in Smalltalk-80) It set SI->top_to_bot to ! 206: * non-zero if we must copy from bottom to top, right to left ! 207: * instead of top to bottom, left to right. ! 208: * ! 209: * NOTE: The +1 for both src.rect.corner_y and src.rect.corner_x this is because ! 210: * these local variables have "closed" corners. (See blt_setup()) ! 211: * ! 212: * IF the destination and source have the same bitmap ! 213: * AND ! 214: * TEST AREA 1 OR TEST AREA 2 ! 215: * THEN ! 216: * (We must copy from right to left bottom to top) ! 217: * ! 218: * TEST AREA 1: The destination top is GREATER than or EQUAL to the ! 219: * source top and its less than the source bottom ! 220: * (src.rect.origin_y <= dst.rect.origin_y < src.rect.corner_y+1) AND ! 221: * the destination left is greater than or equal to ! 222: * the source left and its less than the source right. ! 223: * (src.rect.origin_x <= dst.rect.origin_x < src.rect.corner_x+1) ! 224: * IN OTHER WORDS, the top left corner of the destination ! 225: * is in the source area. ! 226: * ! 227: * TEST AREA 2: The destination top is GREATER than the source top ! 228: * and its less than the source bottom: ! 229: * (src.rect.origin_y < dst.rect.origin_y < src.rect.corner_y+1) ! 230: * AND the source left is greater than the destination left ! 231: * and its less than the destination right. ! 232: * (dst.rect.origin_x < src.rect.origin_x < dst.rect.corner_x+1) ! 233: * IN OTHER WORDS, the top horizontal line of the destination ! 234: * intersects the left vertical line of the source, causing ! 235: * the right top corner of the destination to be in the ! 236: * source. ! 237: * ! 238: * src.rect.origin_x ! 239: * src.rect.origin_y +---------------------------- ! 240: * src.rect.origin_y - 1 -----------------------| ! 241: * | ! 242: * TEST AREA 2 | TEST AREA 1 ! 243: * | ! 244: * | ! 245: * src.rect.corner_y+1 ------------------------------------------------ ! 246: */ ! 247: #define checkOverlap(UI,SI) \ ! 248: SI->top_to_bot = ((UI->src_bitmap.base == UI->dst_bitmap.base) \ ! 249: && (((SI->src.rect.origin_y <= SI->dst.rect.origin_y &&\ ! 250: SI->dst.rect.origin_y < (SI->src.rect.corner_y+1))\ ! 251: && (SI->src.rect.origin_x <= SI->dst.rect.origin_x && \ ! 252: SI->dst.rect.origin_x < (SI->src.rect.corner_x+1)))\ ! 253: || ((SI->src.rect.origin_y < SI->dst.rect.origin_y && \ ! 254: SI->dst.rect.origin_y < (SI->src.rect.corner_y+1))\ ! 255: && (SI->dst.rect.origin_x < SI->src.rect.origin_x && \ ! 256: SI->src.rect.origin_x < (SI->dst.rect.corner_x+1))))) ! 257: ! 258: /* ! 259: * CalculateOffsetDst sets up pointers to a word in the destination and ! 260: * possibly to the mask bitmap using the dst_x,dst_y points given. ! 261: * It calculates the increment for each pointer from the end of one ! 262: * rectangle scanline to the beginning of the next. ! 263: */ ! 264: calculateOffsetDst(u_info,s_info,dst_x,dst_y) ! 265: register Blt_userdata *u_info; ! 266: register Blt_sysdata *s_info; ! 267: short dst_x,dst_y; /* top,left or bottom,right */ ! 268: { ! 269: /* ! 270: * Set up the destination pointer and increment. ! 271: * NOTE that (dst_y * u_info->dst_bitmap.nshorts) + DIV_BPW(dst_x) ! 272: * gives the WORD offset to base. Since we need the byte address ! 273: * this quantity must be multiplied by 2 (MUL_2). ! 274: * ! 275: * Set up destination to point to a word offset from the base address. ! 276: */ ! 277: #if (APA8 || APA8C) ! 278: if (IS_APA8orAPA8C(u_info->dst_bitmap)) { ! 279: s_info->dst_plus = 4; ! 280: s_info->dst.data = (unsigned short *)( ! 281: (long)u_info->dst_bitmap.base + ! 282: MUL_4((dst_y * ! 283: u_info->dst_bitmap.nshorts) + ! 284: DIV_BPW(dst_x))); ! 285: s_info->dst.nextline = MUL_4(u_info->dst_bitmap.nshorts - ! 286: s_info->nshorts + 1); ! 287: } ! 288: else { ! 289: s_info->dst_plus = 2; ! 290: s_info->dst.data = (unsigned short *)( ! 291: (long)u_info->dst_bitmap.base + ! 292: MUL_2((dst_y * u_info->dst_bitmap.nshorts) + ! 293: DIV_BPW(dst_x))); ! 294: s_info->dst.nextline = MUL_2(u_info->dst_bitmap.nshorts - ! 295: s_info->nshorts + 1); ! 296: } ! 297: #else no APA8 stuff ! 298: s_info->dst.data = (unsigned short *)((long)u_info->dst_bitmap.base + ! 299: MUL_2((dst_y * u_info->dst_bitmap.nshorts) + ! 300: DIV_BPW(dst_x))); ! 301: ! 302: /* ! 303: * NOTE: This increment shows the increment for the number of BYTES. ! 304: */ ! 305: s_info->dst.nextline = MUL_2(u_info->dst_bitmap.nshorts - ! 306: s_info->nshorts + 1); ! 307: #endif APA8 ! 308: ! 309: /* ! 310: * Set up the masking bitmap (if given) to point to a word ! 311: * offset from the base address. ! 312: */ ! 313: if (u_info->blt_flags & BLT_MASKON) { ! 314: /* ! 315: * Calculate the shift amount (skew) that is needed ! 316: * to align a word in the mask bitmap with a word ! 317: * in the destination. ! 318: */ ! 319: if (s_info->top_to_bot) { ! 320: computeSkewMskNeg(s_info); ! 321: ! 322: /* ! 323: * Calculate the mask pointer. ! 324: */ ! 325: s_info->msk.data = (unsigned short *)( ! 326: (long)(u_info->msk_bitmap.base) + ! 327: MUL_2((s_info->msk.rect.corner_y * ! 328: u_info->msk_bitmap.nshorts) + ! 329: DIV_BPW(s_info->msk.rect.corner_x))); ! 330: } ! 331: else { ! 332: computeSkewMskPos(s_info); ! 333: ! 334: /* ! 335: * Calculate the mask pointer. ! 336: */ ! 337: s_info->msk.data = (unsigned short *)( ! 338: (long)(u_info->msk_bitmap.base) + ! 339: MUL_2((s_info->msk.rect.origin_y * ! 340: u_info->msk_bitmap.nshorts) + ! 341: DIV_BPW(s_info->msk.rect.origin_x))); ! 342: } ! 343: ! 344: /* ! 345: * Calculate the mask increment. ! 346: */ ! 347: s_info->msk.nextline = MUL_2( u_info->msk_bitmap.nshorts - ! 348: (s_info->nshorts + ! 349: s_info->preload_msk) + 1); ! 350: } ! 351: else { ! 352: s_info->msk.data = (unsigned short *)0; ! 353: s_info->msk.nextline = 0; ! 354: } ! 355: } ! 356: ! 357: /* ! 358: * CalculateOffsetSrcNeg sets up pointers to the last word in the ! 359: * source. It also determines if "priming" must be done. ! 360: * (i.e. 2 words of source are needed for the first word of the destination.) ! 361: * When going from right to left this happens when for example you have ! 362: * 3 bits in the source (at the end of the line) (0-2) and 5 bits to fill ! 363: * in the destination (0-4). One must take those 3 bits from the source ! 364: * and put them in 2-4 in the destination and increment the source. ! 365: * ! 366: * It then calculates the increment for the source. ! 367: */ ! 368: ! 369: #if (APA8 || APA8C) ! 370: #define calculateOffsetSrcNeg(UI,SI) { \ ! 371: if (IS_APA8orAPA8C(UI->src_bitmap)) { \ ! 372: SI->src_plus = 4; \ ! 373: SI->src.data = (unsigned short *)((long)(UI->src_bitmap.base) +\ ! 374: MUL_4((SI->src.rect.corner_y * \ ! 375: UI->src_bitmap.nshorts) + \ ! 376: DIV_BPW(SI->src.rect.corner_x)));\ ! 377: SI->src.nextline = MUL_4(UI->src_bitmap.nshorts - \ ! 378: (SI->nshorts+SI->preload_src) + 1);\ ! 379: } \ ! 380: else { \ ! 381: SI->src_plus = 2; \ ! 382: SI->src.data = (unsigned short *)((long)(UI->src_bitmap.base) +\ ! 383: MUL_2((SI->src.rect.corner_y * \ ! 384: UI->src_bitmap.nshorts) + \ ! 385: DIV_BPW(SI->src.rect.corner_x))); \ ! 386: SI->src.nextline = MUL_2(UI->src_bitmap.nshorts - \ ! 387: (SI->nshorts + SI->preload_src) + 1);\ ! 388: } \ ! 389: } ! 390: #else no APA8 stuff ! 391: #define calculateOffsetSrcNeg(UI,SI) { \ ! 392: SI->src.data = (unsigned short *)((long)(UI->src_bitmap.base) + \ ! 393: MUL_2((SI->src.rect.corner_y * UI->src_bitmap.nshorts) +\ ! 394: DIV_BPW(SI->src.rect.corner_x))); \ ! 395: SI->src.nextline = MUL_2(UI->src_bitmap.nshorts - \ ! 396: (SI->nshorts+SI->preload_src) + 1); \ ! 397: } ! 398: #endif ! 399: ! 400: /* ! 401: * CalculateOffsetSrcPos sets up pointers to the first word in the ! 402: * source. It also determines if "priming" must be done. (i.e. 2 words ! 403: * of source are needed for the first word of the destination.) ! 404: * When going from left to right this happens when for example you have ! 405: * 3 bits in the source (13-15) and 5 bits to fill in the destination (11-15). ! 406: * One must take those 3 bits from the source and put them in 11-13 ! 407: * and then increment the source. ! 408: * ! 409: * It then calculates the increment for the source. ! 410: */ ! 411: #if (APA8 || APA8C) ! 412: #define calculateOffsetSrcPos(UI,SI) { \ ! 413: if (IS_APA8orAPA8C(UI->src_bitmap)) { \ ! 414: SI->src_plus = 4; \ ! 415: SI->src.data = (unsigned short *)((long)UI->src_bitmap.base + \ ! 416: MUL_4((SI->src.rect.origin_y * \ ! 417: UI->src_bitmap.nshorts) + \ ! 418: DIV_BPW(SI->src.rect.origin_x)));\ ! 419: SI->src.nextline = MUL_4(UI->src_bitmap.nshorts - \ ! 420: (SI->nshorts + SI->preload_src) + 1);\ ! 421: } \ ! 422: else { \ ! 423: SI->src_plus = 2; \ ! 424: SI->src.data = (unsigned short *)((long)UI->src_bitmap.base +\ ! 425: MUL_2((SI->src.rect.origin_y * \ ! 426: UI->src_bitmap.nshorts) + \ ! 427: DIV_BPW(SI->src.rect.origin_x))); \ ! 428: SI->src.nextline = MUL_2(UI->src_bitmap.nshorts - \ ! 429: (SI->nshorts+SI->preload_src) + 1); \ ! 430: } \ ! 431: } ! 432: #else no APA8 stuff ! 433: #define calculateOffsetSrcPos(UI,SI) { \ ! 434: SI->src.data = (unsigned short *)((long)UI->src_bitmap.base + \ ! 435: MUL_2((SI->src.rect.origin_y * UI->src_bitmap.nshorts) +\ ! 436: DIV_BPW(SI->src.rect.origin_x))); \ ! 437: SI->src.nextline = MUL_2(UI->src_bitmap.nshorts - \ ! 438: (SI->nshorts+SI->preload_src) + 1); \ ! 439: } ! 440: #endif ! 441: ! 442: /* ! 443: * Set up destination offsets. ! 444: */ ! 445: #define calculateOffsetDstNeg(UI,SI) calculateOffsetDst(UI,SI, \ ! 446: SI->dst.rect.corner_x,\ ! 447: SI->dst.rect.corner_y) ! 448: #define calculateOffsetDstPos(UI,SI) calculateOffsetDst(UI,SI, \ ! 449: SI->dst.rect.origin_x, \ ! 450: SI->dst.rect.origin_y) ! 451: ! 452: /* ! 453: * If a rule specifies the type of tile to be used then set tile_ptr. ! 454: * If tile_ptr has already been set then don't change it. ! 455: */ ! 456: #define calculateOffsetTile(UI,SI) { \ ! 457: if (SI->rule == DstClear || SI->rule == TileDstClear) { \ ! 458: SI->tile_ptr = &white.tile[0]; \ ! 459: } \ ! 460: else if (SI->rule == DstSet || SI->rule == TileDstSet \ ! 461: || SI->rule == NotDstCopy) { \ ! 462: SI->tile_ptr = &black.tile[0]; \ ! 463: } \ ! 464: else if (SI->tile_ptr == (unsigned short *)0){ \ ! 465: SI->tile_ptr = (unsigned short *)UI->tile_ptr; \ ! 466: } \ ! 467: } ! 468: ! 469: /* ! 470: * Do the bit block transfer using the information in u_info. Return -1 if ! 471: * bad pointers are given, 0 if the area clipped down to a null blt and 1 if ! 472: * the "bitblt" was done. ! 473: */ ! 474: bitblt(u_info) ! 475: register Blt_userdata *u_info; ! 476: { ! 477: register Blt_sysdata *sys_info = &blt_info; ! 478: register tmp; ! 479: register saved_loc; ! 480: int blt_status; ! 481: ! 482: DEBUGF((blt_debug > 1),printf("Enter bitblt.\r\n")); ! 483: ! 484: /* ! 485: * Set up to do this blt. blt_setup does clipping if necessary, sets ! 486: * up either the source or tile (depending on the combination rule ! 487: * being used) and sets the width and height of the blt. It returns ! 488: * zero if the blt is to be done. ! 489: */ ! 490: if ((blt_status = blt_setup(u_info,sys_info)) != 1) { ! 491: /* ! 492: * Bad pointers or the combination rule was such that nothing ! 493: * has to be done. ! 494: */ ! 495: return(blt_status); ! 496: } ! 497: else if (sys_info->width <= 0 || sys_info->height <= 0) { ! 498: /* ! 499: * Nothing to do. ! 500: */ ! 501: return(0); ! 502: } ! 503: ! 504: #ifdef USE_APA16_HDWR ! 505: /* ! 506: * Are we using hardware?? This is for debugging purposes, we ! 507: * know the software works so to test the hardware stuff we have this ! 508: * flag in blt_flags. However if we are using a mask bitmap then ! 509: * the hardware can not be used. ! 510: */ ! 511: if ((u_info->blt_flags & BLT_MASKON) == 0) { ! 512: register int ret_flag; /* Hardware return flag */ ! 513: ! 514: /* ! 515: * One can only use the hardware assist if the destination ! 516: * bitmap is the screen. ! 517: */ ! 518: ret_flag = 1; ! 519: if (IS_APA16(u_info->dst_bitmap)) { ! 520: extern unsigned short execute_cmd[]; ! 521: ! 522: /* ! 523: * Check and see if there is a hardware function ! 524: * (execute command) for this rule. ! 525: */ ! 526: if (execute_cmd[sys_info->rule]) { ! 527: if (sys_info->is_src) { ! 528: if (IS_APA16(u_info->src_bitmap)) { ! 529: /* ! 530: * Pass in the pointers to ! 531: * the screen because if they ! 532: * are greater than the first ! 533: * byte address in the APA16 ! 534: * buffer things will not ! 535: * work. ! 536: */ ! 537: sys_info->dst.data = ! 538: u_info->dst_bitmap.base; ! 539: sys_info->src.data = ! 540: u_info->src_bitmap.base; ! 541: ret_flag = apa16_StoS(sys_info); ! 542: } ! 543: else { ! 544: /* ! 545: * The APA-16 does memory to ! 546: * screen stuff. But first ! 547: * The source address and ! 548: * and the source "nextline" ! 549: * field must also be ! 550: * calculated. ! 551: * ! 552: * NOT IMPLEMENTED YET. ! 553: * ! 554: * computeSkewPos(sys_info); ! 555: * calculateOffsetSrcPos(u_info, ! 556: * sys_info); ! 557: * ret_flag = ! 558: * apa16_MtoS(sys_info); ! 559: */ ! 560: } ! 561: } ! 562: else { ! 563: /* ! 564: * The tile ptr has not been set up yet. ! 565: */ ! 566: sys_info->tile_ptr = (unsigned short *) ! 567: u_info->tile_ptr; ! 568: ret_flag = apa16_copyTile(sys_info); ! 569: } ! 570: ! 571: /* ! 572: * Check the status of the hardware blt, if ! 573: * its 0 then everything was done successfully. ! 574: */ ! 575: if (ret_flag == 0) { ! 576: ! 577: /* ! 578: * Indicate that a blt was done. ! 579: */ ! 580: return(1); ! 581: } ! 582: } ! 583: } ! 584: } ! 585: ! 586: /* ! 587: * Regardless of the hardware flag, if we get here it means ! 588: * that we are going to use the software to blt. If the screen ! 589: * is to be changed then we must wait for the rasterop engine to finish ! 590: * with the screen if it is still using the screen. ! 591: */ ! 592: if (*QUE_COUNT_R != 0) { ! 593: if (IS_APA16(u_info->dst_bitmap) || ! 594: (IS_APA16(u_info->src_bitmap))) { ! 595: WAIT_QUE(tmp,0); ! 596: } ! 597: } ! 598: ! 599: #endif USE_APA16_HDWR ! 600: ! 601: #ifdef AED ! 602: /* ! 603: * If this is a screen to screen blt on the AED have the microcode ! 604: * make the screen changes while the bltter alters the ! 605: * offscreen bitmap. ! 606: */ ! 607: ! 608: if (IS_AED(u_info->src_bitmap) && IS_AED(u_info->dst_bitmap) && ! 609: (u_info->blt_flags & BLT_ECHO)) { ! 610: aed_screen_copy(sys_info->src.rect.origin_x, ! 611: sys_info->src.rect.origin_y, ! 612: sys_info->dst.rect.origin_x, ! 613: sys_info->dst.rect.origin_y, ! 614: (short) sys_info->width, ! 615: (short) sys_info->height, ! 616: sys_info->rule); ! 617: blt_status = 0; ! 618: } ! 619: #endif AED ! 620: ! 621: /* ! 622: * Remove the locator from the screen if it is a software locator that ! 623: * is actually in (on) the source or destination bitmap. Hardware ! 624: * locators (as in the APA-16) are not removed. ! 625: */ ! 626: SAVE_LOCATOR(); ! 627: ! 628: /* ! 629: * Calculate the edge masks for the destination. (See computeMasks ! 630: * in Smalltalk-80) ! 631: */ ! 632: computeMasks(sys_info); ! 633: ! 634: /* ! 635: * If the source is to be used then things will be done differently ! 636: * than if a tile is used. ! 637: */ ! 638: if (sys_info->is_src) { ! 639: /* ! 640: * Check for overlapping source and destination. (See ! 641: * checkOverlap in Smalltalk-80) Sets sys_info->top_to_bot ! 642: * non-zero if we must copy from bottom to top, right to ! 643: * left instead of top to bottom, left to right. ! 644: */ ! 645: checkOverlap(u_info,sys_info); ! 646: ! 647: if (sys_info->top_to_bot) { ! 648: /* ! 649: * Calculate the shift amount (skew) that is needed ! 650: * to align a word in the source with a word in the ! 651: * destination. ! 652: */ ! 653: computeSkewNeg(sys_info); ! 654: ! 655: /* ! 656: * Set up pointers to the source, destination ! 657: * and possibly to the mask bitmap. Also set up ! 658: * shift amounts (skews) for the mask bitmap if needed. ! 659: * Calculate the increment for each pointer from ! 660: * the end of one rectangle scanline to the beginning ! 661: * of the next. ! 662: */ ! 663: calculateOffsetSrcNeg(u_info,sys_info); ! 664: calculateOffsetDstNeg(u_info,sys_info); ! 665: ! 666: /* ! 667: * Do the blt from bottom to top, right to left!! ! 668: */ ! 669: if (u_info->blt_flags & BLT_MASKON) { ! 670: maskBitNeg(sys_info); ! 671: } ! 672: else { ! 673: /* ! 674: * Just copy from source to destination ! 675: * going bottom to top, right to left. ! 676: * No mask bitmap to worry about. ! 677: */ ! 678: copyBitNeg(sys_info); ! 679: } ! 680: } ! 681: else { ! 682: /* ! 683: * Calculate the shift amount (skew) that is needed ! 684: * to align a word in the source with a word in the ! 685: * destination. ! 686: */ ! 687: computeSkewPos(sys_info); ! 688: ! 689: /* ! 690: * Set up pointers to the source, destination ! 691: * and possibly to the mask bitmap. ! 692: * Also set up shift amounts (skews) for the mask ! 693: * bitmap if needed. Calculate the increment for ! 694: * each pointer from the end of one rectangle ! 695: * scanline to the beginning of the next. ! 696: */ ! 697: calculateOffsetSrcPos(u_info,sys_info); ! 698: calculateOffsetDstPos(u_info,sys_info); ! 699: ! 700: /* ! 701: * Do the blt from top to bottom, left to right!! ! 702: */ ! 703: if (u_info->blt_flags & BLT_MASKON) { ! 704: /* ! 705: * Copy from source to destination going ! 706: * top to bottom, left to right. Use the ! 707: * mask bitmap. ! 708: */ ! 709: maskBitPos(sys_info); ! 710: } ! 711: else { ! 712: /* ! 713: * Just copy from source to destination ! 714: * going top to bottom, left to right. ! 715: */ ! 716: if (sys_info->nshorts < 3) { ! 717: /* ! 718: * Optimize this very important routine ! 719: * for one and two shorts in the dst ! 720: * changed. ! 721: */ ! 722: smallcopyBitPos(sys_info); ! 723: } ! 724: else { ! 725: copyBitPos(sys_info); ! 726: } ! 727: } ! 728: } ! 729: } ! 730: else { ! 731: /* ! 732: * We have a TILE rule. ! 733: */ ! 734: sys_info->top_to_bot = 0; ! 735: ! 736: /* ! 737: * Set up pointers to the tile and destination and possibly ! 738: * to the mask bitmap. Calculate the increment for ! 739: * each pointer from the end of one rectangle scanline to ! 740: * the beginning of the next. ! 741: * NOTE: The pointer to the tile may have been set in ! 742: * blt_setup. ! 743: */ ! 744: calculateOffsetTile(u_info,sys_info); ! 745: calculateOffsetDstPos(u_info,sys_info); ! 746: ! 747: /* ! 748: * Do the tile blt! ! 749: */ ! 750: if (u_info->blt_flags & BLT_MASKON) { ! 751: maskTile(sys_info); ! 752: } ! 753: else { ! 754: copyTile(sys_info); ! 755: } ! 756: } ! 757: ! 758: /* ! 759: * Restore the locator if the screen was dealt with. ! 760: */ ! 761: RESTORE_LOCATOR(); ! 762: ! 763: #ifdef AED ! 764: /* ! 765: * If we are echoing to AED, keep track of bounding ! 766: * rectangle of the updated screen area. ! 767: */ ! 768: ! 769: if (IS_AED(u_info->dst_bitmap) && blt_status && ! 770: (u_info->blt_flags & BLT_ECHO)) { ! 771: aed_echo_rect(&changed_rect); ! 772: } ! 773: #endif AED ! 774: ! 775: /* ! 776: * Indicate that a blt was done. ! 777: */ ! 778: return(1); ! 779: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.