![[BACK]](/icons/back.gif){kind=icon}
Return to rasops24.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / rasops|
Return to rasops24.c CVS log | Up to [local] / sys / dev / rasops |
1.1 nbrk 1: /* $OpenBSD: rasops24.c,v 1.5 2002/07/27 22:17:49 miod Exp $ */
2: /* $NetBSD: rasops24.c,v 1.12 2000/04/12 14:22:29 pk Exp $ */
3:
4: /*-
5: * Copyright (c) 1999 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Andrew Doran.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: #include <sys/param.h>
41: #include <sys/systm.h>
42: #include <sys/time.h>
43:
44: #include <machine/endian.h>
45:
46: #include <dev/wscons/wsdisplayvar.h>
47: #include <dev/wscons/wsconsio.h>
48: #include <dev/rasops/rasops.h>
49:
50: void rasops24_erasecols(void *, int, int, int, long);
51: void rasops24_eraserows(void *, int, int, long);
52: void rasops24_putchar(void *, int, int, u_int, long attr);
53: #ifndef RASOPS_SMALL
54: void rasops24_putchar8(void *, int, int, u_int, long attr);
55: void rasops24_putchar12(void *, int, int, u_int, long attr);
56: void rasops24_putchar16(void *, int, int, u_int, long attr);
57: void rasops24_makestamp(struct rasops_info *, long);
58:
59: /*
60: * 4x1 stamp for optimized character blitting
61: */
62: static int32_t stamp[64];
63: static long stamp_attr;
64: static int stamp_mutex; /* XXX see note in readme */
65: #endif
66:
67: /*
68: * XXX this confuses the hell out of gcc2 (not egcs) which always insists
69: * that the shift count is negative.
70: *
71: * offset = STAMP_SHIFT(fontbits, nibble #) & STAMP_MASK
72: * destination int32_t[0] = STAMP_READ(offset)
73: * destination int32_t[1] = STAMP_READ(offset + 4)
74: * destination int32_t[2] = STAMP_READ(offset + 8)
75: */
76: #define STAMP_SHIFT(fb,n) ((n*4-4) >= 0 ? (fb)>>(n*4-4):(fb)<<-(n*4-4))
77: #define STAMP_MASK (0xf << 4)
78: #define STAMP_READ(o) (*(int32_t *)((caddr_t)stamp + (o)))
79:
80: /*
81: * Initialize rasops_info struct for this colordepth.
82: */
83: void
84: rasops24_init(ri)
85: struct rasops_info *ri;
86: {
87:
88: switch (ri->ri_font->fontwidth) {
89: #ifndef RASOPS_SMALL
90: case 8:
91: ri->ri_ops.putchar = rasops24_putchar8;
92: break;
93: case 12:
94: ri->ri_ops.putchar = rasops24_putchar12;
95: break;
96: case 16:
97: ri->ri_ops.putchar = rasops24_putchar16;
98: break;
99: #endif
100: default:
101: ri->ri_ops.putchar = rasops24_putchar;
102: break;
103: }
104:
105: if (ri->ri_rnum == 0) {
106: ri->ri_rnum = 8;
107: ri->ri_rpos = 0;
108: ri->ri_gnum = 8;
109: ri->ri_gpos = 8;
110: ri->ri_bnum = 8;
111: ri->ri_bpos = 16;
112: }
113:
114: ri->ri_ops.erasecols = rasops24_erasecols;
115: ri->ri_ops.eraserows = rasops24_eraserows;
116: }
117:
118: /*
119: * Put a single character. This is the generic version.
120: * XXX this bites - we should use masks.
121: */
122: void
123: rasops24_putchar(cookie, row, col, uc, attr)
124: void *cookie;
125: int row, col;
126: u_int uc;
127: long attr;
128: {
129: int fb, width, height, cnt, clr[2];
130: struct rasops_info *ri;
131: u_char *dp, *rp, *fr;
132:
133: ri = (struct rasops_info *)cookie;
134:
135: #ifdef RASOPS_CLIPPING
136: /* Catches 'row < 0' case too */
137: if ((unsigned)row >= (unsigned)ri->ri_rows)
138: return;
139:
140: if ((unsigned)col >= (unsigned)ri->ri_cols)
141: return;
142: #endif
143:
144: rp = ri->ri_bits + row * ri->ri_yscale + col * ri->ri_xscale;
145: height = ri->ri_font->fontheight;
146: width = ri->ri_font->fontwidth;
147:
148: clr[1] = ri->ri_devcmap[((u_int)attr >> 24) & 0xf];
149: clr[0] = ri->ri_devcmap[((u_int)attr >> 16) & 0xf];
150:
151: if (uc == ' ') {
152: u_char c = clr[0];
153: while (height--) {
154: dp = rp;
155: rp += ri->ri_stride;
156:
157: for (cnt = width; cnt; cnt--) {
158: *dp++ = c >> 16;
159: *dp++ = c >> 8;
160: *dp++ = c;
161: }
162: }
163: } else {
164: uc -= ri->ri_font->firstchar;
165: fr = (u_char *)ri->ri_font->data + uc * ri->ri_fontscale;
166:
167: while (height--) {
168: dp = rp;
169: fb = fr[3] | (fr[2] << 8) | (fr[1] << 16) |
170: (fr[0] << 24);
171: fr += ri->ri_font->stride;
172: rp += ri->ri_stride;
173:
174: for (cnt = width; cnt; cnt--, fb <<= 1) {
175: if ((fb >> 31) & 1) {
176: *dp++ = clr[1] >> 16;
177: *dp++ = clr[1] >> 8;
178: *dp++ = clr[1];
179: } else {
180: *dp++ = clr[0] >> 16;
181: *dp++ = clr[0] >> 8;
182: *dp++ = clr[0];
183: }
184: }
185: }
186: }
187:
188: /* Do underline */
189: if ((attr & 1) != 0) {
190: u_char c = clr[1];
191:
192: rp -= ri->ri_stride << 1;
193:
194: while (width--) {
195: *rp++ = c >> 16;
196: *rp++ = c >> 8;
197: *rp++ = c;
198: }
199: }
200: }
201:
202: #ifndef RASOPS_SMALL
203: /*
204: * Recompute the blitting stamp.
205: */
206: void
207: rasops24_makestamp(ri, attr)
208: struct rasops_info *ri;
209: long attr;
210: {
211: u_int fg, bg, c1, c2, c3, c4;
212: int i;
213:
214: fg = ri->ri_devcmap[((u_int)attr >> 24) & 0xf] & 0xffffff;
215: bg = ri->ri_devcmap[((u_int)attr >> 16) & 0xf] & 0xffffff;
216: stamp_attr = attr;
217:
218: for (i = 0; i < 64; i += 4) {
219: #if BYTE_ORDER == LITTLE_ENDIAN
220: c1 = (i & 32 ? fg : bg);
221: c2 = (i & 16 ? fg : bg);
222: c3 = (i & 8 ? fg : bg);
223: c4 = (i & 4 ? fg : bg);
224: #else
225: c1 = (i & 8 ? fg : bg);
226: c2 = (i & 4 ? fg : bg);
227: c3 = (i & 16 ? fg : bg);
228: c4 = (i & 32 ? fg : bg);
229: #endif
230: stamp[i+0] = (c1 << 8) | (c2 >> 16);
231: stamp[i+1] = (c2 << 16) | (c3 >> 8);
232: stamp[i+2] = (c3 << 24) | c4;
233:
234: #if BYTE_ORDER == LITTLE_ENDIAN
235: if ((ri->ri_flg & RI_BSWAP) == 0) {
236: #else
237: if ((ri->ri_flg & RI_BSWAP) != 0) {
238: #endif
239: stamp[i+0] = swap32(stamp[i+0]);
240: stamp[i+1] = swap32(stamp[i+1]);
241: stamp[i+2] = swap32(stamp[i+2]);
242: }
243: }
244: }
245:
246: /*
247: * Put a single character. This is for 8-pixel wide fonts.
248: */
249: void
250: rasops24_putchar8(cookie, row, col, uc, attr)
251: void *cookie;
252: int row, col;
253: u_int uc;
254: long attr;
255: {
256: struct rasops_info *ri;
257: int height, so, fs;
258: int32_t *rp;
259: u_char *fr;
260:
261: /* Can't risk remaking the stamp if it's already in use */
262: if (stamp_mutex++) {
263: stamp_mutex--;
264: rasops24_putchar(cookie, row, col, uc, attr);
265: return;
266: }
267:
268: ri = (struct rasops_info *)cookie;
269:
270: #ifdef RASOPS_CLIPPING
271: if ((unsigned)row >= (unsigned)ri->ri_rows) {
272: stamp_mutex--;
273: return;
274: }
275:
276: if ((unsigned)col >= (unsigned)ri->ri_cols) {
277: stamp_mutex--;
278: return;
279: }
280: #endif
281:
282: /* Recompute stamp? */
283: if (attr != stamp_attr)
284: rasops24_makestamp(ri, attr);
285:
286: rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
287: height = ri->ri_font->fontheight;
288:
289: if (uc == (u_int)-1) {
290: int32_t c = stamp[0];
291: while (height--) {
292: rp[0] = rp[1] = rp[2] = rp[3] = rp[4] = rp[5] = c;
293: DELTA(rp, ri->ri_stride, int32_t *);
294: }
295: } else {
296: uc -= ri->ri_font->firstchar;
297: fr = (u_char *)ri->ri_font->data + uc*ri->ri_fontscale;
298: fs = ri->ri_font->stride;
299:
300: while (height--) {
301: so = STAMP_SHIFT(fr[0], 1) & STAMP_MASK;
302: rp[0] = STAMP_READ(so);
303: rp[1] = STAMP_READ(so + 4);
304: rp[2] = STAMP_READ(so + 8);
305:
306: so = STAMP_SHIFT(fr[0], 0) & STAMP_MASK;
307: rp[3] = STAMP_READ(so);
308: rp[4] = STAMP_READ(so + 4);
309: rp[5] = STAMP_READ(so + 8);
310:
311: fr += fs;
312: DELTA(rp, ri->ri_stride, int32_t *);
313: }
314: }
315:
316: /* Do underline */
317: if ((attr & 1) != 0) {
318: int32_t c = STAMP_READ(52);
319:
320: DELTA(rp, -(ri->ri_stride << 1), int32_t *);
321: rp[0] = rp[1] = rp[2] = rp[3] = rp[4] = rp[5] = c;
322: }
323:
324: stamp_mutex--;
325: }
326:
327: /*
328: * Put a single character. This is for 12-pixel wide fonts.
329: */
330: void
331: rasops24_putchar12(cookie, row, col, uc, attr)
332: void *cookie;
333: int row, col;
334: u_int uc;
335: long attr;
336: {
337: struct rasops_info *ri;
338: int height, so, fs;
339: int32_t *rp;
340: u_char *fr;
341:
342: /* Can't risk remaking the stamp if it's already in use */
343: if (stamp_mutex++) {
344: stamp_mutex--;
345: rasops24_putchar(cookie, row, col, uc, attr);
346: return;
347: }
348:
349: ri = (struct rasops_info *)cookie;
350:
351: #ifdef RASOPS_CLIPPING
352: if ((unsigned)row >= (unsigned)ri->ri_rows) {
353: stamp_mutex--;
354: return;
355: }
356:
357: if ((unsigned)col >= (unsigned)ri->ri_cols) {
358: stamp_mutex--;
359: return;
360: }
361: #endif
362:
363: /* Recompute stamp? */
364: if (attr != stamp_attr)
365: rasops24_makestamp(ri, attr);
366:
367: rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
368: height = ri->ri_font->fontheight;
369:
370: if (uc == (u_int)-1) {
371: int32_t c = stamp[0];
372: while (height--) {
373: rp[0] = rp[1] = rp[2] = rp[3] =
374: rp[4] = rp[5] = rp[6] = rp[7] = rp[8] = c;
375: DELTA(rp, ri->ri_stride, int32_t *);
376: }
377: } else {
378: uc -= ri->ri_font->firstchar;
379: fr = (u_char *)ri->ri_font->data + uc*ri->ri_fontscale;
380: fs = ri->ri_font->stride;
381:
382: while (height--) {
383: so = STAMP_SHIFT(fr[0], 1) & STAMP_MASK;
384: rp[0] = STAMP_READ(so);
385: rp[1] = STAMP_READ(so + 4);
386: rp[2] = STAMP_READ(so + 8);
387:
388: so = STAMP_SHIFT(fr[0], 0) & STAMP_MASK;
389: rp[3] = STAMP_READ(so);
390: rp[4] = STAMP_READ(so + 4);
391: rp[5] = STAMP_READ(so + 8);
392:
393: so = STAMP_SHIFT(fr[1], 1) & STAMP_MASK;
394: rp[6] = STAMP_READ(so);
395: rp[7] = STAMP_READ(so + 4);
396: rp[8] = STAMP_READ(so + 8);
397:
398: fr += fs;
399: DELTA(rp, ri->ri_stride, int32_t *);
400: }
401: }
402:
403: /* Do underline */
404: if ((attr & 1) != 0) {
405: int32_t c = STAMP_READ(52);
406:
407: DELTA(rp, -(ri->ri_stride << 1), int32_t *);
408: rp[0] = rp[1] = rp[2] = rp[3] =
409: rp[4] = rp[5] = rp[6] = rp[7] = rp[8] = c;
410: }
411:
412: stamp_mutex--;
413: }
414:
415: /*
416: * Put a single character. This is for 16-pixel wide fonts.
417: */
418: void
419: rasops24_putchar16(cookie, row, col, uc, attr)
420: void *cookie;
421: int row, col;
422: u_int uc;
423: long attr;
424: {
425: struct rasops_info *ri;
426: int height, so, fs;
427: int32_t *rp;
428: u_char *fr;
429:
430: /* Can't risk remaking the stamp if it's already in use */
431: if (stamp_mutex++) {
432: stamp_mutex--;
433: rasops24_putchar(cookie, row, col, uc, attr);
434: return;
435: }
436:
437: ri = (struct rasops_info *)cookie;
438:
439: #ifdef RASOPS_CLIPPING
440: if ((unsigned)row >= (unsigned)ri->ri_rows) {
441: stamp_mutex--;
442: return;
443: }
444:
445: if ((unsigned)col >= (unsigned)ri->ri_cols) {
446: stamp_mutex--;
447: return;
448: }
449: #endif
450:
451: /* Recompute stamp? */
452: if (attr != stamp_attr)
453: rasops24_makestamp(ri, attr);
454:
455: rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
456: height = ri->ri_font->fontheight;
457:
458: if (uc == (u_int)-1) {
459: int32_t c = stamp[0];
460: while (height--) {
461: rp[0] = rp[1] = rp[2] = rp[3] =
462: rp[4] = rp[5] = rp[6] = rp[7] =
463: rp[8] = rp[9] = rp[10] = rp[11] = c;
464: DELTA(rp, ri->ri_stride, int32_t *);
465: }
466: } else {
467: uc -= ri->ri_font->firstchar;
468: fr = (u_char *)ri->ri_font->data + uc*ri->ri_fontscale;
469: fs = ri->ri_font->stride;
470:
471: while (height--) {
472: so = STAMP_SHIFT(fr[0], 1) & STAMP_MASK;
473: rp[0] = STAMP_READ(so);
474: rp[1] = STAMP_READ(so + 4);
475: rp[2] = STAMP_READ(so + 8);
476:
477: so = STAMP_SHIFT(fr[0], 0) & STAMP_MASK;
478: rp[3] = STAMP_READ(so);
479: rp[4] = STAMP_READ(so + 4);
480: rp[5] = STAMP_READ(so + 8);
481:
482: so = STAMP_SHIFT(fr[1], 1) & STAMP_MASK;
483: rp[6] = STAMP_READ(so);
484: rp[7] = STAMP_READ(so + 4);
485: rp[8] = STAMP_READ(so + 8);
486:
487: so = STAMP_SHIFT(fr[1], 0) & STAMP_MASK;
488: rp[9] = STAMP_READ(so);
489: rp[10] = STAMP_READ(so + 4);
490: rp[11] = STAMP_READ(so + 8);
491:
492: DELTA(rp, ri->ri_stride, int32_t *);
493: fr += fs;
494: }
495: }
496:
497: /* Do underline */
498: if ((attr & 1) != 0) {
499: int32_t c = STAMP_READ(52);
500:
501: DELTA(rp, -(ri->ri_stride << 1), int32_t *);
502: rp[0] = rp[1] = rp[2] = rp[3] =
503: rp[4] = rp[5] = rp[6] = rp[7] =
504: rp[8] = rp[9] = rp[10] = rp[11] = c;
505: }
506:
507: stamp_mutex--;
508: }
509: #endif /* !RASOPS_SMALL */
510:
511: /*
512: * Erase rows. This is nice and easy due to alignment.
513: */
514: void
515: rasops24_eraserows(cookie, row, num, attr)
516: void *cookie;
517: int row, num;
518: long attr;
519: {
520: int n9, n3, n1, cnt, stride, delta;
521: u_int32_t *dp, clr, stamp[3];
522: struct rasops_info *ri;
523:
524: /*
525: * If the color is gray, we can cheat and use the generic routines
526: * (which are faster, hopefully) since the r,g,b values are the same.
527: */
528: if ((attr & 4) != 0) {
529: rasops_eraserows(cookie, row, num, attr);
530: return;
531: }
532:
533: ri = (struct rasops_info *)cookie;
534:
535: #ifdef RASOPS_CLIPPING
536: if (row < 0) {
537: num += row;
538: row = 0;
539: }
540:
541: if ((row + num) > ri->ri_rows)
542: num = ri->ri_rows - row;
543:
544: if (num <= 0)
545: return;
546: #endif
547:
548: clr = ri->ri_devcmap[(attr >> 16) & 0xf] & 0xffffff;
549: stamp[0] = (clr << 8) | (clr >> 16);
550: stamp[1] = (clr << 16) | (clr >> 8);
551: stamp[2] = (clr << 24) | clr;
552:
553: #if BYTE_ORDER == LITTLE_ENDIAN
554: if ((ri->ri_flg & RI_BSWAP) == 0) {
555: #else
556: if ((ri->ri_flg & RI_BSWAP) != 0) {
557: #endif
558: stamp[0] = swap32(stamp[0]);
559: stamp[1] = swap32(stamp[1]);
560: stamp[2] = swap32(stamp[2]);
561: }
562:
563: /*
564: * XXX the wsdisplay_emulops interface seems a little deficient in
565: * that there is no way to clear the *entire* screen. We provide a
566: * workaround here: if the entire console area is being cleared, and
567: * the RI_FULLCLEAR flag is set, clear the entire display.
568: */
569: if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) {
570: stride = ri->ri_stride;
571: num = ri->ri_height;
572: dp = (int32_t *)ri->ri_origbits;
573: delta = 0;
574: } else {
575: stride = ri->ri_emustride;
576: num *= ri->ri_font->fontheight;
577: dp = (int32_t *)(ri->ri_bits + row * ri->ri_yscale);
578: delta = ri->ri_delta;
579: }
580:
581: n9 = stride / 36;
582: cnt = (n9 << 5) + (n9 << 2); /* (32*n9) + (4*n9) */
583: n3 = (stride - cnt) / 12;
584: cnt += (n3 << 3) + (n3 << 2); /* (8*n3) + (4*n3) */
585: n1 = (stride - cnt) >> 2;
586:
587: while (num--) {
588: for (cnt = n9; cnt; cnt--) {
589: dp[0] = stamp[0];
590: dp[1] = stamp[1];
591: dp[2] = stamp[2];
592: dp[3] = stamp[0];
593: dp[4] = stamp[1];
594: dp[5] = stamp[2];
595: dp[6] = stamp[0];
596: dp[7] = stamp[1];
597: dp[8] = stamp[2];
598: dp += 9;
599: }
600:
601: for (cnt = n3; cnt; cnt--) {
602: dp[0] = stamp[0];
603: dp[1] = stamp[1];
604: dp[2] = stamp[2];
605: dp += 3;
606: }
607:
608: for (cnt = 0; cnt < n1; cnt++)
609: *dp++ = stamp[cnt];
610:
611: DELTA(dp, delta, int32_t *);
612: }
613: }
614:
615: /*
616: * Erase columns.
617: */
618: void
619: rasops24_erasecols(cookie, row, col, num, attr)
620: void *cookie;
621: int row, col, num;
622: long attr;
623: {
624: int n12, n4, height, cnt, slop, clr, stamp[3];
625: struct rasops_info *ri;
626: int32_t *dp, *rp;
627: u_char *dbp;
628:
629: /*
630: * If the color is gray, we can cheat and use the generic routines
631: * (which are faster, hopefully) since the r,g,b values are the same.
632: */
633: if ((attr & 4) != 0) {
634: rasops_erasecols(cookie, row, col, num, attr);
635: return;
636: }
637:
638: ri = (struct rasops_info *)cookie;
639:
640: #ifdef RASOPS_CLIPPING
641: /* Catches 'row < 0' case too */
642: if ((unsigned)row >= (unsigned)ri->ri_rows)
643: return;
644:
645: if (col < 0) {
646: num += col;
647: col = 0;
648: }
649:
650: if ((col + num) > ri->ri_cols)
651: num = ri->ri_cols - col;
652:
653: if (num <= 0)
654: return;
655: #endif
656:
657: rp = (int32_t *)(ri->ri_bits + row*ri->ri_yscale + col*ri->ri_xscale);
658: num *= ri->ri_font->fontwidth;
659: height = ri->ri_font->fontheight;
660:
661: clr = ri->ri_devcmap[(attr >> 16) & 0xf] & 0xffffff;
662: stamp[0] = (clr << 8) | (clr >> 16);
663: stamp[1] = (clr << 16) | (clr >> 8);
664: stamp[2] = (clr << 24) | clr;
665:
666: #if BYTE_ORDER == LITTLE_ENDIAN
667: if ((ri->ri_flg & RI_BSWAP) == 0) {
668: #else
669: if ((ri->ri_flg & RI_BSWAP) != 0) {
670: #endif
671: stamp[0] = swap32(stamp[0]);
672: stamp[1] = swap32(stamp[1]);
673: stamp[2] = swap32(stamp[2]);
674: }
675:
676: /*
677: * The current byte offset mod 4 tells us the number of 24-bit pels
678: * we need to write for alignment to 32-bits. Once we're aligned on
679: * a 32-bit boundary, we're also aligned on a 4 pixel boundary, so
680: * the stamp does not need to be rotated. The following shows the
681: * layout of 4 pels in a 3 word region and illustrates this:
682: *
683: * aaab bbcc cddd
684: */
685: slop = (long)rp & 3; num -= slop;
686: n12 = num / 12; num -= (n12 << 3) + (n12 << 2);
687: n4 = num >> 2; num &= 3;
688:
689: while (height--) {
690: dbp = (u_char *)rp;
691: DELTA(rp, ri->ri_stride, int32_t *);
692:
693: /* Align to 4 bytes */
694: /* XXX handle with masks, bring under control of RI_BSWAP */
695: for (cnt = slop; cnt; cnt--) {
696: *dbp++ = (clr >> 16);
697: *dbp++ = (clr >> 8);
698: *dbp++ = clr;
699: }
700:
701: dp = (int32_t *)dbp;
702:
703: /* 12 pels per loop */
704: for (cnt = n12; cnt; cnt--) {
705: dp[0] = stamp[0];
706: dp[1] = stamp[1];
707: dp[2] = stamp[2];
708: dp[3] = stamp[0];
709: dp[4] = stamp[1];
710: dp[5] = stamp[2];
711: dp[6] = stamp[0];
712: dp[7] = stamp[1];
713: dp[8] = stamp[2];
714: dp += 9;
715: }
716:
717: /* 4 pels per loop */
718: for (cnt = n4; cnt; cnt--) {
719: dp[0] = stamp[0];
720: dp[1] = stamp[1];
721: dp[2] = stamp[2];
722: dp += 3;
723: }
724:
725: /* Trailing slop */
726: /* XXX handle with masks, bring under control of RI_BSWAP */
727: dbp = (u_char *)dp;
728: for (cnt = num; cnt; cnt--) {
729: *dbp++ = (clr >> 16);
730: *dbp++ = (clr >> 8);
731: *dbp++ = clr;
732: }
733: }
734: }