1 /* 2 * Copyright (c) 1992, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Sony Corp. and Kazumasa Utashiro of Software Research Associates, Inc. 7 * 8 * %sccs.include.redist.c% 9 * 10 * from: $Hdr: bitmapif.c,v 4.300 91/06/09 06:14:40 root Rel41 $ SONY 11 * 12 * @(#)bitmapif.c 8.1 (Berkeley) 06/10/93 13 */ 14 15 #ifdef IPC_MRX 16 #include <sys/param.h> 17 #include <sys/types.h> 18 #include <news3400/iop/framebuf.h> 19 #include <news3400/iop/fbreg.h> 20 #else 21 #include <sys/param.h> 22 #include <sys/types.h> 23 #include <news3400/iop/framebuf.h> 24 #include <news3400/iop/fbreg.h> 25 #endif 26 27 #include <news3400/fb/fbdefs.h> 28 29 #include <news3400/bm/vt100.h> 30 #include <news3400/bm/bitmapif.h> 31 32 extern int bm_todo; 33 extern int tmode; 34 35 #ifdef CPU_SINGLE 36 extern char *ext_fnt_addr[]; 37 extern char *ext_fnt24_addr[]; 38 #else /* CPU_SINGLE */ 39 extern char **ext_fnt_addr; 40 extern char **ext_fnt24_addr; 41 #define lock_bitmap() 42 #define unlock_bitmap() 43 #endif /* CPU_SINGLE */ 44 45 extern SCREEN screen; 46 47 #ifdef IPC_MRX 48 extern int bitmap_use; 49 #endif 50 51 #ifdef CPU_SINGLE 52 #include <machine/cpu.h> 53 #define PRE_EMPT need_resched() 54 #else 55 #define PRE_EMPT 56 #endif 57 58 short zero[32 * 2]; 59 struct csr_buf local_csr_buf; 60 61 #ifdef CPU_SINGLE 62 struct fb_map rommap; 63 #endif 64 65 bitmapinit() 66 { 67 fbbm_rop_reset(consfb); 68 if (!consfb->Mono) { 69 lock_bitmap(); 70 fbbm_init_palette(consfb); 71 unlock_bitmap(); 72 } 73 } 74 75 bm_pallet_read(entry) 76 int entry; 77 { 78 lPalette lp; 79 sPalette palette; 80 #ifdef CPU_SINGLE 81 struct fb_map rommap; 82 #endif 83 84 lock_bitmap(); 85 86 lp.count = 1; 87 #ifdef CPU_SINGLE 88 lp.palette = (sPalette *)&rommap; 89 rommap.fm_vaddr = (caddr_t)&palette; 90 rommap.fm_offset = 0; 91 #else 92 lp.palette = &palette; 93 #endif 94 palette.index = entry; 95 96 fbbm_get_palette(consfb, &lp); 97 98 unlock_bitmap(); 99 100 return((palette.rgb.r << 16) | (palette.rgb.g << 8) | palette.rgb.b); 101 } 102 103 bm_pallet_write(entry, val) 104 int entry; 105 int val; 106 { 107 lPalette lp; 108 sPalette palette; 109 #ifdef CPU_SINGLE 110 struct fb_map rommap; 111 #endif 112 113 lock_bitmap(); 114 115 lp.count = 1; 116 #ifdef CPU_SINGLE 117 lp.palette = (sPalette *)&rommap; 118 rommap.fm_vaddr = (caddr_t)&palette; 119 rommap.fm_offset = 0; 120 #else 121 lp.palette = &palette; 122 #endif 123 palette.index = entry; 124 palette.rgb.r = ((val >> 16) & 0xff); 125 palette.rgb.g = ((val >> 8) & 0xff); 126 palette.rgb.b = (val & 0xff); 127 fbbm_set_palette(consfb, &lp); 128 129 unlock_bitmap(); 130 131 return(val); 132 } 133 134 unsigned 135 sftjis_to_jis(h, l) 136 register unsigned int h, l; 137 { 138 if ((h >= JVR1S) && (h <= JVR1E)) 139 h -= JVR1S; 140 else if ((h >= JVR2S) && (h <= JVR2E)) 141 h = h - JVR2S + 0x1f; 142 else 143 return (0); 144 145 h <<= 1; 146 147 if ((l >= JHR1S) && (l <= JHR1E)) 148 l -= JHR1S; 149 else if ((l >= JHR2S) && (l <= JHR2E)) 150 l = l - JHR2S + 0x3f; 151 else if ((l >= JHR3S) && (l <= JHR3E)) { 152 l -= JHR3S; 153 h++; 154 } else 155 return (0); 156 157 return(((h + 0x21) << 8) + l + 0x21); 158 } 159 160 setropfunc(func, transp, fore, aux) 161 int func, fore, aux; 162 { 163 char tmp[4]; 164 register int i = consfb->fbNplane; 165 register char *funcp = consfb->funcvec; 166 167 consfb->func = func; 168 consfb->fore = fore; 169 consfb->aux = aux; 170 consfb->trans = transp; 171 172 tmp[0] = TRANS(transp, (func & 0x0c) | (func>>2)); 173 tmp[1] = TRANS(transp, (func>>2) | ((func<<2) & 0x0c)); 174 tmp[2] = TRANS(transp, func); 175 tmp[3] = TRANS(transp, (func<<2) & 0x0c | func & 3); 176 177 while (--i >= 0) { 178 *funcp++ = tmp[((fore & 1) << 1) | (aux & 1)]; 179 fore >>= 1; aux >>= 1; 180 } 181 } 182 183 move_rect(src_x, src_y, width, height, dst_x, dst_y, rop) 184 int src_x, src_y; 185 int width, height; 186 int dst_x, dst_y; 187 int rop; 188 { 189 lRectangle sr; 190 lPoint dp; 191 192 sr.origin.x = src_x; 193 sr.origin.y = src_y; 194 sr.extent.x = width; 195 sr.extent.y = height; 196 197 dp.x = dst_x; 198 dp.y = dst_y; 199 200 lock_bitmap(); 201 setropfunc(rop, 0, consfb->planemask, 0); 202 fbbm_rop_init(consfb, consfb->funcvec); 203 fbbm_rop_copy(consfb, &sr, &dp, 0, consfb->planemask); 204 unlock_bitmap(); 205 } 206 207 clear_rect(x, y, width, height, rop, fore, aux) 208 int x, y; 209 int width, height; 210 int rop; 211 int fore; 212 int aux; 213 { 214 lRectangle dr; 215 216 dr.origin.x = x; 217 dr.origin.y = y; 218 dr.extent.x = width; 219 dr.extent.y = height; 220 221 lock_bitmap(); 222 setropfunc(rop, 0, fore, aux); 223 fbbm_rop_cinit(consfb, consfb->planemask, 1); 224 fbbm_rop_clear(consfb, &dr); 225 unlock_bitmap(); 226 } 227 228 line(param) 229 short *param; 230 { 231 lPoint p[2]; 232 lRectangle clip; 233 234 p[0].x = param[0]; 235 p[0].y = param[1]; 236 p[1].x = param[2]; 237 p[1].y = param[3]; 238 clip = consfb->VisRect; 239 240 lock_bitmap(); 241 fbbm_rop_vect(consfb, &clip, param[4] & 0xf, 242 fbbm_get_pixel(consfb, param[5]), 0, 1, 243 consfb->planemask, 2, p, LINE_SLD, 1, 0); 244 unlock_bitmap(); 245 } 246 247 /* 248 * cursor on 249 * cursor_on(x, y, plane) puts cursor at position (x, y) with color = plane, 250 * if cursor sw is off. 251 * At the same time the image of cursor position is saved. 252 */ 253 cursor_on(p) 254 lPoint *p; 255 { 256 register struct csr_buf *csr_bp = &local_csr_buf; 257 register lRectangle *dr; 258 259 if (screen.s_term_mode & DECCSR_ACTV && 260 bm_todo <= 0 && csr_bp->csr_sw == C_OFF) { 261 262 if (csr_bp->csr_number == 2 && p->x != rit_m) 263 dr = &char_r2; 264 else 265 dr = &char_r1; 266 267 dr->origin = *p; 268 269 lock_bitmap(); 270 setropfunc(BF_DI, 0, consfb->planemask, 0); 271 fbbm_rop_init(consfb, consfb->funcvec); 272 fbbm_rop_copy(consfb, dr, dr, 0, (fcolor^bcolor) & consfb->planemask); 273 unlock_bitmap(); 274 275 csr_bp->csr_sw = C_ON; 276 csr_bp->csr_p = *p; 277 } 278 } 279 280 /* 281 * cursor off 282 * cursor_off() turns off cursor. 283 * The image of cursor position which has previously saved by cursor_on 284 * is restored. 285 */ 286 cursor_off() 287 { 288 register struct csr_buf *csr_bp = &local_csr_buf; 289 register lRectangle *dr; 290 291 if (screen.s_term_mode & DECCSR_ACTV && csr_bp->csr_sw == C_ON) { 292 if (csr_bp->csr_number == 2 && csr_bp->csr_x != rit_m) 293 dr = &char_r2; 294 else 295 dr = &char_r1; 296 297 dr->origin = csr_bp->csr_p; 298 299 lock_bitmap(); 300 setropfunc(BF_DI, 0, consfb->planemask, 0); 301 fbbm_rop_init(consfb, consfb->funcvec); 302 fbbm_rop_copy(consfb, dr, dr, 0, (fcolor^bcolor) & consfb->planemask); 303 unlock_bitmap(); 304 305 csr_bp->csr_sw = C_OFF; 306 } 307 } 308 309 /* 310 * move lines 311 * move_lines(sl, nl, dl) moves nl lines starting at line sl to line dl. 312 */ 313 move_lines(sl, nl, dl) 314 int sl, nl, dl; 315 { 316 move_rect(x_ofst, char_h*(sl - 1) + y_ofst, char_w*(rit_m - LFT_M + 1), 317 char_h*nl, x_ofst, char_h*(dl - 1) + y_ofst, BF_S); 318 PRE_EMPT; 319 } 320 321 /* 322 * move chars 323 * move_chars(sx, sy, nchar, dx) moves nchar characters at position (sx, sy) 324 * to (dx, sy). 325 */ 326 move_chars(sx, sy, nchar, dx) 327 int sx, sy; 328 int nchar; 329 int dx; 330 { 331 move_rect(char_w*(sx - 1) + x_ofst, char_h*(sy - 1) + y_ofst, 332 char_w * nchar, char_h, 333 char_w*(dx - 1) + x_ofst, char_h*(sy - 1) + y_ofst, BF_S); 334 } 335 336 /* 337 * clear lines 338 * clear_lines(sl, nl, rev) clears nl lines starting at line sl with rev 339 * mode. If rev = 0 then normal clear else reverse clear. 340 */ 341 clear_lines(sl, nl, rev, fcol, bcol) 342 int sl, nl; 343 int rev; 344 int fcol, bcol; 345 { 346 if (nl == btm_m) { 347 clear_rect(0, 0, scr_w, scr_h, BF_S, rev?fcol:bcol, bcol); 348 } else if (nl > 0) { 349 clear_rect(x_ofst, char_h*(sl - 1) + y_ofst, 350 char_w*(rit_m - LFT_M + 1), char_h*nl, 351 BF_S, rev?fcol:bcol, bcol); 352 } 353 } 354 355 /* 356 * Clear chars 357 * clear_chars(x, y, nchar, rev) clears nchar characters following the 358 * position (x, y) with rev mode. If rev = 0 then normal clear else 359 * reverse clear. 360 */ 361 clear_chars(x, y, nchar, rev, fcol, bcol) 362 int x, y; 363 int nchar; 364 int rev; 365 int fcol, bcol; 366 { 367 if (nchar > 0) { 368 clear_rect(char_w*(x - 1) + x_ofst, char_h*(y - 1) + y_ofst, 369 char_w*nchar, char_h, BF_S, rev?fcol:bcol, bcol); 370 } 371 } 372 373 reverse_rec(fcol, bcol) 374 int fcol, bcol; 375 { 376 clear_rect(0, 0, scr_w, scr_h, BF_SDX, fcol^bcol, 0); 377 } 378 379 copy_char(sp, c, kanji) 380 register SCREEN *sp; 381 register unsigned int c; 382 int kanji; 383 { 384 register char *f_addr; 385 register int len; 386 register lRectangle *sr, *dr; 387 lRectangle udr; 388 register char **fnt_addr; 389 extern struct fb_map rommap; 390 391 lock_bitmap(); 392 393 if (consfb->font_h == 24) 394 fnt_addr = ext_fnt24_addr; 395 else 396 fnt_addr = ext_fnt_addr; 397 398 if (kanji) { 399 dr = &char_r2; 400 sr = &font_r2; 401 len = font_len2; 402 } else { 403 dr = &char_r1; 404 sr = &font_r1; 405 len = font_len1; 406 } 407 408 dr->origin = sp->s_csr.csr_p; 409 410 setropfunc(BF_S, 0, fcolor, bcolor); 411 fbbm_rop_cinit(consfb, consfb->planemask, 0); 412 fbbm_rop_clear(consfb, dr); 413 414 if (kanji) { 415 /* 416 * KANJI code... kanji char 417 */ 418 f_addr = (char *)fbbm_Krom_addr(consfb, c, sr); 419 #ifdef CPU_DOUBLE 420 } else if (fnt_addr == 0) { 421 /* 422 * no external fonts... try to use ROM fonts 423 */ 424 len = font_len2; 425 f_addr = (char *)fbbm_Krom_addr(consfb, c, sr); 426 #endif 427 #ifdef KM_ASCII 428 } else if (tmode == KM_ASCII) { 429 /* 430 * terminal mode is ASCII... ASCII (ISO) char 431 */ 432 if ((c >= 0x20) && (c <= 0x7e)) { 433 /* 434 * ASCII char 435 */ 436 f_addr = fnt_addr[c]; 437 } else if ((c >= 0xa0) && (c <= 0xff)) { 438 /* 439 * ISO char 440 */ 441 f_addr = fnt_addr[c - 32]; 442 } else { 443 /* 444 * UNKNOWN char 445 */ 446 f_addr = (caddr_t)zero; 447 } 448 #endif /* KM_ASCII */ 449 } else { 450 /* 451 * terminal mode is not ASCII... JIS, SJIS, EUC, ... 452 */ 453 if ((c >= 0x20) && (c <= 0x7e)) { 454 /* 455 * ASCII char 456 */ 457 f_addr = fnt_addr[c]; 458 } else if ((c >= 0xa1) && (c <= 0xdf)) { 459 /* 460 * KANA char 461 */ 462 f_addr = fnt_addr[c + 32]; 463 } else { 464 /* 465 * UNKNOWN char 466 */ 467 f_addr = (caddr_t)zero; 468 } 469 } 470 471 dr->origin.y += ch_pos; 472 473 setropfunc(BF_S, 1, fcolor, bcolor); 474 475 if (f_addr != 0) { 476 fbbm_rop_winit(consfb); 477 rommap.fm_vaddr = f_addr; 478 rommap.fm_offset = 0; 479 fbbm_rop_write(consfb, &rommap, rommap.fm_offset, len, 480 sr, &dr->origin, consfb->planemask); 481 if (sp->s_csr.csr_attributes & BOLD) { 482 dr->origin.x += 1; 483 fbbm_rop_write(consfb, &rommap, rommap.fm_offset, len, 484 sr, &dr->origin, consfb->planemask); 485 } 486 } else { 487 fbbm_rop_init(consfb, consfb->funcvec); 488 fbbm_rop_copy(consfb, sr, &dr->origin, 1, consfb->planemask); 489 if (sp->s_csr.csr_attributes & BOLD) { 490 dr->origin.x += 1; 491 fbbm_rop_copy(consfb, sr, &dr->origin, 1, consfb->planemask); 492 } 493 } 494 495 if (sp->s_csr.csr_attributes & USCORE) { 496 497 udr.origin.x = sp->s_csr.csr_p.x; 498 udr.origin.y = sp->s_csr.csr_p.y + ul_pos; 499 udr.extent.x = char_w; 500 udr.extent.y = 1; 501 502 setropfunc(BF_S, 1, fcolor, bcolor); 503 fbbm_rop_cinit(consfb, consfb->planemask, 1); 504 fbbm_rop_clear(consfb, &udr); 505 } 506 unlock_bitmap(); 507 } 508 509 vt_flush(spc) 510 struct cursor *spc; 511 { 512 register char *f_addr; 513 register int len; 514 register lRectangle *sr, *dr; 515 lRectangle fr, cr; 516 register int i; 517 register unsigned int c; 518 lRectangle udr; 519 register char **fnt_addr; 520 char *oldf_addr = (char *)-1; 521 extern struct fb_map rommap; 522 523 if (fp == 0) 524 return; 525 526 cursor_off(); 527 528 lock_bitmap(); 529 530 if (consfb->font_h == 24) 531 fnt_addr = ext_fnt24_addr; 532 else 533 fnt_addr = ext_fnt_addr; 534 535 udr.origin = fpp; 536 udr.extent.x = fpn * char_w; 537 udr.extent.y = char_h; 538 539 setropfunc(BF_S, 0, fcolor, bcolor); 540 fbbm_rop_cinit(consfb, consfb->planemask, 0); 541 fbbm_rop_clear(consfb, &udr); 542 543 if (fpa & BOLD) 544 setropfunc(BF_S, 1, fcolor, bcolor); 545 else 546 setropfunc(BF_S, 0, fcolor, bcolor); 547 548 fbbm_rop_winit(consfb); 549 550 sr = &fr; 551 dr = &cr; 552 sr->origin.x = 0; 553 sr->origin.y = 0; 554 sr->extent.y = font_h; 555 dr->origin.x = fpp.x; 556 dr->origin.y = fpp.y + ch_pos; 557 558 for (i = 0; i < fp; i++) { 559 c = fbuf[i]; 560 561 sr->extent.x = font_w; 562 dr->extent.x = char_w; 563 564 if (c & 0xff00) { 565 /* 566 * KANJI code... kanji char 567 */ 568 sr->extent.x = font_r2.extent.x; 569 dr->extent.x = char_r2.extent.x; 570 len = font_len2; 571 f_addr = (char *)fbbm_Krom_addr(consfb, c, sr); 572 #ifdef CPU_DOUBLE 573 } else if (fnt_addr == 0) { 574 /* 575 * no external fonts... try to use ROM fonts 576 */ 577 sr->extent.x = font_r1.extent.x; /*XXX*/ 578 dr->extent.x = char_r1.extent.x; /*XXX*/ 579 len = font_len2; 580 f_addr = (char *)fbbm_Krom_addr(consfb, c, sr); 581 #endif 582 #ifdef KM_ASCII 583 } else if (tmode == KM_ASCII) { 584 /* 585 * terminal mode is ASCII... ASCII (ISO) char 586 */ 587 len = font_len1; 588 if ((c >= 0x20) && (c <= 0x7e)) { 589 /* 590 * ASCII char 591 */ 592 f_addr = fnt_addr[c]; 593 } else if ((c >= 0xa0) && (c <= 0xff)) { 594 /* 595 * ISO char 596 */ 597 f_addr = fnt_addr[c - 32]; 598 } else { 599 /* 600 * UNKNOWN char 601 */ 602 f_addr = (caddr_t)zero; 603 } 604 #endif /* KM_ASCII */ 605 } else { 606 /* 607 * terminal mode is not ASCII... JIS, SJIS, EUC, ... 608 */ 609 len = font_len1; 610 if ((c >= 0x20) && (c <= 0x7e)) { 611 /* 612 * ASCII char 613 */ 614 f_addr = fnt_addr[c]; 615 } else if ((c >= 0xa1) && (c <= 0xdf)) { 616 /* 617 * KANA char 618 */ 619 f_addr = fnt_addr[c + 64]; 620 } else { 621 /* 622 * UNKNOWN char 623 */ 624 f_addr = (caddr_t)zero; 625 } 626 } 627 628 if (f_addr != 0) { 629 if (oldf_addr == 0) 630 fbbm_rop_winit(consfb); 631 632 rommap.fm_vaddr = f_addr; 633 rommap.fm_offset = 0; 634 fbbm_rop_write(consfb, &rommap, rommap.fm_offset, len, 635 sr, &dr->origin, consfb->planemask); 636 if (fpa & BOLD) { 637 /* 638 * Bold char 639 */ 640 dr->origin.x += 1; 641 fbbm_rop_write(consfb, &rommap, 642 rommap.fm_offset, len, 643 sr, &dr->origin, consfb->planemask); 644 dr->origin.x -= 1; 645 } 646 } else { 647 if (oldf_addr != 0) 648 fbbm_rop_init(consfb, consfb->funcvec); 649 650 fbbm_rop_copy(consfb, sr, &dr->origin, 1, consfb->planemask); 651 if (fpa & BOLD) { 652 /* 653 * Bold char 654 */ 655 dr->origin.x += 1; 656 fbbm_rop_copy(consfb, sr, &dr->origin, 657 1, consfb->planemask); 658 dr->origin.x -= 1; 659 } 660 661 } 662 dr->origin.x += dr->extent.x; 663 oldf_addr = f_addr; 664 665 /* 666 * sr->origin.x and sr->origin.y were changed by 667 * fbpop_Krom_addr(), fb254_Krom_addr(). 668 */ 669 sr->origin.x = 0; 670 sr->origin.y = 0; 671 } 672 673 if (fpa & USCORE) { 674 udr.origin.y += ul_pos; 675 udr.extent.y = 1; 676 677 setropfunc(BF_S, 1, fcolor, bcolor); 678 fbbm_rop_cinit(consfb, consfb->planemask, 1); 679 fbbm_rop_clear(consfb, &udr); 680 } 681 fp = 0; 682 683 unlock_bitmap(); 684 685 dr->origin.y -= ch_pos; 686 cursor_on(&(spc->csr_p)); 687 } 688