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
bitmapinit()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
bm_pallet_read(entry)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
bm_pallet_write(entry,val)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
sftjis_to_jis(h,l)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
setropfunc(func,transp,fore,aux)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
move_rect(src_x,src_y,width,height,dst_x,dst_y,rop)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
clear_rect(x,y,width,height,rop,fore,aux)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
line(param)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 */
cursor_on(p)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 */
cursor_off()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 */
move_lines(sl,nl,dl)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 */
move_chars(sx,sy,nchar,dx)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 */
clear_lines(sl,nl,rev,fcol,bcol)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 */
clear_chars(x,y,nchar,rev,fcol,bcol)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
reverse_rec(fcol,bcol)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
copy_char(sp,c,kanji)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