1 /* driver.c Framebuffer primitives */
2
3
4 #include <sys/endian.h>
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include <vga.h>
9
10 #include "inlstring.h" /* include inline string operations */
11 #include "vgagl.h"
12 #include "def.h"
13 #include "driver.h"
14
15
16 #define MAXBYTEWIDTH 4096 /* used in bitblt emulation */
17
18 /* All functions that simply call another function with slightly different
19 * parameter values are declared inline. */
20 #define INLINE inline
21
22 #define NOTIMPL(s) { notimplemented(s); return; }
23
24 /* in: vp = video offset; out: rvp = video pointer, chunksize, page */
25 #define SETWRITEPAGED(vp, rvp, chunksize, page) \
26 page = vp >> 16; \
27 vga_setpage(page); \
28 rvp = (vp & 0xffff) + VBUF; \
29 chunksize = 0x10000 - (vp & 0xffff);
30
RGB2BGR(int c)31 static inline int RGB2BGR(int c)
32 {
33 /* a bswap would do the same as the first 3 but in only ONE! cycle. */
34 /* However bswap is not supported by 386 */
35
36 if (MODEFLAGS & MODEFLAG_24BPP_REVERSED)
37 c = bswap32(c) >> 8;
38 return c;
39 }
40
41 /* RGB_swapped_memcopy returns the amount of bytes unhandled */
RGB_swapped_memcpy(char * dest,char * source,int len)42 static inline int RGB_swapped_memcpy(char *dest, char *source, int len)
43 {
44 int rest, tmp;
45
46 tmp = len / 3;
47 rest = len - 3 * tmp;
48 len = tmp;
49
50 while (len--) {
51 *dest++ = source[2];
52 *dest++ = source[1];
53 *dest++ = source[0];
54 source += 3;
55 }
56
57 return rest;
58 }
59
notimplemented(char * s)60 static void notimplemented(char *s)
61 {
62 printf("vgagl: %s not implemented.\n", s);
63 }
64
65
66
67 /* One byte per pixel frame buffer primitives */
68
69 #define ASSIGNVP8(x, y, vp) vp = VBUF + (y) * BYTEWIDTH + (x);
70 #define ASSIGNVPOFFSET8(x, y, vp) vp = (y) * BYTEWIDTH + (x);
71
__svgalib_driver8_setpixel(int x,int y,int c)72 void __svgalib_driver8_setpixel(int x, int y, int c)
73 {
74 #ifdef __alpha__
75 vga_setcolor(c);
76 vga_drawpixel(x, y);
77 #else
78 char *vp;
79 ASSIGNVP8(x, y, vp);
80 *vp = c;
81 #endif
82 }
83
__svgalib_driver8p_setpixel(int x,int y,int c)84 void __svgalib_driver8p_setpixel(int x, int y, int c)
85 {
86 int vp;
87 ASSIGNVPOFFSET8(x, y, vp);
88 vga_setpage(vp >> 16);
89 *(VBUF + (vp & 0xffff)) = c;
90 }
91
__svgalib_driver8_getpixel(int x,int y)92 int __svgalib_driver8_getpixel(int x, int y)
93 {
94 char *vp;
95 ASSIGNVP8(x, y, vp);
96 return *vp;
97 }
98
__svgalib_driver8p_getpixel(int x,int y)99 int __svgalib_driver8p_getpixel(int x, int y)
100 {
101 int vp;
102 ASSIGNVPOFFSET8(x, y, vp);
103 vga_setpage(vp >> 16);
104 return *(VBUF + (vp & 0xffff));
105 }
106
__svgalib_driver8_hline(int x1,int y,int x2,int c)107 void __svgalib_driver8_hline(int x1, int y, int x2, int c)
108 {
109 char *vp;
110 ASSIGNVP8(x1, y, vp);
111 __memset(vp, c, x2 - x1 + 1);
112 }
113
__svgalib_driver8p_hline(int x1,int y,int x2,int c)114 void __svgalib_driver8p_hline(int x1, int y, int x2, int c)
115 {
116 int vp;
117 char *rvp;
118 int l;
119 int chunksize, page;
120 ASSIGNVPOFFSET8(x1, y, vp);
121 SETWRITEPAGED(vp, rvp, chunksize, page);
122 l = x2 - x1 + 1;
123 if (l <= chunksize)
124 __memset(rvp, c, l);
125 else {
126 __memset(rvp, c, chunksize);
127 vga_setpage(page + 1);
128 __memset(VBUF, c, l - chunksize);
129 }
130 }
131
__svgalib_driver8_fillbox(int x,int y,int w,int h,int c)132 void __svgalib_driver8_fillbox(int x, int y, int w, int h, int c)
133 {
134 char *vp;
135 int i;
136 ASSIGNVP8(x, y, vp);
137 for (i = 0; i < h; i++) {
138 __memset(vp, c, w);
139 vp += BYTEWIDTH;
140 }
141 }
142
__svgalib_driver8a_fillbox(int x,int y,int w,int h,int c)143 void __svgalib_driver8a_fillbox(int x, int y, int w, int h, int c)
144 {
145 if (w * h < 128)
146 (*__svgalib_nonaccel_fillbox)(x, y, w, h, c);
147 else {
148 vga_accel(ACCEL_SETFGCOLOR, c);
149 vga_accel(ACCEL_FILLBOX, x, y, w, h);
150 }
151 }
152
__svgalib_driver8p_fillbox(int x,int y,int w,int h,int c)153 void __svgalib_driver8p_fillbox(int x, int y, int w, int h, int c)
154 {
155 int vp;
156 int page;
157 int i;
158 ASSIGNVPOFFSET8(x, y, vp);
159 page = vp >> 16;
160 vp &= 0xffff;
161 vga_setpage(page);
162 for (i = 0; i < h; i++) {
163 if (vp + w > 0x10000) {
164 if (vp >= 0x10000) {
165 page++;
166 vga_setpage(page);
167 vp &= 0xffff;
168 } else { /* page break within line */
169 __memset(VBUF + vp, c, 0x10000 - vp);
170 page++;
171 vga_setpage(page);
172 __memset(VBUF, c, (vp + w) & 0xffff);
173 vp = (vp + BYTEWIDTH) & 0xffff;
174 continue;
175 }
176 };
177 __memset(VBUF + vp, c, w);
178 vp += BYTEWIDTH;
179 }
180 }
181
__svgalib_driver8_putbox(int x,int y,int w,int h,void * b,int bw)182 void __svgalib_driver8_putbox(int x, int y, int w, int h, void *b, int bw)
183 {
184 char *vp; /* screen pointer */
185 char *bp; /* bitmap pointer */
186 int i;
187 ASSIGNVP8(x, y, vp);
188 bp = b;
189 for (i = 0; i < h; i++) {
190 __memcpy(vp, bp, w);
191 bp += bw;
192 vp += BYTEWIDTH;
193 }
194 }
195
__svgalib_driver8p_putbox(int x,int y,int w,int h,void * b,int bw)196 void __svgalib_driver8p_putbox(int x, int y, int w, int h, void *b, int bw)
197 {
198 /* extra argument width of source bitmap, so that putboxpart can use this */
199 int vp;
200 int page;
201 char *bp = b;
202 int i;
203 ASSIGNVPOFFSET8(x, y, vp);
204 page = vp >> 16;
205 vp &= 0xffff;
206 vga_setpage(page);
207 for (i = 0; i < h; i++) {
208 if (vp + w > 0x10000) {
209 if (vp >= 0x10000) {
210 page++;
211 vga_setpage(page);
212 vp &= 0xffff;
213 } else { /* page break within line */
214 __memcpy(VBUF + vp, bp, 0x10000 - vp);
215 page++;
216 vga_setpage(page);
217 __memcpy(VBUF, bp + 0x10000 - vp,
218 (vp + w) & 0xffff);
219 vp = (vp + BYTEWIDTH) & 0xffff;
220 bp += bw;
221 continue;
222 }
223 };
224 __memcpy(VBUF + vp, bp, w);
225 bp += bw;
226 vp += BYTEWIDTH;
227 }
228 }
229
__svgalib_driver8_getbox(int x,int y,int w,int h,void * b,int bw)230 void __svgalib_driver8_getbox(int x, int y, int w, int h, void *b, int bw)
231 {
232 char *vp; /* screen pointer */
233 char *bp; /* bitmap pointer */
234 int i;
235 ASSIGNVP8(x, y, vp);
236 bp = b;
237 for (i = 0; i < h; i++) {
238 __memcpy(bp, vp, w);
239 bp += bw;
240 vp += BYTEWIDTH;
241 }
242 }
243
__svgalib_driver8p_getbox(int x,int y,int w,int h,void * b,int bw)244 void __svgalib_driver8p_getbox(int x, int y, int w, int h, void *b, int bw)
245 {
246 int vp;
247 int page;
248 char *bp = b;
249 int i;
250 ASSIGNVPOFFSET8(x, y, vp);
251 page = vp >> 16;
252 vp &= 0xffff;
253 vga_setpage(page);
254 for (i = 0; i < h; i++) {
255 if (vp + w > 0x10000) {
256 if (vp >= 0x10000) {
257 page++;
258 vga_setpage(page);
259 vp &= 0xffff;
260 } else { /* page break within line */
261 __memcpy(bp, VBUF + vp, 0x10000 - vp);
262 page++;
263 vga_setpage(page);
264 __memcpy(bp + 0x10000 - vp, VBUF,
265 (vp + w) & 0xffff);
266 vp = (vp + BYTEWIDTH) & 0xffff;
267 bp += bw;
268 continue;
269 }
270 };
271 __memcpy(bp, VBUF + vp, w);
272 bp += bw;
273 vp += BYTEWIDTH;
274 }
275 }
276
__svgalib_driver8_putboxmask(int x,int y,int w,int h,void * b)277 void __svgalib_driver8_putboxmask(int x, int y, int w, int h, void *b)
278 {
279 uchar *bp = b;
280 uchar *vp;
281 int i;
282 ASSIGNVP8(x, y, vp);
283 for (i = 0; i < h; i++) {
284 uchar *endoflinebp = bp + w;
285 while (bp < endoflinebp - 3) {
286 unsigned int c4 = *(unsigned int *) bp;
287 if (c4 & 0xff)
288 *vp = (uchar) c4;
289 c4 >>= 8;
290 if (c4 & 0xff)
291 *(vp + 1) = (uchar) c4;
292 c4 >>= 8;
293 if (c4 & 0xff)
294 *(vp + 2) = (uchar) c4;
295 c4 >>= 8;
296 if (c4 & 0xff)
297 *(vp + 3) = (uchar) c4;
298 bp += 4;
299 vp += 4;
300 }
301 while (bp < endoflinebp) {
302 uchar c = *bp;
303 if (c)
304 *vp = c;
305 bp++;
306 vp++;
307 }
308 vp += BYTEWIDTH - w;
309 }
310 }
311
__svgalib_driver8_putboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)312 void __svgalib_driver8_putboxpart(int x, int y, int w, int h, int ow, int oh,
313 void *b, int xo, int yo)
314 {
315 __svgalib_driver8_putbox(x, y, w, h, b + yo * ow + xo, ow); /* inlined */
316 }
317
__svgalib_driver8p_putboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)318 void __svgalib_driver8p_putboxpart(int x, int y, int w, int h, int ow, int oh,
319 void *b, int xo, int yo)
320 {
321 __svgalib_driver8p_putbox(x, y, w, h, b + yo * ow + xo, ow); /* inlined */
322 }
323
__svgalib_driver8_getboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)324 void __svgalib_driver8_getboxpart(int x, int y, int w, int h, int ow, int oh,
325 void *b, int xo, int yo)
326 {
327 __svgalib_driver8_getbox(x, y, w, h, b + yo * ow + xo, ow);
328 }
329
__svgalib_driver8p_getboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)330 void __svgalib_driver8p_getboxpart(int x, int y, int w, int h, int ow, int oh,
331 void *b, int xo, int yo)
332 {
333 __svgalib_driver8p_getbox(x, y, w, h, b + yo * ow + xo, ow);
334 }
335
__svgalib_driver8_copybox(int x1,int y1,int w,int h,int x2,int y2)336 void __svgalib_driver8_copybox(int x1, int y1, int w, int h, int x2, int y2)
337 {
338 char *svp, *dvp;
339 /* I hope this works now. */
340 if (y1 >= y2) {
341 if (y1 == y2 && x2 >= x1) { /* tricky */
342 int i;
343 if (x1 == x2)
344 return;
345 /* use a temporary buffer to store a line */
346 /* using reversed movs would be much faster */
347 ASSIGNVP8(x1, y1, svp);
348 ASSIGNVP8(x2, y2, dvp);
349 for (i = 0; i < h; i++) {
350 uchar linebuf[MAXBYTEWIDTH];
351 __memcpy(linebuf, svp, w);
352 __memcpy(dvp, linebuf, w);
353 svp += BYTEWIDTH;
354 dvp += BYTEWIDTH;
355 }
356 } else { /* copy from top to bottom */
357 int i;
358 ASSIGNVP8(x1, y1, svp);
359 ASSIGNVP8(x2, y2, dvp);
360 for (i = 0; i < h; i++) {
361 __memcpy(dvp, svp, w);
362 svp += BYTEWIDTH;
363 dvp += BYTEWIDTH;
364 }
365 }
366 } else { /* copy from bottom to top */
367 int i;
368 ASSIGNVP8(x1, y1 + h, svp);
369 ASSIGNVP8(x2, y2 + h, dvp);
370 for (i = 0; i < h; i++) {
371 svp -= BYTEWIDTH;
372 dvp -= BYTEWIDTH;
373 __memcpy(dvp, svp, w);
374 }
375 }
376 }
377
__svgalib_driver8a_copybox(int x1,int y1,int w,int h,int x2,int y2)378 void __svgalib_driver8a_copybox(int x1, int y1, int w, int h, int x2, int y2)
379 {
380 vga_accel(ACCEL_SCREENCOPY, x1, y1, x2, y2, w, h);
381 }
382
383
384
385 /* Two bytes per pixel graphics primitives */
386
387 #define ASSIGNVP16(x, y, vp) vp = VBUF + (y) * BYTEWIDTH + (x) * 2;
388 #define ASSIGNVPOFFSET16(x, y, vp) vp = (y) * BYTEWIDTH + (x) * 2;
389
__svgalib_driver16_setpixel(int x,int y,int c)390 void __svgalib_driver16_setpixel(int x, int y, int c)
391 {
392 char *vp;
393 ASSIGNVP16(x, y, vp);
394 *(unsigned short *) vp = c;
395 }
396
__svgalib_driver16p_setpixel(int x,int y,int c)397 void __svgalib_driver16p_setpixel(int x, int y, int c)
398 {
399 int vp;
400 ASSIGNVPOFFSET16(x, y, vp);
401 vga_setpage(vp >> 16);
402 *(unsigned short *) (VBUF + (vp & 0xffff)) = c;
403 }
404
__svgalib_driver16_getpixel(int x,int y)405 int __svgalib_driver16_getpixel(int x, int y)
406 {
407 char *vp;
408 ASSIGNVP16(x, y, vp);
409 return *(unsigned short *) vp;
410 }
411
__svgalib_driver16p_getpixel(int x,int y)412 int __svgalib_driver16p_getpixel(int x, int y)
413 {
414 int vp;
415 ASSIGNVPOFFSET16(x, y, vp);
416 vga_setpage(vp >> 16);
417 return *(unsigned short *) (VBUF + (vp & 0xffff));
418 }
419
__svgalib_driver16_hline(int x1,int y,int x2,int c)420 void __svgalib_driver16_hline(int x1, int y, int x2, int c)
421 {
422 char *vp;
423 ASSIGNVP16(x1, y, vp);
424 __memset2(vp, c, x2 - x1 + 1);
425 }
426
__svgalib_driver16p_hline(int x1,int y,int x2,int c)427 void __svgalib_driver16p_hline(int x1, int y, int x2, int c)
428 {
429 int vp;
430 char *rvp;
431 int l;
432 int chunksize, page;
433 ASSIGNVPOFFSET16(x1, y, vp);
434 SETWRITEPAGED(vp, rvp, chunksize, page);
435 l = (x2 - x1 + 1) * 2;
436 if (l <= chunksize)
437 __memset2(rvp, c, l / 2);
438 else {
439 __memset2(rvp, c, chunksize / 2);
440 vga_setpage(page + 1);
441 __memset2(VBUF, c, (l - chunksize) / 2);
442 }
443 }
444
__svgalib_driver16_fillbox(int x,int y,int w,int h,int c)445 void __svgalib_driver16_fillbox(int x, int y, int w, int h, int c)
446 {
447 char *vp;
448 int i;
449 ASSIGNVP16(x, y, vp);
450 for (i = 0; i < h; i++) {
451 __memset2(vp, c, w);
452 vp += BYTEWIDTH;
453 }
454 }
455
__svgalib_driver16p_fillbox(int x,int y,int w,int h,int c)456 void __svgalib_driver16p_fillbox(int x, int y, int w, int h, int c)
457 {
458 int vp;
459 int page;
460 int i;
461 ASSIGNVPOFFSET16(x, y, vp);
462 page = vp >> 16;
463 vp &= 0xffff;
464 vga_setpage(page);
465 for (i = 0; i < h; i++) {
466 if (vp + w * 2 > 0x10000) {
467 if (vp >= 0x10000) {
468 page++;
469 vga_setpage(page);
470 vp &= 0xffff;
471 } else { /* page break within line */
472 __memset2(VBUF + vp, c, (0x10000 - vp) / 2);
473 page++;
474 vga_setpage(page);
475 __memset2(VBUF, c, ((vp + w * 2) & 0xffff) / 2);
476 vp = (vp + BYTEWIDTH) & 0xffff;
477 continue;
478 }
479 };
480 __memset2(VBUF + vp, c, w);
481 vp += BYTEWIDTH;
482 }
483 }
484
__svgalib_driver16_putbox(int x,int y,int w,int h,void * b,int bw)485 void __svgalib_driver16_putbox(int x, int y, int w, int h, void *b, int bw)
486 {
487 char *vp; /* screen pointer */
488 char *bp; /* bitmap pointer */
489 int i;
490 ASSIGNVP16(x, y, vp);
491 bp = b;
492 for (i = 0; i < h; i++) {
493 __memcpy(vp, bp, w * 2);
494 bp += bw * 2;
495 vp += BYTEWIDTH;
496 }
497 }
498
__svgalib_driver16p_putbox(int x,int y,int w,int h,void * b,int bw)499 void __svgalib_driver16p_putbox(int x, int y, int w, int h, void *b, int bw)
500 {
501 __svgalib_driver8p_putbox(x * 2, y, w * 2, h, b, bw * 2);
502 }
503
__svgalib_driver16_getbox(int x,int y,int w,int h,void * b,int bw)504 void __svgalib_driver16_getbox(int x, int y, int w, int h, void *b, int bw)
505 {
506 char *vp; /* screen pointer */
507 char *bp; /* bitmap pointer */
508 int i;
509 ASSIGNVP16(x, y, vp);
510 bp = b;
511 for (i = 0; i < h; i++) {
512 __memcpy(bp, vp, w * 2);
513 bp += bw * 2;
514 vp += BYTEWIDTH;
515 }
516 }
517
__svgalib_driver16p_getbox(int x,int y,int w,int h,void * b,int bw)518 INLINE void __svgalib_driver16p_getbox(int x, int y, int w, int h, void *b, int bw)
519 {
520 __svgalib_driver8p_getbox(x * 2, y, w * 2, h, b, bw * 2);
521 }
522
__svgalib_driver16_putboxmask(int x,int y,int w,int h,void * b)523 void __svgalib_driver16_putboxmask(int x, int y, int w, int h, void *b)
524 {
525 uchar *bp = b;
526 uchar *vp;
527 int i;
528 ASSIGNVP16(x, y, vp);
529 for (i = 0; i < h; i++) {
530 uchar *endoflinebp = bp + w * 2;
531 while (bp < endoflinebp - 7) {
532 unsigned c2 = *(unsigned *) bp;
533 if (c2 & 0xffff)
534 *(ushort *) vp = (ushort) c2;
535 c2 >>= 16;
536 if (c2 & 0xffff)
537 *(ushort *) (vp + 2) = (ushort) c2;
538 c2 = *(unsigned *) (bp + 4);
539 if (c2 & 0xffff)
540 *(ushort *) (vp + 4) = (ushort) c2;
541 c2 >>= 16;
542 if (c2 & 0xffff)
543 *(ushort *) (vp + 6) = (ushort) c2;
544 bp += 8;
545 vp += 8;
546 }
547 while (bp < endoflinebp) {
548 ushort c = *(ushort *) bp;
549 if (c)
550 *(ushort *) vp = c;
551 bp += 2;
552 vp += 2;
553 }
554 vp += BYTEWIDTH - w * 2;
555 }
556 }
557
__svgalib_driver16_putboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)558 INLINE void __svgalib_driver16_putboxpart(int x, int y, int w, int h, int ow, int oh,
559 void *b, int xo, int yo)
560 {
561 __svgalib_driver8_putbox(x * 2, y, w * 2, h, b + yo * ow * 2 + xo * 2, ow * 2);
562 /* inlined */
563 }
564
__svgalib_driver16p_putboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)565 INLINE void __svgalib_driver16p_putboxpart(int x, int y, int w, int h, int ow, int oh,
566 void *b, int xo, int yo)
567 {
568 __svgalib_driver8p_putbox(x * 2, y, w * 2, h, b + yo * ow * 2 + xo * 2, ow * 2);
569 }
570
__svgalib_driver16_getboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)571 INLINE void __svgalib_driver16_getboxpart(int x, int y, int w, int h, int ow, int oh,
572 void *b, int xo, int yo)
573 {
574 __svgalib_driver16_getbox(x, y, w, h, b + yo * ow + xo, ow);
575 }
576
__svgalib_driver16p_getboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)577 INLINE void __svgalib_driver16p_getboxpart(int x, int y, int w, int h, int ow, int oh,
578 void *b, int xo, int yo)
579 {
580 __svgalib_driver16p_getbox(x, y, w, h, b + yo * ow + xo, ow);
581 }
582
__svgalib_driver16_copybox(int x1,int y1,int w,int h,int x2,int y2)583 INLINE void __svgalib_driver16_copybox(int x1, int y1, int w, int h, int x2, int y2)
584 {
585 __svgalib_driver8_copybox(x1 * 2, y1, w * 2, h, x2 * 2, y2);
586 }
587
__svgalib_driver16a_copybox(int x1,int y1,int w,int h,int x2,int y2)588 void __svgalib_driver16a_copybox(int x1, int y1, int w, int h, int x2, int y2)
589 {
590 int svp, dvp;
591 ASSIGNVPOFFSET16(x1, y1, svp);
592 ASSIGNVPOFFSET16(x2, y2, dvp);
593 vga_bitblt(svp, dvp, w * 2, h, BYTEWIDTH);
594 }
595
596
597
598 /* Three bytes per pixel graphics primitives */
599
600 #define ASSIGNVP24(x, y, vp) vp = VBUF + (y) * BYTEWIDTH + (x) * 3;
601 #define ASSIGNVPOFFSET24(x, y, vp) vp = (y) * BYTEWIDTH + (x) * 3;
602 #define RGBEQUAL(c) ((c & 0xff) == ((c >> 8) & 0xff) && \
603 (c & 0xff) == ((c >> 16) & 0xff))
604
__svgalib_driver24_setpixel(int x,int y,int c)605 void __svgalib_driver24_setpixel(int x, int y, int c)
606 {
607 char *vp;
608 c = RGB2BGR(c);
609 ASSIGNVP24(x, y, vp);
610 *(unsigned short *) vp = c;
611 *(unsigned char *) (vp + 2) = c >> 16;
612 }
613
__svgalib_driver24p_setpixel(int x,int y,int c)614 void __svgalib_driver24p_setpixel(int x, int y, int c)
615 {
616 int vp, vpo;
617 char *vbuf;
618 int page;
619 c = RGB2BGR(c);
620 ASSIGNVPOFFSET24(x, y, vp);
621 vbuf = VBUF;
622 page = vp >> 16;
623 vga_setpage(page);
624 vpo = vp & 0xffff;
625 if (vpo <= 0xfffd) {
626 *(unsigned short *) (vbuf + vpo) = c;
627 *(unsigned char *) (vbuf + vpo + 2) = c >> 16;
628 } else if (vpo == 0xfffe) {
629 *(unsigned short *) (vbuf + 0xfffe) = c;
630 vga_setpage(page + 1);
631 *(unsigned char *) vbuf = c >> 16;
632 } else { /* vpo == 0xffff */
633 *(unsigned char *) (vbuf + 0xffff) = c;
634 vga_setpage(page + 1);
635 *(unsigned short *) vbuf = c >> 8;
636 }
637 }
638
__svgalib_driver24_getpixel(int x,int y)639 int __svgalib_driver24_getpixel(int x, int y)
640 {
641 char *vp;
642 ASSIGNVP24(x, y, vp);
643 return RGB2BGR(*(unsigned short *) vp + (*(unsigned char *) (vp + 2) << 16));
644 }
645
__svgalib_driver24p_getpixel(int x,int y)646 int __svgalib_driver24p_getpixel(int x, int y)
647 {
648 int vp, vpo;
649 char *vbuf;
650 int page;
651 ASSIGNVPOFFSET24(x, y, vp);
652 vbuf = VBUF;
653 page = vp >> 16;
654 vga_setpage(page);
655 vpo = vp & 0xffff;
656 if (vpo <= 0xfffd)
657 return RGB2BGR(*(unsigned short *) (vbuf + vpo) +
658 (*(unsigned char *) (vbuf + vpo + 2) << 16));
659 else if (vpo == 0xfffe) {
660 int c;
661 c = *(unsigned short *) (vbuf + 0xfffe);
662 vga_setpage(page + 1);
663 return RGB2BGR((*(unsigned char *) vbuf << 16) + c);
664 } else { /* vpo == 0xffff */
665 int c;
666 c = *(unsigned char *) (vbuf + 0xffff);
667 vga_setpage(page + 1);
668 return RGB2BGR((*(unsigned short *) vbuf << 8) + c);
669 }
670 }
671
__svgalib_driver24_hline(int x1,int y,int x2,int c)672 void __svgalib_driver24_hline(int x1, int y, int x2, int c)
673 {
674 char *vp;
675 c = RGB2BGR(c);
676 ASSIGNVP24(x1, y, vp);
677 if (RGBEQUAL(c))
678 __memset(vp, c, (x2 - x1 + 1) * 3);
679 else
680 __memset3(vp, c, x2 - x1 + 1);
681 }
682
__svgalib_driver24p_hline(int x1,int y,int x2,int c)683 void __svgalib_driver24p_hline(int x1, int y, int x2, int c)
684 {
685 int vp;
686 char *rvp;
687 int l;
688 int chunksize, page;
689 c = RGB2BGR(c);
690 ASSIGNVPOFFSET24(x1, y, vp);
691 SETWRITEPAGED(vp, rvp, chunksize, page);
692 l = (x2 - x1 + 1) * 3;
693 if (l <= chunksize)
694 __memset3(rvp, c, l / 3);
695 else {
696 int n, m, o;
697 n = chunksize / 3;
698 m = chunksize % 3;
699 __memset3(rvp, c, n);
700 /* Handle page break within pixel. */
701 if (m >= 1)
702 *(rvp + n * 3) = c;
703 if (m == 2)
704 *(rvp + n * 3 + 1) = c >> 8;
705 vga_setpage(page + 1);
706 o = 0;
707 if (m == 2) {
708 *(VBUF) = c >> 16;
709 o = 1;
710 }
711 if (m == 1) {
712 *(unsigned short *) (VBUF) = c >> 8;
713 o = 2;
714 }
715 __memset3(VBUF + o, c, (l - chunksize) / 3);
716 }
717 }
718
__svgalib_driver24_fillbox(int x,int y,int w,int h,int c)719 void __svgalib_driver24_fillbox(int x, int y, int w, int h, int c)
720 {
721 char *vp;
722 int i, j;
723 c = RGB2BGR(c);
724 ASSIGNVP24(x, y, vp);
725 if (RGBEQUAL(c))
726 for (i = 0; i < h; i++) {
727 __memset(vp, c, w * 3);
728 vp += BYTEWIDTH;
729 } else
730 for (j = 0; j < h; j++) {
731 __memset3(vp, c, w);
732 vp += BYTEWIDTH;
733 }
734 }
735
__svgalib_driver24p_fillbox(int x,int y,int w,int h,int c)736 void __svgalib_driver24p_fillbox(int x, int y, int w, int h, int c)
737 {
738 int vp;
739 int page;
740 int i;
741 c = RGB2BGR(c);
742 ASSIGNVPOFFSET24(x, y, vp);
743 page = vp >> 16;
744 vp &= 0xffff;
745 vga_setpage(page);
746 if (RGBEQUAL(c)) {
747 for (i = 0; i < h; i++) {
748 if (vp + w * 3 > 0x10000) {
749 if (vp >= 0x10000) {
750 page++;
751 vga_setpage(page);
752 vp &= 0xffff;
753 } else { /* Page break within line. */
754 __memset(VBUF + vp, c, 0x10000 - vp);
755 page++;
756 vga_setpage(page);
757 __memset(VBUF, c, (vp + w * 3) & 0xffff);
758 vp = (vp + BYTEWIDTH) & 0xffff;
759 continue;
760 }
761 };
762 __memset(VBUF + vp, c, w * 3);
763 vp += BYTEWIDTH;
764 }
765 } else
766 for (i = 0; i < h; i++) {
767 if (vp + w * 3 > 0x10000) {
768 if (vp >= 0x10000) {
769 page++;
770 vga_setpage(page);
771 vp &= 0xffff;
772 } else { /* Page break within line. */
773 int n, m, o;
774 n = (0x10000 - vp) / 3;
775 m = (0x10000 - vp) % 3;
776 __memset3(VBUF + vp, c, n);
777 /* Handle page break within pixel. */
778 if (m >= 1)
779 *(VBUF + vp + n * 3) = c;
780 if (m == 2)
781 *(VBUF + vp + n * 3 + 1) = c >> 8;
782 page++;
783 vga_setpage(page);
784 o = 0;
785 if (m == 2) {
786 *(VBUF) = c >> 16;
787 o = 1;
788 }
789 if (m == 1) {
790 *(unsigned short *) (VBUF) = c >> 8;
791 o = 2;
792 }
793 __memset3(VBUF + o, c, ((vp + w * 3) & 0xffff) / 3);
794 vp = (vp + BYTEWIDTH) & 0xffff;
795 continue;
796 }
797 };
798 __memset3(VBUF + vp, c, w);
799 vp += BYTEWIDTH;
800 }
801 }
802
__svgalib_driver24_putbox(int x,int y,int w,int h,void * b,int bw)803 void __svgalib_driver24_putbox(int x, int y, int w, int h, void *b, int bw)
804 {
805 char *vp; /* screen pointer */
806 char *bp; /* bitmap pointer */
807 int i;
808 ASSIGNVP24(x, y, vp);
809 bp = b;
810 if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
811 for (i = 0; i < h; i++) {
812 RGB_swapped_memcpy(vp, bp, w * 3);
813 bp += bw * 3;
814 vp += BYTEWIDTH;
815 }
816 } else {
817 for (i = 0; i < h; i++) {
818 __memcpy(vp, bp, w * 3);
819 bp += bw * 3;
820 vp += BYTEWIDTH;
821 }
822 }
823 }
824
driver24_rev_putbox(int x,int y,int w,int h,void * b,int bw)825 static void driver24_rev_putbox(int x, int y, int w, int h, void *b, int bw)
826 {
827 /* extra argument width of source bitmap, so that putboxpart can use this */
828 int vp;
829 int page;
830 char *bp = b, *bp2;
831 int i, left;
832
833 ASSIGNVPOFFSET8(x, y, vp);
834 page = vp >> 16;
835 vp &= 0xffff;
836 vga_setpage(page);
837 for (i = 0; i < h; i++) {
838 if (vp + w > 0x10000) {
839 if (vp >= 0x10000) {
840 page++;
841 vga_setpage(page);
842 vp &= 0xffff;
843 } else { /* page break within line */
844 left = RGB_swapped_memcpy(VBUF + vp, bp, 0x10000 - vp);
845 bp2 = bp + (0x10000 - vp - left);
846 switch (left) {
847 case 2:
848 *(VBUF + 0xFFFE) = bp2[2];
849 *(VBUF + 0xFFFF) = bp2[1];
850 break;
851 case 1:
852 *(VBUF + 0xFFFF) = bp2[2];
853 break;
854 }
855
856 page++;
857 vga_setpage(page);
858
859 switch (left) {
860 case 1:
861 *(VBUF) = bp2[1];
862 *(VBUF + 1) = bp2[0];
863 left = 3 - left;
864 bp2 += 3;
865 break;
866 case 2:
867 *(VBUF) = bp2[0];
868 left = 3 - left;
869 bp2 += 3;
870 break;
871 }
872
873 RGB_swapped_memcpy(VBUF + left, bp2, ((vp + w) & 0xffff) - left);
874 vp = (vp + BYTEWIDTH) & 0xffff;
875 bp += bw;
876 continue;
877 }
878 };
879 RGB_swapped_memcpy(VBUF + vp, bp, w);
880 bp += bw;
881 vp += BYTEWIDTH;
882 }
883 }
884
__svgalib_driver24p_putbox(int x,int y,int w,int h,void * b,int bw)885 INLINE void __svgalib_driver24p_putbox(int x, int y, int w, int h, void *b, int bw)
886 {
887 if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
888 driver24_rev_putbox(x * 3, y, w * 3, h, b, bw * 3);
889 } else {
890 __svgalib_driver8p_putbox(x * 3, y, w * 3, h, b, bw * 3);
891 }
892 }
893
__svgalib_driver24_putbox32(int x,int y,int w,int h,void * b,int bw)894 void __svgalib_driver24_putbox32(int x, int y, int w, int h, void *b, int bw)
895 {
896 char *vp; /* screen pointer */
897 char *bp; /* bitmap pointer */
898 int i;
899 ASSIGNVP24(x, y, vp);
900 bp = b;
901 for (i = 0; i < h; i++) {
902 __svgalib_memcpy4to3(vp, bp, w);
903 bp += bw * 4;
904 vp += BYTEWIDTH;
905 }
906 }
907
__svgalib_driver24_getbox(int x,int y,int w,int h,void * b,int bw)908 void __svgalib_driver24_getbox(int x, int y, int w, int h, void *b, int bw)
909 {
910 char *vp; /* screen pointer */
911 char *bp; /* bitmap pointer */
912 int i;
913 ASSIGNVP24(x, y, vp);
914 bp = b;
915 if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
916 for (i = 0; i < h; i++) {
917 RGB_swapped_memcpy(bp, vp, w * 3);
918 bp += bw * 3;
919 vp += BYTEWIDTH;
920 }
921 } else {
922 for (i = 0; i < h; i++) {
923 __memcpy(bp, vp, w * 3);
924 bp += bw * 3;
925 vp += BYTEWIDTH;
926 }
927 }
928 }
929
driver24_rev_getbox(int x,int y,int w,int h,void * b,int bw)930 static void driver24_rev_getbox(int x, int y, int w, int h, void *b, int bw)
931 {
932 /* extra argument width of source bitmap, so that putboxpart can use this */
933 int vp;
934 int page;
935 char *bp = b, *bp2;
936 int i, left;
937
938 ASSIGNVPOFFSET8(x, y, vp);
939 page = vp >> 16;
940 vp &= 0xffff;
941 vga_setpage(page);
942 for (i = 0; i < h; i++) {
943 if (vp + w > 0x10000) {
944 if (vp >= 0x10000) {
945 page++;
946 vga_setpage(page);
947 vp &= 0xffff;
948 } else { /* page break within line */
949 left = RGB_swapped_memcpy(bp, VBUF + vp, 0x10000 - vp);
950 bp2 = bp + (0x10000 - vp - left);
951 switch (left) {
952 case 2:
953 bp2[2] = *(VBUF + 0xFFFE);
954 bp2[1] = *(VBUF + 0xFFFF);
955 break;
956 case 1:
957 bp2[2] = *(VBUF + 0xFFFF);
958 break;
959 }
960
961 page++;
962 vga_setpage(page);
963
964 switch (left) {
965 case 1:
966 bp2[1] = *(VBUF);
967 bp2[0] = *(VBUF + 1);
968 left = 3 - left;
969 bp2 += 3;
970 break;
971 case 2:
972 bp2[0] = *(VBUF);
973 left = 3 - left;
974 bp2 += 3;
975 break;
976 }
977
978 RGB_swapped_memcpy(bp2, VBUF + left, ((vp + w) & 0xffff) - left);
979 vp = (vp + BYTEWIDTH) & 0xffff;
980 bp += bw;
981 continue;
982 }
983 };
984 RGB_swapped_memcpy(bp, VBUF + vp, w);
985 bp += bw;
986 vp += BYTEWIDTH;
987 }
988 }
989
__svgalib_driver24p_getbox(int x,int y,int w,int h,void * b,int bw)990 INLINE void __svgalib_driver24p_getbox(int x, int y, int w, int h, void *b, int bw)
991 {
992 if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
993 driver24_rev_getbox(x * 3, y, w * 3, h, b, bw * 3);
994 } else {
995 __svgalib_driver8p_getbox(x * 3, y, w * 3, h, b, bw * 3);
996 }
997 }
998
__svgalib_driver24_putboxmask(int x,int y,int w,int h,void * b)999 void __svgalib_driver24_putboxmask(int x, int y, int w, int h, void *b)
1000 {
1001 uchar *bp = b;
1002 uchar *vp;
1003 int i;
1004 ASSIGNVP24(x, y, vp);
1005 for (i = 0; i < h; i++) {
1006 uchar *endoflinebp = bp + w * 3;
1007 while (bp < endoflinebp - 11) {
1008 unsigned c = RGB2BGR(*(unsigned *) bp);
1009 if (c & 0xffffff) {
1010 *(ushort *) vp = (ushort) c;
1011 *(vp + 2) = c >> 16;
1012 }
1013 c = RGB2BGR(*(unsigned *) (bp + 3));
1014 if (c & 0xffffff) {
1015 *(ushort *) (vp + 3) = (ushort) c;
1016 *(vp + 5) = c >> 16;
1017 }
1018 c = RGB2BGR(*(unsigned *) (bp + 6));
1019 if (c & 0xffffff) {
1020 *(ushort *) (vp + 6) = (ushort) c;
1021 *(vp + 8) = c >> 16;
1022 }
1023 c = RGB2BGR(*(unsigned *) (bp + 9));
1024 if (c & 0xffffff) {
1025 *(ushort *) (vp + 9) = (ushort) c;
1026 *(vp + 11) = c >> 16;
1027 }
1028 bp += 12;
1029 vp += 12;
1030 }
1031 while (bp < endoflinebp) {
1032 uint c = RGB2BGR(*(uint *) bp);
1033 if (c & 0xffffff) {
1034 *(ushort *) vp = (ushort) c;
1035 *(vp + 2) = c >> 16;
1036 }
1037 bp += 3;
1038 vp += 3;
1039 }
1040 vp += BYTEWIDTH - w * 3;
1041 }
1042 }
1043
__svgalib_driver24_putboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)1044 INLINE void __svgalib_driver24_putboxpart(int x, int y, int w, int h, int ow, int oh,
1045 void *b, int xo, int yo)
1046 {
1047 /*
1048 * Actually I think all this could be done by just calling __svgalib_driver24_putbox
1049 * with correct args. But I'm too fearful. - Michael.
1050 */
1051 if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
1052 __svgalib_driver24_putbox(x, y, w, h, b + yo * ow + xo, ow);
1053 } else {
1054 __svgalib_driver8_putbox(x * 3, y, w * 3, h, b + yo * ow * 3 + xo * 3, ow * 3);
1055 }
1056 }
1057
__svgalib_driver24p_putboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)1058 INLINE void __svgalib_driver24p_putboxpart(int x, int y, int w, int h, int ow, int oh,
1059 void *b, int xo, int yo)
1060 {
1061 if (MODEFLAGS & MODEFLAG_24BPP_REVERSED) {
1062 driver24_rev_putbox(x * 3, y, w * 3, h, b + yo * ow * 3 + xo * 3, ow * 3);
1063 } else {
1064 __svgalib_driver8p_putbox(x * 3, y, w * 3, h, b + yo * ow * 3 + xo * 3, ow * 3);
1065 }
1066 }
1067
__svgalib_driver24_getboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)1068 INLINE void __svgalib_driver24_getboxpart(int x, int y, int w, int h, int ow, int oh,
1069 void *b, int xo, int yo)
1070 {
1071 __svgalib_driver24_getbox(x, y, w, h, b + yo * ow + xo, ow);
1072 }
1073
__svgalib_driver24p_getboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)1074 INLINE void __svgalib_driver24p_getboxpart(int x, int y, int w, int h, int ow, int oh,
1075 void *b, int xo, int yo)
1076 {
1077 __svgalib_driver24p_getbox(x, y, w, h, b + yo * ow + xo, ow);
1078 }
1079
__svgalib_driver24_copybox(int x1,int y1,int w,int h,int x2,int y2)1080 void __svgalib_driver24_copybox(int x1, int y1, int w, int h, int x2, int y2)
1081 {
1082 __svgalib_driver8_copybox(x1 * 3, y1, w * 3, h, x2 * 3, y2);
1083 }
1084
__svgalib_driver24a_copybox(int x1,int y1,int w,int h,int x2,int y2)1085 void __svgalib_driver24a_copybox(int x1, int y1, int w, int h, int x2, int y2)
1086 {
1087 int svp, dvp;
1088 ASSIGNVPOFFSET24(x1, y1, svp);
1089 ASSIGNVPOFFSET24(x2, y2, dvp);
1090 vga_bitblt(svp, dvp, w * 3, h, BYTEWIDTH);
1091 }
1092
1093
1094
1095 /* Four bytes per pixel graphics primitives */
1096
1097 #define ASSIGNVP32(x, y, vp) vp = VBUF + (y) * BYTEWIDTH + (x) * 4;
1098 #define ASSIGNVPOFFSET32(x, y, vp) vp = (y) * BYTEWIDTH + (x) * 4;
1099
__svgalib_driver32_setpixel(int x,int y,int c)1100 void __svgalib_driver32_setpixel(int x, int y, int c)
1101 {
1102 char *vp;
1103 ASSIGNVP32(x, y, vp);
1104 *(unsigned *) vp = c;
1105 }
1106
__svgalib_driver32p_setpixel(int x,int y,int c)1107 void __svgalib_driver32p_setpixel(int x, int y, int c)
1108 {
1109 int vp;
1110 ASSIGNVPOFFSET32(x, y, vp);
1111 vga_setpage(vp >> 16);
1112 *(unsigned *) (VBUF + (vp & 0xffff)) = c;
1113 }
1114
__svgalib_driver32_getpixel(int x,int y)1115 int __svgalib_driver32_getpixel(int x, int y)
1116 {
1117 char *vp;
1118 ASSIGNVP32(x, y, vp);
1119 return *(unsigned *) vp;
1120 }
1121
__svgalib_driver32p_getpixel(int x,int y)1122 int __svgalib_driver32p_getpixel(int x, int y)
1123 {
1124 int vp;
1125 ASSIGNVPOFFSET32(x, y, vp);
1126 vga_setpage(vp >> 16);
1127 return *(unsigned *) (VBUF + (vp & 0xffff));
1128 }
1129
__svgalib_driver32_hline(int x1,int y,int x2,int c)1130 void __svgalib_driver32_hline(int x1, int y, int x2, int c)
1131 {
1132 char *vp;
1133 ASSIGNVP32(x1, y, vp);
1134 __memsetlong(vp, c, x2 - x1 + 1);
1135 }
1136
__svgalib_driver32p_hline(int x1,int y,int x2,int c)1137 void __svgalib_driver32p_hline(int x1, int y, int x2, int c)
1138 {
1139 int vp;
1140 char *rvp;
1141 int l;
1142 int chunksize, page;
1143 ASSIGNVPOFFSET32(x1, y, vp);
1144 SETWRITEPAGED(vp, rvp, chunksize, page);
1145 l = (x2 - x1 + 1) * 4;
1146 if (l <= chunksize)
1147 __memsetlong(rvp, c, l / 4);
1148 else {
1149 __memsetlong(rvp, c, chunksize / 4);
1150 vga_setpage(page + 1);
1151 __memsetlong(VBUF, c, (l - chunksize) / 4);
1152 }
1153 }
1154
__svgalib_driver32_fillbox(int x,int y,int w,int h,int c)1155 void __svgalib_driver32_fillbox(int x, int y, int w, int h, int c)
1156 {
1157 char *vp;
1158 int i;
1159 ASSIGNVP32(x, y, vp);
1160 for (i = 0; i < h; i++) {
1161 __memsetlong(vp, c, w);
1162 vp += BYTEWIDTH;
1163 }
1164 }
1165
__svgalib_driver32p_fillbox(int x,int y,int w,int h,int c)1166 void __svgalib_driver32p_fillbox(int x, int y, int w, int h, int c)
1167 {
1168 int vp;
1169 int page;
1170 int i;
1171 ASSIGNVPOFFSET32(x, y, vp);
1172 page = vp >> 16;
1173 vp &= 0xffff;
1174 vga_setpage(page);
1175 for (i = 0; i < h; i++) {
1176 if (vp + w * 4 > 0x10000) {
1177 if (vp >= 0x10000) {
1178 page++;
1179 vga_setpage(page);
1180 vp &= 0xffff;
1181 } else { /* page break within line */
1182 __memsetlong(VBUF + vp, c, (0x10000 - vp) / 4);
1183 page++;
1184 vga_setpage(page);
1185 __memsetlong(VBUF, c, ((vp + w * 4) & 0xffff) / 4);
1186 vp = (vp + BYTEWIDTH) & 0xffff;
1187 continue;
1188 }
1189 };
1190 __memsetlong(VBUF + vp, c, w);
1191 vp += BYTEWIDTH;
1192 }
1193 }
1194
__svgalib_driver32_putbox(int x,int y,int w,int h,void * b,int bw)1195 INLINE void __svgalib_driver32_putbox(int x, int y, int w, int h, void *b, int bw)
1196 {
1197 __svgalib_driver8_putbox(x * 4, y, w * 4, h, b, bw * 4);
1198 }
1199
__svgalib_driver32p_putbox(int x,int y,int w,int h,void * b,int bw)1200 INLINE void __svgalib_driver32p_putbox(int x, int y, int w, int h, void *b, int bw)
1201 {
1202 __svgalib_driver8p_putbox(x * 4, y, w * 4, h, b, bw * 4);
1203 }
1204
__svgalib_driver32_getbox(int x,int y,int w,int h,void * b,int bw)1205 INLINE void __svgalib_driver32_getbox(int x, int y, int w, int h, void *b, int bw)
1206 {
1207 __svgalib_driver8_getbox(x * 4, y, w * 4, h, b, bw * 4);
1208 }
1209
__svgalib_driver32p_getbox(int x,int y,int w,int h,void * b,int bw)1210 INLINE void __svgalib_driver32p_getbox(int x, int y, int w, int h, void *b, int bw)
1211 {
1212 __svgalib_driver8p_getbox(x * 4, y, w * 4, h, b, bw * 4);
1213 }
1214
__svgalib_driver32_putboxmask(int x,int y,int w,int h,void * b)1215 void __svgalib_driver32_putboxmask(int x, int y, int w, int h, void *b)
1216 {
1217 uchar *bp = b;
1218 uchar *vp;
1219 int i;
1220 ASSIGNVP32(x, y, vp);
1221 for (i = 0; i < h; i++) {
1222 uchar *endoflinebp = bp + w * 4;
1223 while (bp < endoflinebp - 15) {
1224 unsigned c = *(unsigned *) bp;
1225 if (c)
1226 *(unsigned *) vp = c;
1227 c = *(unsigned *) (bp + 4);
1228 if (c)
1229 *(unsigned *) (vp + 4) = c;
1230 c = *(unsigned *) (bp + 8);
1231 if (c)
1232 *(unsigned *) (vp + 8) = c;
1233 c = *(unsigned *) (bp + 12);
1234 if (c)
1235 *(unsigned *) (vp + 12) = c;
1236 bp += 16;
1237 vp += 16;
1238 }
1239 while (bp < endoflinebp) {
1240 unsigned c = *(unsigned *) bp;
1241 if (c)
1242 *(unsigned *) vp = c;
1243 bp += 4;
1244 vp += 4;
1245 }
1246 vp += BYTEWIDTH - w * 4;
1247 }
1248 }
1249
__svgalib_driver32_putboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)1250 INLINE void __svgalib_driver32_putboxpart(int x, int y, int w, int h, int ow, int oh,
1251 void *b, int xo, int yo)
1252 {
1253 __svgalib_driver32_putbox(x, y, w, h, b + yo * ow * 4 + xo * 4 , ow );
1254 /* inlined */
1255 }
1256
__svgalib_driver32p_putboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)1257 INLINE void __svgalib_driver32p_putboxpart(int x, int y, int w, int h, int ow, int oh,
1258 void *b, int xo, int yo)
1259 {
1260 __svgalib_driver32p_putbox(x, y, w, h, b + yo * ow * 4 + xo * 4, ow );
1261 /* inlined */
1262 }
1263
__svgalib_driver32_getboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)1264 INLINE void __svgalib_driver32_getboxpart(int x, int y, int w, int h, int ow, int oh,
1265 void *b, int xo, int yo)
1266 {
1267 __svgalib_driver32_getbox(x, y, w, h, b + yo * ow * 4 + xo * 4 , ow );
1268 }
1269
__svgalib_driver32p_getboxpart(int x,int y,int w,int h,int ow,int oh,void * b,int xo,int yo)1270 INLINE void __svgalib_driver32p_getboxpart(int x, int y, int w, int h, int ow, int oh,
1271 void *b, int xo, int yo)
1272 {
1273 __svgalib_driver32p_getbox(x, y, w, h, b + yo * ow * 4 + xo * 4 , ow );
1274 }
1275
__svgalib_driver32_copybox(int x1,int y1,int w,int h,int x2,int y2)1276 INLINE void __svgalib_driver32_copybox(int x1, int y1, int w, int h, int x2, int y2)
1277 {
1278 __svgalib_driver8_copybox(x1 * 4, y1, w * 4, h, x2 * 4, y2);
1279 }
1280
1281
1282
1283 /* Planar 256 color mode graphics primitives (only putbox) */
1284
__svgalib_driverplanar256_nothing(void)1285 void __svgalib_driverplanar256_nothing(void)
1286 {
1287 NOTIMPL("planar 256 color mode primitive");
1288 }
1289
__svgalib_driverplanar256_putbox(int x,int y,int w,int h,void * b,int bw)1290 void __svgalib_driverplanar256_putbox(int x, int y, int w, int h, void *b, int bw)
1291 {
1292 if ((w & 3) != 0 || (x & 3) != 0)
1293 NOTIMPL("planar 256 color mode unaligned putbox");
1294 vga_copytoplanar256(b, bw, y * BYTEWIDTH + x / 4, BYTEWIDTH,
1295 w, h);
1296 }
1297
__svgalib_driverplanar16_nothing(void)1298 void __svgalib_driverplanar16_nothing(void)
1299 {
1300 NOTIMPL("planar 16 color mode primitive");
1301 }
1302
1303
1304 /* Memory primitives */
1305
__svgalib_driver_setread(GraphicsContext * gc,int i,void ** vp)1306 int __svgalib_driver_setread(GraphicsContext * gc, int i, void **vp)
1307 {
1308 if (gc->modetype == CONTEXT_PAGED) {
1309 vga_setpage(i >> 16);
1310 *vp = (i & 0xffff) + gc->vbuf;
1311 return 0x10000 - (i & 0xffff);
1312 } else {
1313 *vp = gc->vbuf + i;
1314 return 0x10000;
1315 }
1316 }
1317
__svgalib_driver_setwrite(GraphicsContext * gc,int i,void ** vp)1318 int __svgalib_driver_setwrite(GraphicsContext * gc, int i, void **vp)
1319 {
1320 if (gc->modetype == CONTEXT_PAGED) {
1321 vga_setpage(i >> 16);
1322 *vp = (i & 0xffff) + gc->vbuf;
1323 return 0x10000 - (i & 0xffff);
1324 } else {
1325 *vp = gc->vbuf + i;
1326 return 0x10000;
1327 }
1328 }
1329
1330
1331
1332 /* Functions that are not yet implemented */
1333
__svgalib_driver8p_putboxmask(int x,int y,int w,int h,void * b)1334 void __svgalib_driver8p_putboxmask(int x, int y, int w, int h, void *b)
1335 {
1336 NOTIMPL("8-bit paged putboxmask");
1337 }
1338
__svgalib_driver8p_copybox(int x1,int y1,int w,int h,int x2,int y2)1339 void __svgalib_driver8p_copybox(int x1, int y1, int w, int h, int x2, int y2)
1340 {
1341 NOTIMPL("8-bit paged copybox (bitblt)");
1342 }
1343
__svgalib_driver16p_putboxmask(int x,int y,int w,int h,void * b)1344 void __svgalib_driver16p_putboxmask(int x, int y, int w, int h, void *b)
1345 {
1346 NOTIMPL("16-bit paged putboxmask");
1347 }
1348
__svgalib_driver16p_copybox(int x1,int y1,int w,int h,int x2,int y2)1349 void __svgalib_driver16p_copybox(int x1, int y1, int w, int h, int x2, int y2)
1350 {
1351 NOTIMPL("16-bit paged copybox");
1352 }
1353
__svgalib_driver24p_putboxmask(int x,int y,int w,int h,void * b)1354 void __svgalib_driver24p_putboxmask(int x, int y, int w, int h, void *b)
1355 {
1356 NOTIMPL("24-bit paged putboxmask");
1357 }
1358
__svgalib_driver24p_copybox(int x1,int y1,int w,int h,int x2,int y2)1359 void __svgalib_driver24p_copybox(int x1, int y1, int w, int h, int x2, int y2)
1360 {
1361 NOTIMPL("24-bit paged copybox");
1362 }
1363
__svgalib_driver32p_putboxmask(int x,int y,int w,int h,void * b)1364 void __svgalib_driver32p_putboxmask(int x, int y, int w, int h, void *b)
1365 {
1366 NOTIMPL("32-bit paged putboxmask");
1367 }
1368
__svgalib_driver32p_copybox(int x1,int y1,int w,int h,int x2,int y2)1369 void __svgalib_driver32p_copybox(int x1, int y1, int w, int h, int x2, int y2)
1370 {
1371 NOTIMPL("32-bit paged copybox");
1372 }
1373