![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devbit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port|
Return to devbit.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include <libg.h>
4: #include <gnot.h>
5: #include "mem.h"
6: #include "dat.h"
7: #include "fns.h"
8: #include "../port/error.h"
9:
10: #include "devtab.h"
11:
12: #include "screen.h"
13:
14: /*
15: * Some monochrome screens are reversed from what we like:
16: * We want 0's bright and 1's dark.
17: * Indexed by an Fcode, these compensate for the source bitmap being wrong
18: * (exchange S rows) and destination (exchange D columns and invert result)
19: */
20: int flipS[] = {
21: 0x0, 0x4, 0x8, 0xC, 0x1, 0x5, 0x9, 0xD,
22: 0x2, 0x6, 0xA, 0xE, 0x3, 0x7, 0xB, 0xF
23: };
24:
25: int flipD[] = {
26: 0xF, 0xD, 0xE, 0xC, 0x7, 0x5, 0x6, 0x4,
27: 0xB, 0x9, 0xA, 0x8, 0x3, 0x1, 0x2, 0x0,
28: };
29:
30: int flipping; /* are flip tables being used to transform Fcodes? */
31:
32: /*
33: * Device (#b/bitblt) is exclusive use on open, so no locks are necessary
34: * for i/o
35: */
36:
37: /*
38: * Arena is a word containing N, followed by a pointer to the Arena,
39: * followed by a pointer to the Bitmap, followed by N words.
40: * The bitmap pointer is zero if block is free.
41: * bit.map is an array of pointers to GBitmaps. The GBitmaps are
42: * freed individually and their corresponding entries in bit.map are zeroed.
43: * The index into bit.map is the Bitmap id as seen in libg. Subfonts and
44: * fonts are handled similarly.
45: */
46:
47: typedef struct Arena Arena;
48: struct Arena
49: {
50: ulong *words; /* storage */
51: ulong *wfree; /* pointer to next free word */
52: ulong nwords; /* total in arena */
53: int nbusy; /* number of busy blocks */
54: };
55:
56: typedef struct BSubfont BSubfont;
57: struct BSubfont
58: {
59: GSubfont;
60: int ref; /* number of times this subfont is open */
61: ulong qid[2]; /* unique id used as a cache tag */
62: };
63:
64: extern GSubfont *defont;
65: BSubfont *bdefont;
66: BSubfont bdefont0;
67:
68:
69: struct
70: {
71: Ref;
72: QLock;
73: GBitmap **map; /* indexed array */
74: int nmap; /* number allocated */
75: GFont **font; /* indexed array */
76: int nfont; /* number allocated */
77: BSubfont**subfont; /* indexed array */
78: int nsubfont; /* number allocated */
79: Arena *arena; /* array */
80: int narena; /* number allocated */
81: int mouseopen; /* flag: mouse open */
82: int bitbltopen; /* flag: bitblt open */
83: int bid; /* last allocated bitmap id */
84: int subfid; /* last allocated subfont id */
85: int cacheid; /* last cached subfont id */
86: int fid; /* last allocated font id */
87: int init; /* freshly opened; init message pending */
88: int rid; /* read bitmap id */
89: int rminy; /* read miny */
90: int rmaxy; /* read maxy */
91: int mid; /* colormap read bitmap id */
92: }bit;
93:
94: #define DMAP 16 /* delta increase in size of arrays */
95: #define FREE 0x80000000
96:
97: void bitcompact(void);
98: int bitalloc(Rectangle, int);
99: void bitfree(GBitmap*);
100: void fontfree(GFont*);
101: void subfontfree(BSubfont*, int);
102: void arenafree(Arena*);
103: void bitstring(GBitmap*, Point, GFont*, uchar*, long, Fcode);
104: void bitloadchar(GFont*, int, GSubfont*, int);
105: extern GBitmap gscreen;
106:
107: typedef struct Mouseinfo Mouseinfo;
108: typedef struct Cursorinfo Cursorinfo;
109:
110: struct Mouseinfo{
111: /*
112: * First three fields are known in some l.s's
113: */
114: int dx;
115: int dy;
116: int track; /* l.s has updated dx & dy */
117: Mouse;
118: int redraw; /* update cursor on screen */
119: ulong counter; /* increments every update */
120: ulong lastcounter; /* value when /dev/mouse read */
121: Rendez r;
122: };
123:
124: struct Cursorinfo{
125: Cursor;
126: Lock;
127: int visible; /* on screen */
128: Rectangle r; /* location */
129: };
130:
131: Mouseinfo mouse;
132: Cursorinfo cursor;
133: Cursor curs;
134: int mouseshifted;
135: int mousetype;
136: int mouseswap;
137: int islittle;
138: int hwcurs;
139:
140: Cursor arrow =
141: {
142: {-1, -1},
143: {0xFF, 0xE0, 0xFF, 0xE0, 0xFF, 0xC0, 0xFF, 0x00,
144: 0xFF, 0x00, 0xFF, 0x80, 0xFF, 0xC0, 0xFF, 0xE0,
145: 0xE7, 0xF0, 0xE3, 0xF8, 0xC1, 0xFC, 0x00, 0xFE,
146: 0x00, 0x7F, 0x00, 0x3E, 0x00, 0x1C, 0x00, 0x08,
147: },
148: {0x00, 0x00, 0x7F, 0xC0, 0x7F, 0x00, 0x7C, 0x00,
149: 0x7E, 0x00, 0x7F, 0x00, 0x6F, 0x80, 0x67, 0xC0,
150: 0x43, 0xE0, 0x41, 0xF0, 0x00, 0xF8, 0x00, 0x7C,
151: 0x00, 0x3E, 0x00, 0x1C, 0x00, 0x08, 0x00, 0x00,
152: }
153: };
154:
155: ulong setbits[16];
156: GBitmap set =
157: {
158: setbits,
159: 0,
160: 1,
161: 0,
162: {0, 0, 16, 16},
163: {0, 0, 16, 16}
164: };
165:
166: ulong clrbits[16];
167: GBitmap clr =
168: {
169: clrbits,
170: 0,
171: 1,
172: 0,
173: {0, 0, 16, 16},
174: {0, 0, 16, 16}
175: };
176:
177: ulong cursorbackbits[16*4];
178: GBitmap cursorback =
179: {
180: cursorbackbits,
181: 0,
182: 1,
183: 0,
184: {0, 0, 16, 16},
185: {0, 0, 16, 16}
186: };
187:
188: void Cursortocursor(Cursor*);
189: int mousechanged(void*);
190:
191: enum{
192: Qdir,
193: Qbitblt,
194: Qmouse,
195: Qmousectl,
196: Qscreen,
197: };
198:
199: Dirtab bitdir[]={
200: "bitblt", {Qbitblt}, 0, 0666,
201: "mouse", {Qmouse}, 0, 0666,
202: "mousectl", {Qmousectl}, 0, 0220,
203: "screen", {Qscreen}, 0, 0444,
204: };
205:
206: #define NBIT (sizeof bitdir/sizeof(Dirtab))
207: #define NINFO 8192 /* max chars per subfont; sanity check only */
208: #define HDR 3
209:
210: void
211: lockedupdate(void)
212: {
213: qlock(&bit);
214: if(waserror()){
215: qunlock(&bit);
216: return;
217: }
218: screenupdate();
219: qunlock(&bit);
220: poperror();
221: }
222:
223: void
224: bitfreeup(void)
225: {
226: int i;
227: BSubfont *s;
228:
229: /* free unused subfonts and compact */
230: for(i=0; i<bit.nsubfont; i++){
231: s = bit.subfont[i];
232: if(s && s!=bdefont && s->ref==0){
233: s->ref = 1;
234: s->qid[0] = ~0; /* force cleanup */
235: subfontfree(s, i);
236: }
237: }
238: bitcompact();
239: }
240:
241: void*
242: bitmalloc(ulong n)
243: {
244: void *p;
245:
246: p = malloc(n);
247: if(p)
248: return p;
249: bitfreeup();
250: return malloc(n);
251: }
252:
253: void
254: bitdebug(void)
255: {
256: int i;
257: long l;
258: Arena *a;
259:
260: l = 0;
261: for(i=0; i<bit.narena; i++){
262: a = &bit.arena[i];
263: if(a->words){
264: l += a->nwords;
265: print("%d: %ld bytes used; %ld total\n", i,
266: (a->wfree-a->words)*sizeof(ulong),
267: a->nwords*sizeof(ulong));
268: }
269: }
270: print("arena: %ld bytes\n", l*sizeof(ulong));
271: l = 0;
272: for(i=0; i<bit.nmap; i++)
273: if(bit.map[i])
274: l++;
275: print("%d bitmaps ", l);
276: l = 0;
277: for(i=0; i<bit.nfont; i++)
278: if(bit.font[i])
279: l++;
280: print("%d fonts ", l);
281: l = 0;
282: for(i=0; i<bit.nsubfont; i++)
283: if(bit.subfont[i]){
284: print("%d: %lux %lux ", i, bit.subfont[i]->qid[0], bit.subfont[i]->qid[1]);
285: l++;
286: }
287: print("%d subfonts\n", l);
288: }
289:
290: void
291: bitreset(void)
292: {
293: int ws;
294: ulong r;
295: Arena *a;
296:
297: if(!conf.monitor)
298: return;
299:
300: memmove(&bdefont0, defont, sizeof(*defont));
301: bdefont = &bdefont0;
302: bit.map = smalloc(DMAP*sizeof(GBitmap*));
303: bit.nmap = DMAP;
304: getcolor(0, &r, &r, &r);
305: if(r == 0)
306: flipping = 1;
307: bit.bid = -1;
308: bit.subfid = -1;
309: bit.fid = -1;
310: bit.cacheid = -1;
311: bit.font = smalloc(DMAP*sizeof(GFont*));
312: bit.nfont = DMAP;
313: bit.subfont = smalloc(DMAP*sizeof(BSubfont*));
314: bit.nsubfont = DMAP;
315: bit.arena = smalloc(DMAP*sizeof(Arena));
316: bit.narena = DMAP;
317: a = &bit.arena[0];
318: /*
319: * Somewhat of a heuristic: start with three screensful and
320: * allocate single screensful dynamically if needed.
321: */
322:
323: ws = BI2WD>>gscreen.ldepth; /* pixels per word */
324: a->nwords = 3*(HDR + gscreen.r.max.y*gscreen.r.max.x/ws);
325: a->words = xalloc(a->nwords*sizeof(ulong));
326: if(a->words == 0){
327: /* try again */
328: print("bitreset: allocating only 1 screenful\n");
329: a->nwords /= 3;
330: a->words = a->words = xalloc(a->nwords*sizeof(ulong));
331: if(a->words == 0)
332: panic("bitreset");
333: }
334: a->wfree = a->words;
335: a->nbusy = 1; /* keep 0th arena from being freed */
336: Cursortocursor(&arrow);
337: }
338:
339: /*
340: * screen bit depth changed, reset backup map for cursor
341: */
342: void
343: bitdepth(void)
344: {
345: cursoroff(1);
346: if(gscreen.ldepth > 3)
347: cursorback.ldepth = 0;
348: else{
349: cursorback.ldepth = gscreen.ldepth;
350: cursorback.width = ((16 << gscreen.ldepth) + 31) >> 5;
351: }
352: cursoron(1);
353: }
354:
355: void
356: bitinit(void)
357: {
358: if(!conf.monitor)
359: return;
360: if(gscreen.ldepth > 3)
361: cursorback.ldepth = 0;
362: else{
363: cursorback.ldepth = gscreen.ldepth;
364: cursorback.width = ((16 << gscreen.ldepth) + 31) >> 5;
365: }
366: cursoron(1);
367: }
368:
369: Chan*
370: bitattach(char *spec)
371: {
372: if(!conf.monitor)
373: error(Egreg);
374: return devattach('b', spec);
375: }
376:
377: Chan*
378: bitclone(Chan *c, Chan *nc)
379: {
380: if(!conf.monitor)
381: error(Egreg);
382: nc = devclone(c, nc);
383: if(c->qid.path != CHDIR)
384: incref(&bit);
385: return nc;
386: }
387:
388: int
389: bitwalk(Chan *c, char *name)
390: {
391: if(!conf.monitor)
392: error(Egreg);
393: return devwalk(c, name, bitdir, NBIT, devgen);
394: }
395:
396: void
397: bitstat(Chan *c, char *db)
398: {
399: if(!conf.monitor)
400: error(Egreg);
401: devstat(c, db, bitdir, NBIT, devgen);
402: }
403:
404: Chan*
405: bitopen(Chan *c, int omode)
406: {
407: GBitmap *b;
408:
409: if(!conf.monitor)
410: error(Egreg);
411: switch(c->qid.path){
412: case CHDIR:
413: if(omode != OREAD)
414: error(Eperm);
415: break;
416: case Qmouse:
417: lock(&bit);
418: if(bit.mouseopen){
419: unlock(&bit);
420: error(Einuse);
421: }
422: bit.mouseopen = 1;
423: bit.ref++;
424: unlock(&bit);
425: break;
426: case Qbitblt:
427: lock(&bit);
428: if(bit.bitbltopen || bit.mouseopen){
429: unlock(&bit);
430: error(Einuse);
431: }
432: b = smalloc(sizeof(GBitmap));
433: *b = gscreen;
434: bit.map[0] = b; /* bitmap 0 is screen */
435: bit.subfont[0] = bdefont; /* subfont 0 is default */
436: bit.subfont[0]->ref = 1;
437: bit.subfont[0]->qid[0] = 0;
438: bit.subfont[0]->qid[1] = 0;
439: bit.bid = -1;
440: bit.fid = -1;
441: bit.subfid = -1;
442: bit.cacheid = -1;
443: bit.rid = -1;
444: bit.mid = -1;
445: bit.init = 0;
446: bit.bitbltopen = 1;
447: Cursortocursor(&arrow);
448: unlock(&bit);
449: break;
450: default:
451: incref(&bit);
452: }
453: c->mode = openmode(omode);
454: c->flag |= COPEN;
455: c->offset = 0;
456: return c;
457: }
458:
459: void
460: bitcreate(Chan *c, char *name, int omode, ulong perm)
461: {
462: if(!conf.monitor)
463: error(Egreg);
464: USED(c, name, omode, perm);
465: error(Eperm);
466: }
467:
468: void
469: bitremove(Chan *c)
470: {
471: if(!conf.monitor)
472: error(Egreg);
473: USED(c);
474: error(Eperm);
475: }
476:
477: void
478: bitwstat(Chan *c, char *db)
479: {
480: if(!conf.monitor)
481: error(Egreg);
482: USED(c, db);
483: error(Eperm);
484: }
485:
486: void
487: bitclose(Chan *c)
488: {
489: GBitmap *b, **bp, **ebp;
490: BSubfont *s, **sp, **esp;
491: GFont *f, **fp, **efp;
492:
493: if(!conf.monitor)
494: error(Egreg);
495: if(c->qid.path!=CHDIR && (c->flag&COPEN)){
496: lock(&bit);
497: if(c->qid.path == Qmouse)
498: bit.mouseopen = 0;
499: if(c->qid.path == Qbitblt)
500: bit.bitbltopen = 0;
501: if(--bit.ref == 0){
502: ebp = &bit.map[bit.nmap];
503: for(bp = bit.map; bp<ebp; bp++){
504: b = *bp;
505: if(b){
506: bitfree(b);
507: *bp = 0;
508: }
509: }
510: esp = &bit.subfont[bit.nsubfont];
511: for(sp=bit.subfont; sp<esp; sp++){
512: s = *sp;
513: if(s)
514: subfontfree(s, sp-bit.subfont);
515: /* don't clear *sp: cached */
516: }
517: efp = &bit.font[bit.nfont];
518: for(fp=bit.font; fp<efp; fp++){
519: f = *fp;
520: if(f){
521: fontfree(f);
522: *fp = 0;
523: }
524: }
525: }
526: unlock(&bit);
527: }
528: }
529:
530: long
531: bitread(Chan *c, void *va, long n, ulong offset)
532: {
533: uchar *p, *q;
534: long miny, maxy, t, x, y;
535: ulong l, nw, ws, rv, gv, bv;
536: int off, j;
537: Fontchar *i;
538: GBitmap *src;
539: BSubfont *s;
540: static int map[8] = {0, 4, 2, 6, 1, 5, 3, 7 };
541:
542: if(!conf.monitor)
543: error(Egreg);
544: if(c->qid.path & CHDIR)
545: return devdirread(c, va, n, bitdir, NBIT, devgen);
546:
547: if(c->qid.path == Qmouse){
548: /*
549: * mouse:
550: * 'm' 1
551: * buttons 1
552: * point 8
553: * msec 4
554: */
555: if(n < 14)
556: error(Ebadblt);
557: while(mousechanged(0) == 0)
558: sleep(&mouse.r, mousechanged, 0);
559: lock(&cursor);
560: p = va;
561: p[0] = 'm';
562: p[1] = mouseswap ? map[mouse.buttons&7] : mouse.buttons;
563: BPLONG(p+2, mouse.xy.x);
564: BPLONG(p+6, mouse.xy.y);
565: BPLONG(p+10, TK2MS(MACHP(0)->ticks));
566: mouse.lastcounter = mouse.counter;
567: unlock(&cursor);
568: return 14;
569: }
570: if(c->qid.path == Qscreen){
571: if(offset==0){
572: if(n < 5*12)
573: error(Eio);
574: sprint(va, "%11d %11d %11d %11d %11d ",
575: gscreen.ldepth, gscreen.r.min.x,
576: gscreen.r.min.y, gscreen.r.max.x,
577: gscreen.r.max.y);
578: return 5*12;
579: }
580: ws = 1<<(3-gscreen.ldepth); /* pixels per byte */
581: l = (gscreen.r.max.x+ws-1)/ws - gscreen.r.min.x/ws;
582: if(l == 0)
583: error(Ebadblt);
584: t = offset-5*12;
585: miny = t/l; /* unsigned computation */
586: maxy = (t+n)/l;
587: if(miny >= gscreen.r.max.y)
588: return 0;
589: if(maxy >= gscreen.r.max.y)
590: maxy = gscreen.r.max.y;
591: n = 0;
592: p = va;
593: for(y=miny; y<maxy; y++){
594: q = (uchar*)gaddr(&gscreen, Pt(0, y));
595: memmove(p, q, l);
596: if(flipping)
597: /* is screen, so must be word aligned */
598: for(x=0; x<l; x+=sizeof(ulong),p+=sizeof(ulong))
599: *(ulong*)p ^= ~0;
600: else
601: p += l;
602: n += l;
603: }
604: return n;
605: }
606: if(c->qid.path != Qbitblt)
607: error(Egreg);
608:
609: qlock(&bit);
610: if(waserror()){
611: qunlock(&bit);
612: nexterror();
613: }
614: p = va;
615: /*
616: * Fuss about and figure out what to say.
617: */
618: if(bit.init){
619: /*
620: * init:
621: * 'I' 1
622: * ldepth 1
623: * rectangle 16
624: * clip rectangle 16
625: * font info 3*12
626: * fontchars 6*(bdefont->n+1)
627: */
628: if(n < 34)
629: error(Ebadblt);
630: p[0] = 'I';
631: p[1] = gscreen.ldepth;
632: BPLONG(p+2, gscreen.r.min.x);
633: BPLONG(p+6, gscreen.r.min.y);
634: BPLONG(p+10, gscreen.r.max.x);
635: BPLONG(p+14, gscreen.r.max.y);
636: BPLONG(p+18, gscreen.clipr.min.x);
637: BPLONG(p+22, gscreen.clipr.min.y);
638: BPLONG(p+26, gscreen.clipr.max.x);
639: BPLONG(p+30, gscreen.clipr.max.y);
640: if(n >= 34+3*12+6*(bdefont->n+1)){
641: p += 34;
642: sprint((char*)p, "%11d %11d %11d ", bdefont->n,
643: bdefont->height, bdefont->ascent);
644: p += 3*12;
645: for(i=bdefont->info,j=0; j<=bdefont->n; j++,i++,p+=6){
646: BPSHORT(p, i->x);
647: p[2] = i->top;
648: p[3] = i->bottom;
649: p[4] = i->left;
650: p[5] = i->width;
651: }
652: n = 34+3*12+6*(bdefont->n+1);
653: }else
654: n = 34;
655: bit.init = 0;
656: }else if(bit.bid > 0){
657: /*
658: * allocate:
659: * 'A' 1
660: * bitmap id 2
661: */
662: if(n < 3)
663: error(Ebadblt);
664: if(bit.bid<0 || bit.map[bit.bid]==0)
665: error(Ebadbitmap);
666: p[0] = 'A';
667: BPSHORT(p+1, bit.bid);
668: bit.bid = -1;
669: n = 3;
670: }else if(bit.subfid > 0){
671: /*
672: * allocate subfont:
673: * 'K' 1
674: * subfont id 2
675: */
676: if(n<3 || bit.subfid<0)
677: error(Ebadblt);
678: s = bit.subfont[bit.subfid];
679: if(s==0 || s->ref==0)
680: error(Ebadfont);
681: p[0] = 'K';
682: BPSHORT(p+1, bit.subfid);
683: bit.subfid = -1;
684: n = 3;
685: }else if(bit.cacheid >= 0){
686: /*
687: * check cache for subfont:
688: * 'J' 1
689: * subfont id 2
690: * font info 3*12
691: * fontchars 6*(subfont->n+1)
692: */
693: p[0] = 'J';
694: if(bit.cacheid < 0)
695: error(Ebadfont);
696: s = bit.subfont[bit.cacheid];
697: if(s==0 || s->ref==0)
698: error(Ebadfont);
699: if(n < 3+3*12+6*(s->n+1))
700: error(Ebadblt);
701: BPSHORT(p+1, bit.cacheid);
702: p += 3;
703: sprint((char*)p, "%11d %11d %11d ", s->n, s->height, s->ascent);
704: p += 3*12;
705: for(i=s->info,j=0; j<=s->n; j++,i++,p+=6){
706: BPSHORT(p, i->x);
707: p[2] = i->top;
708: p[3] = i->bottom;
709: p[4] = i->left;
710: p[5] = i->width;
711: }
712: n = 3+3*12+6*(s->n+1);
713: bit.cacheid = -1;
714: }else if(bit.fid >= 0){
715: /*
716: * allocate font:
717: * 'N' 1
718: * font id 2
719: */
720: if(n < 3)
721: error(Ebadblt);
722: if(bit.fid<0 || bit.font[bit.fid]==0)
723: error(Ebadfont);
724: p[0] = 'N';
725: BPSHORT(p+1, bit.fid);
726: bit.fid = -1;
727: n = 3;
728: }else if(bit.mid >= 0){
729: /*
730: * read colormap:
731: * data 12*(2**bitmapdepth)
732: */
733: src = bit.map[bit.mid];
734: if(src == 0)
735: error(Ebadbitmap);
736: l = (1<<src->ldepth);
737: nw = 1 << l;
738: if(n < 12*nw)
739: error(Ebadblt);
740: for(j = 0; j < nw; j++){
741: if(bit.mid == 0){
742: getcolor(flipping? nw-j-1 : j, &rv, &gv, &bv);
743: }else{
744: rv = j;
745: for(off = 32-l; off > 0; off -= l)
746: rv = (rv << l) | j;
747: gv = bv = rv;
748: }
749: BPLONG(p, rv);
750: BPLONG(p+4, gv);
751: BPLONG(p+8, bv);
752: p += 12;
753: }
754: bit.mid = -1;
755: n = 12*nw;
756: }else if(bit.rid >= 0){
757: /*
758: * read bitmap:
759: * data bytewidth*(maxy-miny)
760: */
761: src = bit.map[bit.rid];
762: if(src == 0)
763: error(Ebadbitmap);
764: off = 0;
765: if(bit.rid == 0)
766: off = 1;
767: miny = bit.rminy;
768: maxy = bit.rmaxy;
769: if(miny>maxy || miny<src->r.min.y || maxy>src->r.max.y)
770: error(Ebadblt);
771: ws = 1<<(3-src->ldepth); /* pixels per byte */
772: /* set l to number of bytes of incoming data per scan line */
773: if(src->r.min.x >= 0)
774: l = (src->r.max.x+ws-1)/ws - src->r.min.x/ws;
775: else{ /* make positive before divide */
776: t = (-src->r.min.x)+ws-1;
777: t = (t/ws)*ws;
778: l = (t+src->r.max.x+ws-1)/ws;
779: }
780: if(n < l*(maxy-miny))
781: error(Ebadblt);
782: if(off)
783: cursoroff(1);
784: n = 0;
785: p = va;
786: for(y=miny; y<maxy; y++){
787: q = (uchar*)gaddr(src, Pt(src->r.min.x, y));
788: q += (src->r.min.x&((sizeof(ulong))*ws-1))/ws;
789: memmove(p, q, l);
790: if(islittle)
791: pixreverse(p, l, src->ldepth);
792: if(bit.rid==0 && flipping)
793: /* is screen, so must be word aligned */
794: for(x=0; x<l; x+=sizeof(ulong),p+=sizeof(ulong))
795: *(ulong*)p ^= ~0;
796: else
797: p += l;
798: n += l;
799: }
800: if(off)
801: cursoron(1);
802: bit.rid = -1;
803: }
804:
805: poperror();
806: qunlock(&bit);
807: return n;
808: }
809:
810: Point
811: bitstrsize(GFont *f, uchar *p, int l)
812: {
813: ushort r;
814: Point s = {0,0};
815: GCacheinfo *c;
816:
817: while(l > 0){
818: r = BGSHORT(p);
819: p += 2;
820: l -= 2;
821: if(r >= f->ncache)
822: continue;
823: c = &f->cache[r];
824: if(c->bottom > s.y)
825: s.y = c->bottom;
826: s.x += c->width;
827: }
828: return s;
829: }
830:
831: long
832: bitwrite(Chan *c, void *va, long n, ulong offset)
833: {
834: uchar *p, *q, *oq;
835: long m, v, miny, maxy, t, x, y;
836: ulong l, nw, ws, rv, q0, q1;
837: ulong *lp;
838: int off, isoff, i, j, ok;
839: ulong *endscreen = gaddr(&gscreen, Pt(0, gscreen.r.max.y));
840: Point pt, pt1, pt2;
841: Rectangle rect;
842: Fcode fc;
843: Fontchar *fcp;
844: GBitmap *src, *dst;
845: BSubfont *f, *tf, **fp;
846: GFont *ff, **ffp;
847: GCacheinfo *gc;
848: char buf[64];
849:
850: if(!conf.monitor)
851: error(Egreg);
852: USED(offset);
853:
854: if(c->qid.path == CHDIR)
855: error(Eisdir);
856:
857: if(c->qid.path == Qmousectl){
858: if(n >= sizeof(buf))
859: n = sizeof(buf)-1;
860: strncpy(buf, va, n);
861: buf[n] = 0;
862: mousectl(buf);
863: return n;
864: }
865:
866: if(c->qid.path != Qbitblt)
867: error(Egreg);
868:
869: isoff = 0;
870: qlock(&bit);
871: if(waserror()){
872: qunlock(&bit);
873: if(isoff)
874: cursoron(1);
875: nexterror();
876: }
877: p = va;
878: m = n;
879: SET(src, dst, f, ff);
880: while(m > 0)
881: switch(*p){
882: default:
883: pprint("bitblt request 0x%x\n", *p);
884: error(Ebadblt);
885:
886: case 'a':
887: /*
888: * allocate:
889: * 'a' 1
890: * ldepth 1
891: * Rectangle 16
892: * next read returns allocated bitmap id
893: */
894: if(m < 18)
895: error(Ebadblt);
896: v = *(p+1);
897: if(v > 3) /* BUG */
898: error(Ebadblt);
899: rect.min.x = BGLONG(p+2);
900: rect.min.y = BGLONG(p+6);
901: rect.max.x = BGLONG(p+10);
902: rect.max.y = BGLONG(p+14);
903: if(Dx(rect) < 0 || Dy(rect) < 0)
904: error(Ebadblt);
905: bit.bid = bitalloc(rect, v);
906: m -= 18;
907: p += 18;
908: break;
909:
910: case 'b':
911: /*
912: * bitblt
913: * 'b' 1
914: * dst id 2
915: * dst Point 8
916: * src id 2
917: * src Rectangle 16
918: * code 2
919: */
920: if(m < 31)
921: error(Ebadblt);
922: fc = BGSHORT(p+29) & 0xF;
923: v = BGSHORT(p+11);
924: if(v<0 || v>=bit.nmap || (src=bit.map[v])==0)
925: error(Ebadbitmap);
926: off = 0;
927: if(v == 0){
928: if(flipping)
929: fc = flipS[fc];
930: off = 1;
931: }
932: v = BGSHORT(p+1);
933: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
934: error(Ebadbitmap);
935: if(v == 0){
936: if(flipping)
937: fc = flipD[fc];
938: off = 1;
939: }
940: pt.x = BGLONG(p+3);
941: pt.y = BGLONG(p+7);
942: rect.min.x = BGLONG(p+13);
943: rect.min.y = BGLONG(p+17);
944: rect.max.x = BGLONG(p+21);
945: rect.max.y = BGLONG(p+25);
946: if(off && !isoff){
947: cursoroff(1);
948: isoff = 1;
949: }
950: gbitblt(dst, pt, src, rect, fc);
951: if(dst->base < endscreen)
952: mbbrect(Rpt(pt, add(pt, sub(rect.max, rect.min))));
953: m -= 31;
954: p += 31;
955: break;
956:
957: case 'c':
958: /*
959: * cursorswitch
960: * 'c' 1
961: * if nothing more: return to arrow; else
962: * Point 8
963: * clr 32
964: * set 32
965: */
966: if(m == 1){
967: if(!isoff){
968: cursoroff(1);
969: isoff = 1;
970: }
971: Cursortocursor(&arrow);
972: m -= 1;
973: p += 1;
974: break;
975: }
976: if(m < 73)
977: error(Ebadblt);
978: curs.offset.x = BGLONG(p+1);
979: curs.offset.y = BGLONG(p+5);
980: memmove(curs.clr, p+9, 2*16);
981: memmove(curs.set, p+41, 2*16);
982: if(islittle){
983: pixreverse(curs.clr, 2*16, 0);
984: pixreverse(curs.set, 2*16, 0);
985: }
986: if(!isoff){
987: cursoroff(1);
988: isoff = 1;
989: }
990: Cursortocursor(&curs);
991: m -= 73;
992: p += 73;
993: break;
994:
995: case 'e':
996: /*
997: * polysegment
998: *
999: * 'e' 1
1000: * id 2
1001: * pt 8
1002: * value 1
1003: * code 2
1004: * n 2
1005: * pts 2*n
1006: */
1007: if(m < 16)
1008: error(Ebadblt);
1009: l = BGSHORT(p+14);
1010: if(m < 16+2*l)
1011: error(Ebadblt);
1012: v = BGSHORT(p+1);
1013: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1014: error(Ebadbitmap);
1015: off = 0;
1016: fc = BGSHORT(p+12) & 0xF;
1017: if(v == 0){
1018: if(flipping)
1019: fc = flipD[fc];
1020: off = 1;
1021: }
1022: pt1.x = BGLONG(p+3);
1023: pt1.y = BGLONG(p+7);
1024: t = p[11];
1025: if(off && !isoff){
1026: cursoroff(1);
1027: isoff = 1;
1028: }
1029: p += 16;
1030: m -= 16;
1031: while(l > 0){
1032: pt2.x = pt1.x + (schar)p[0];
1033: pt2.y = pt1.y + (schar)p[1];
1034: gsegment(dst, pt1, pt2, t, fc);
1035: if(dst->base < endscreen){
1036: mbbpt(pt1);
1037: mbbpt(pt2);
1038: }
1039: pt1 = pt2;
1040: p += 2;
1041: m -= 2;
1042: l--;
1043: }
1044: break;
1045:
1046: case 'f':
1047: /*
1048: * free
1049: * 'f' 1
1050: * id 2
1051: */
1052: if(m < 3)
1053: error(Ebadblt);
1054: v = BGSHORT(p+1);
1055: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1056: error(Ebadbitmap);
1057: bitfree(dst);
1058: bit.map[v] = 0;
1059: m -= 3;
1060: p += 3;
1061: break;
1062:
1063: case 'g':
1064: /*
1065: * free subfont
1066: * 'g' 1
1067: * id 2
1068: */
1069: if(m < 3)
1070: error(Ebadblt);
1071: v = BGSHORT(p+1);
1072: if(v<0 || v>=bit.nsubfont || (f=bit.subfont[v])==0 || f->ref==0)
1073: error(Ebadfont);
1074: subfontfree(f, v);
1075: m -= 3;
1076: p += 3;
1077: break;
1078:
1079: case 'h':
1080: /*
1081: * free font
1082: * 'h' 1
1083: * id 2
1084: */
1085: if(m < 3)
1086: error(Ebadblt);
1087: v = BGSHORT(p+1);
1088: if(v<0 || v>=bit.nfont || (ff=bit.font[v])==0)
1089: error(Ebadfont);
1090: fontfree(ff);
1091: bit.font[v] = 0;
1092: m -= 3;
1093: p += 3;
1094: break;
1095:
1096: case 'i':
1097: /*
1098: * init
1099: *
1100: * 'i' 1
1101: */
1102: bit.init = 1;
1103: m -= 1;
1104: p += 1;
1105: break;
1106:
1107: case 'j':
1108: /*
1109: * subfont cache check
1110: *
1111: * 'j' 1
1112: * qid 8
1113: */
1114: if(m < 9)
1115: error(Ebadblt);
1116: q0 = BGLONG(p+1);
1117: q1 = BGLONG(p+5);
1118: i = 0;
1119: if(q0 != ~0)
1120: for(; i<bit.nsubfont; i++){
1121: f = bit.subfont[i];
1122: if(f && f->qid[0]==q0 && f->qid[1]==q1)
1123: goto sfcachefound;
1124: }
1125: error(Esfnotcached);
1126:
1127: sfcachefound:
1128: f->ref++;
1129: bit.cacheid = i;
1130: m -= 9;
1131: p += 9;
1132: break;
1133:
1134: case 'k':
1135: /*
1136: * allocate subfont
1137: * 'k' 1
1138: * n 2
1139: * height 1
1140: * ascent 1
1141: * bitmap id 2
1142: * qid 8
1143: * fontchars 6*(n+1)
1144: * next read returns allocated font id
1145: */
1146: if(m < 15)
1147: error(Ebadblt);
1148: v = BGSHORT(p+1);
1149: if(v<0 || v>NINFO || m<15+6*(v+1))
1150: error(Ebadblt);
1151: for(i=1; i<bit.nsubfont; i++)
1152: if(bit.subfont[i] == 0)
1153: goto subfontfound;
1154: fp = bitmalloc((bit.nsubfont+DMAP)*sizeof(BSubfont*));
1155: if(fp == 0)
1156: error(Enomem);
1157: memmove(fp, bit.subfont, bit.nsubfont*sizeof(BSubfont*));
1158: free(bit.subfont);
1159: bit.subfont = fp;
1160: bit.nsubfont += DMAP;
1161: subfontfound:
1162: f = bitmalloc(sizeof(BSubfont));
1163: if(f == 0)
1164: error(Enomem);
1165: f->info = bitmalloc((v+1)*sizeof(Fontchar));
1166: if(f->info == 0){
1167: free(f);
1168: error(Enomem);
1169: }
1170: bit.subfont[i] = f;
1171: f->n = v;
1172: f->height = p[3];
1173: f->ascent = p[4];
1174: f->qid[0] = BGLONG(p+7);
1175: f->qid[1] = BGLONG(p+11);
1176: /* check to see if already there, uncache if so */
1177: for(j=0; j<bit.nsubfont; j++){
1178: if(j == i)
1179: continue;
1180: tf = bit.subfont[j];
1181: if(tf && tf->qid[0]==f->qid[0] && tf->qid[1]==f->qid[1]){
1182: f->qid[0] = ~0; /* uncached */
1183: break;
1184: }
1185: }
1186: f->ref = 1;
1187: v = BGSHORT(p+5);
1188: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1189: error(Ebadbitmap);
1190: f->bits = dst;
1191: bit.map[v] = 0; /* subfont now owns bitmap */
1192: m -= 15;
1193: p += 15;
1194: fcp = f->info;
1195: for(j=0; j<=f->n; j++,fcp++){
1196: fcp->x = BGSHORT(p);
1197: fcp->top = p[2];
1198: fcp->bottom = p[3];
1199: fcp->left = p[4];
1200: fcp->width = p[5];
1201: fcp->top = p[2];
1202: p += 6;
1203: m -= 6;
1204: }
1205: bit.subfid = i;
1206: break;
1207:
1208: case 'l':
1209: /*
1210: * line segment
1211: *
1212: * 'l' 1
1213: * id 2
1214: * pt1 8
1215: * pt2 8
1216: * value 1
1217: * code 2
1218: */
1219: if(m < 22)
1220: error(Ebadblt);
1221: v = BGSHORT(p+1);
1222: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1223: error(Ebadbitmap);
1224: off = 0;
1225: fc = BGSHORT(p+20) & 0xF;
1226: if(v == 0){
1227: if(flipping)
1228: fc = flipD[fc];
1229: off = 1;
1230: }
1231: pt1.x = BGLONG(p+3);
1232: pt1.y = BGLONG(p+7);
1233: pt2.x = BGLONG(p+11);
1234: pt2.y = BGLONG(p+15);
1235: t = p[19];
1236: if(off && !isoff){
1237: cursoroff(1);
1238: isoff = 1;
1239: }
1240: gsegment(dst, pt1, pt2, t, fc);
1241: if(dst->base < endscreen){
1242: mbbpt(pt1);
1243: mbbpt(pt2);
1244: }
1245: m -= 22;
1246: p += 22;
1247: break;
1248:
1249: case 'm':
1250: /*
1251: * read colormap
1252: *
1253: * 'm' 1
1254: * id 2
1255: */
1256: if(m < 3)
1257: error(Ebadblt);
1258: v = BGSHORT(p+1);
1259: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1260: error(Ebadbitmap);
1261: bit.mid = v;
1262: m -= 3;
1263: p += 3;
1264: break;
1265:
1266: case 'n':
1267: /*
1268: * allocate font
1269: * 'n' 1
1270: * height 1
1271: * ascent 1
1272: * ldepth 2
1273: * ncache 2
1274: * next read returns allocated font id
1275: */
1276: if(m < 7)
1277: error(Ebadblt);
1278: v = BGSHORT(p+3);
1279: t = BGSHORT(p+5);
1280: if(v<0 || t<0)
1281: error(Ebadblt);
1282: for(i=0; i<bit.nfont; i++)
1283: if(bit.font[i] == 0)
1284: goto fontfound;
1285: ffp = bitmalloc((bit.nfont+DMAP)*sizeof(GFont*));
1286: if(ffp == 0)
1287: error(Enomem);
1288: memmove(ffp, bit.font, bit.nfont*sizeof(GFont*));
1289: free(bit.font);
1290: bit.font = ffp;
1291: bit.nfont += DMAP;
1292: fontfound:
1293: ff = bitmalloc(sizeof(GFont));
1294: if(ff == 0)
1295: error(Enomem);
1296: ff->ncache = t;
1297: ff->cache = bitmalloc(t*sizeof(GCacheinfo));
1298: if(ff->cache == 0){
1299: free(ff);
1300: error(Enomem);
1301: }
1302: bit.font[i] = ff;
1303: ff = bit.font[i];
1304: ff->height = p[1];
1305: ff->ascent = p[2];
1306: ff->ldepth = v;
1307: ff->width = 0;
1308: ff->b = 0;
1309: m -= 7;
1310: p += 7;
1311: bit.fid = i;
1312: break;
1313:
1314: case 'p':
1315: /*
1316: * point
1317: *
1318: * 'p' 1
1319: * id 2
1320: * pt 8
1321: * value 1
1322: * code 2
1323: */
1324: if(m < 14)
1325: error(Ebadblt);
1326: v = BGSHORT(p+1);
1327: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1328: error(Ebadbitmap);
1329: off = 0;
1330: fc = BGSHORT(p+12) & 0xF;
1331: if(v == 0){
1332: if(flipping)
1333: fc = flipD[fc];
1334: off = 1;
1335: }
1336: pt1.x = BGLONG(p+3);
1337: pt1.y = BGLONG(p+7);
1338: t = p[11];
1339: if(off && !isoff){
1340: cursoroff(1);
1341: isoff = 1;
1342: }
1343: gpoint(dst, pt1, t, fc);
1344: if(dst->base < endscreen)
1345: mbbpt(pt1);
1346: m -= 14;
1347: p += 14;
1348: break;
1349:
1350: case 'q':
1351: /*
1352: * clip rectangle
1353: * 'q' 1
1354: * id 2
1355: * rect 16
1356: */
1357: if(m < 19)
1358: error(Ebadblt);
1359: v = BGSHORT(p+1);
1360: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1361: error(Ebadbitmap);
1362: rect.min.x = BGLONG(p+3);
1363: rect.min.y = BGLONG(p+7);
1364: rect.max.x = BGLONG(p+11);
1365: rect.max.y = BGLONG(p+15);
1366: if(rectclip(&rect, dst->r))
1367: dst->clipr = rect;
1368: m -= 19;
1369: p += 19;
1370: break;
1371:
1372: case 'r':
1373: /*
1374: * read
1375: * 'r' 1
1376: * src id 2
1377: * miny 4
1378: * maxy 4
1379: */
1380: if(m < 11)
1381: error(Ebadblt);
1382: v = BGSHORT(p+1);
1383: if(v<0 || v>=bit.nmap || (src=bit.map[v])==0)
1384: error(Ebadbitmap);
1385: miny = BGLONG(p+3);
1386: maxy = BGLONG(p+7);
1387: if(miny>maxy || miny<src->r.min.y || maxy>src->r.max.y)
1388: error(Ebadblt);
1389: bit.rid = v;
1390: bit.rminy = miny;
1391: bit.rmaxy = maxy;
1392: p += 11;
1393: m -= 11;
1394: break;
1395:
1396: case 's':
1397: /*
1398: * string
1399: * 's' 1
1400: * id 2
1401: * pt 8
1402: * font id 2
1403: * code 2
1404: * n 2
1405: * cache indices 2*n (not null terminated)
1406: */
1407: if(m < 17)
1408: error(Ebadblt);
1409: v = BGSHORT(p+1);
1410: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1411: error(Ebadbitmap);
1412: off = 0;
1413: fc = BGSHORT(p+13) & 0xF;
1414: if(v == 0){
1415: if(flipping)
1416: fc = flipD[fc];
1417: off = 1;
1418: }
1419: pt.x = BGLONG(p+3);
1420: pt.y = BGLONG(p+7);
1421: v = BGSHORT(p+11);
1422: if(v<0 || v>=bit.nfont || (ff=bit.font[v])==0)
1423: error(Ebadfont);
1424: l = BGSHORT(p+15)*2;
1425: p += 17;
1426: m -= 17;
1427: if(l > m)
1428: error(Ebadblt);
1429: if(off && !isoff){
1430: cursoroff(1);
1431: isoff = 1;
1432: }
1433: bitstring(dst, pt, ff, p, l, fc);
1434: if(dst->base < endscreen)
1435: mbbrect(Rpt(pt, add(pt, bitstrsize(ff, p, l))));
1436: m -= l;
1437: p += l;
1438: break;
1439:
1440: case 't':
1441: /*
1442: * texture
1443: * 't' 1
1444: * dst id 2
1445: * rect 16
1446: * src id 2
1447: * fcode 2
1448: */
1449: if(m < 23)
1450: error(Ebadblt);
1451: v = BGSHORT(p+1);
1452: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1453: error(Ebadbitmap);
1454: off = 0;
1455: fc = BGSHORT(p+21) & 0xF;
1456: if(v == 0){
1457: if(flipping)
1458: fc = flipD[fc];
1459: off = 1;
1460: }
1461: rect.min.x = BGLONG(p+3);
1462: rect.min.y = BGLONG(p+7);
1463: rect.max.x = BGLONG(p+11);
1464: rect.max.y = BGLONG(p+15);
1465: v = BGSHORT(p+19);
1466: if(v<0 || v>=bit.nmap || (src=bit.map[v])==0)
1467: error(Ebadbitmap);
1468: if(off && !isoff){
1469: cursoroff(1);
1470: isoff = 1;
1471: }
1472: gtexture(dst, rect, src, fc);
1473: if(dst->base < endscreen)
1474: mbbrect(rect);
1475: m -= 23;
1476: p += 23;
1477: break;
1478:
1479: case 'v':
1480: /*
1481: * clear font cache and bitmap.
1482: * if error, font is unchanged.
1483: * 'v' 1
1484: * id 2
1485: * ncache 2
1486: * width 2
1487: */
1488: if(m < 7)
1489: error(Ebadblt);
1490: v = BGSHORT(p+1);
1491: t = BGSHORT(p+3);
1492: if(t<0 || v<0 || v>=bit.nfont || (ff=bit.font[v])==0)
1493: error(Ebadblt);
1494: x = BGSHORT(p+5);
1495: i = bitalloc(Rect(0, 0, t*x, ff->height), ff->ldepth);
1496: if(t != ff->ncache){
1497: gc = bitmalloc(t*sizeof(ff->cache[0]));
1498: if(gc == 0){
1499: bitfree(bit.map[i]);
1500: bit.map[i] = 0;
1501: error(Enomem);
1502: }
1503: free(ff->cache);
1504: ff->cache = gc;
1505: ff->ncache = t;
1506: }else{
1507: /*
1508: * memset not necessary but helps avoid
1509: * confusion if the cache is mishandled by the
1510: * user.
1511: */
1512: memset(ff->cache, 0, t*sizeof(ff->cache[0]));
1513: }
1514: if(ff->b)
1515: bitfree(ff->b);
1516: ff->b = bit.map[i];
1517: bit.map[i] = 0; /* disconnect it from GBitmap space */
1518: ff->width = x;
1519: p += 7;
1520: m -= 7;
1521: break;
1522:
1523: case 'w':
1524: /*
1525: * write
1526: * 'w' 1
1527: * dst id 2
1528: * miny 4
1529: * maxy 4
1530: * data bytewidth*(maxy-miny)
1531: */
1532: if(m < 11)
1533: error(Ebadblt);
1534: v = BGSHORT(p+1);
1535: if(v<0 || v>=bit.nmap || (dst=bit.map[v])==0)
1536: error(Ebadbitmap);
1537: off = 0;
1538: if(v == 0)
1539: off = 1;
1540: miny = BGLONG(p+3);
1541: maxy = BGLONG(p+7);
1542: if(miny>maxy || miny<dst->r.min.y || maxy>dst->r.max.y)
1543: error(Ebadblt);
1544: ws = 1<<(3-dst->ldepth); /* pixels per byte */
1545: /* set l to number of bytes of incoming data per scan line */
1546: if(dst->r.min.x >= 0)
1547: l = (dst->r.max.x+ws-1)/ws - dst->r.min.x/ws;
1548: else{ /* make positive before divide */
1549: t = (-dst->r.min.x)+ws-1;
1550: t = (t/ws)*ws;
1551: l = (t+dst->r.max.x+ws-1)/ws;
1552: }
1553: if(dst->base < endscreen)
1554: mbbrect(Rect(dst->r.min.x, miny, dst->r.max.x, maxy));
1555: p += 11;
1556: m -= 11;
1557: if(m < l*(maxy-miny))
1558: error(Ebadblt);
1559: if(off && !isoff){
1560: cursoroff(1);
1561: isoff = 1;
1562: }
1563: for(y=miny; y<maxy; y++){
1564: oq = (uchar*)gaddr(dst, Pt(dst->r.min.x, y));
1565: q = oq + (dst->r.min.x&((sizeof(ulong))*ws-1))/ws;
1566: memmove(q, p, l);
1567: if(islittle)
1568: pixreverse(q, l, dst->ldepth);
1569: if(v==0 && flipping){ /* flip bits */
1570: /* we know it's all word aligned */
1571: lp = (ulong*)oq;
1572: for(x=0; x<l; x+=sizeof(ulong))
1573: *lp++ ^= ~0;
1574: }
1575: p += l;
1576: m -= l;
1577: }
1578: if(v == 0)
1579: hwscreenwrite(miny, maxy);
1580: break;
1581:
1582: case 'x':
1583: /*
1584: * cursorset
1585: *
1586: * 'x' 1
1587: * pt 8
1588: */
1589: if(m < 9)
1590: error(Ebadblt);
1591: pt1.x = BGLONG(p+1);
1592: pt1.y = BGLONG(p+5);
1593: if(ptinrect(pt1, gscreen.r)){
1594: mouse.xy = pt1;
1595: mouse.redraw = 1;
1596: mouse.track = 1;
1597: mouseclock();
1598: }
1599: m -= 9;
1600: p += 9;
1601: break;
1602:
1603: case 'y':
1604: /*
1605: * load font from subfont
1606: * 'y' 1
1607: * id 2
1608: * cache index 2
1609: * subfont id 2
1610: * subfont index 2
1611: */
1612: if(m < 9)
1613: error(Ebadblt);
1614: v = BGSHORT(p+1);
1615: if(v<0 || v>=bit.nfont || (ff=bit.font[v])==0)
1616: error(Ebadblt);
1617: if(ff->b == 0)
1618: error(Ebadbitmap);
1619: l = BGSHORT(p+3);
1620: if(l >= ff->ncache)
1621: error(Ebadblt);
1622: v = BGSHORT(p+5);
1623: if(v<0 || v>=bit.nsubfont || (f=bit.subfont[v])==0 || f->ref==0)
1624: error(Ebadfont);
1625: nw = BGSHORT(p+7);
1626: if(nw >= f->n)
1627: error(Ebadblt);
1628: bitloadchar(ff, l, f, nw);
1629: p += 9;
1630: m -= 9;
1631: break;
1632:
1633: case 'z':
1634: /*
1635: * write the colormap
1636: *
1637: * 'z' 1
1638: * id 2
1639: * map 12*(2**bitmapdepth)
1640: */
1641: if(m < 3)
1642: error(Ebadblt);
1643: v = BGSHORT(p+1);
1644: if(v != 0)
1645: error(Ebadbitmap);
1646: m -= 3;
1647: p += 3;
1648: nw = 1 << (1 << gscreen.ldepth);
1649: if(m < 12*nw)
1650: error(Ebadblt);
1651: ok = 1;
1652: for(i = 0; i < nw; i++){
1653: ok &= setcolor(flipping ? ~i : i, BGLONG(p), BGLONG(p+4), BGLONG(p+8));
1654: p += 12;
1655: m -= 12;
1656: }
1657: if(!ok){
1658: /* assume monochrome: possibly change flipping */
1659: l = BGLONG(p-12);
1660: getcolor(nw-1, &rv, &rv, &rv);
1661: flipping = (l != rv);
1662: }
1663: break;
1664: }
1665:
1666: poperror();
1667: if(isoff)
1668: cursoron(1);
1669: screenupdate();
1670: qunlock(&bit);
1671: return n;
1672: }
1673:
1674: int
1675: bitalloc(Rectangle rect, int ld)
1676: {
1677: Arena *a, *ea, *aa;
1678: GBitmap *b, **bp, **ep;
1679: ulong l, ws, nw;
1680: long t;
1681:
1682: ws = BI2WD>>ld; /* pixels per word */
1683: if(rect.min.x >= 0){
1684: l = (rect.max.x+ws-1)/ws;
1685: l -= rect.min.x/ws;
1686: }else{ /* make positive before divide */
1687: t = (-rect.min.x)+ws-1;
1688: t = (t/ws)*ws;
1689: l = (t+rect.max.x+ws-1)/ws;
1690: }
1691: nw = l*Dy(rect);
1692: ea = &bit.arena[bit.narena];
1693:
1694: /* first try easy fit */
1695: for(a=bit.arena; a<ea; a++){
1696: if(a->words == 0)
1697: continue;
1698: if(a->wfree+HDR+nw <= a->words+a->nwords)
1699: goto found;
1700: }
1701:
1702: /* compact and try again */
1703: bitcompact();
1704: aa = 0;
1705: for(a=bit.arena; a<ea; a++){
1706: if(a->words == 0){
1707: if(aa == 0)
1708: aa = a;
1709: continue;
1710: }
1711: if(a->wfree+HDR+nw <= a->words+a->nwords)
1712: goto found;
1713: }
1714:
1715: /* need new arena */
1716: if(aa){
1717: a = aa;
1718: a->nwords = HDR + (gscreen.r.max.y*gscreen.r.max.x)/ws;
1719: if(a->nwords < HDR+nw)
1720: a->nwords = HDR+nw;
1721: a->words = xalloc(a->nwords*sizeof(ulong));
1722: if(a->words){
1723: a->wfree = a->words;
1724: a->nbusy = 0;
1725: goto found;
1726: }
1727: }
1728: /* else can't grow list: bitmaps have backpointers */
1729:
1730: bitfreeup();
1731:
1732: for(a=bit.arena; a<ea; a++){
1733: if(a->words == 0)
1734: continue;
1735: if(a->wfree+HDR+nw <= a->words+a->nwords)
1736: goto found;
1737: }
1738: if(a == ea)
1739: error(Enobitstore);
1740:
1741: found:
1742: b = bitmalloc(sizeof(GBitmap));
1743: if(b == 0)
1744: error(Enomem);
1745: *a->wfree++ = nw;
1746: *a->wfree++ = (ulong)a;
1747: *a->wfree++ = (ulong)b;
1748: memset(a->wfree, 0, nw*sizeof(ulong));
1749: b->base = a->wfree;
1750: a->wfree += nw;
1751: a->nbusy++;
1752: b->zero = l*rect.min.y;
1753: if(rect.min.x >= 0)
1754: b->zero += rect.min.x/ws;
1755: else
1756: b->zero -= (-rect.min.x+ws-1)/ws;
1757: b->zero = -b->zero;
1758: b->width = l;
1759: b->ldepth = ld;
1760: b->r = rect;
1761: b->clipr = rect;
1762: b->cache = 0;
1763: /* worth doing better than linear lookup? */
1764: ep = bit.map+bit.nmap;
1765: for(bp=bit.map; bp<ep; bp++)
1766: if(*bp == 0)
1767: break;
1768: if(bp == ep){
1769: bp = bitmalloc((bit.nmap+DMAP)*sizeof(GBitmap*));
1770: if(bp == 0){
1771: bitfree(b);
1772: error(Enomem);
1773: }
1774: memmove(bp, bit.map, bit.nmap*sizeof(GBitmap*));
1775: free(bit.map);
1776: bit.map = bp;
1777: bp += bit.nmap;
1778: bit.nmap += DMAP;
1779: }
1780: *bp = b;
1781: return bp-bit.map;
1782: }
1783:
1784: void
1785: bitfree(GBitmap *b)
1786: {
1787: Arena *a;
1788:
1789: if(b->base != gscreen.base){ /* can't free screen memory */
1790: a = (Arena*)(b->base[-2]);
1791: a->nbusy--;
1792: if(a->nbusy == 0)
1793: arenafree(a);
1794: b->base[-1] = 0;
1795: }
1796: free(b);
1797: }
1798:
1799: void
1800: fontfree(GFont *f)
1801: {
1802: if(f->b)
1803: bitfree(f->b);
1804: free(f->cache);
1805: free(f);
1806: }
1807:
1808: void
1809: subfontfree(BSubfont *s, int i)
1810: {
1811: if(s!=bdefont && s->ref>0){ /* don't free subfont 0, bdefont */
1812: s->ref--;
1813: if(s->ref==0 && s->qid[0]==~0){ /* uncached */
1814: bitfree(s->bits);
1815: free(s->info);
1816: free(s);
1817: bit.subfont[i] = 0;
1818: }
1819: }
1820: return;
1821: }
1822:
1823: void
1824: arenafree(Arena *a)
1825: {
1826: xfree(a->words);
1827: a->words = 0;
1828: }
1829:
1830: void
1831: bitstring(GBitmap *bp, Point pt, GFont *f, uchar *p, long l, Fcode fc)
1832: {
1833: int full;
1834: Rectangle rect;
1835: ushort r;
1836: GCacheinfo *c;
1837: int x;
1838: Fcode clr;
1839:
1840: clr = 0;
1841: full = (fc&~S)^(D&~S); /* result involves source */
1842: if(full){
1843: rect.min.y = 0;
1844: rect.max.y = f->height;
1845: /* set clr to result under fc if source pixel is zero */
1846: /* hard to do without knowing layout of bits, so we cheat */
1847: clr = (fc&3); /* fc&3 is result if source is zero */
1848: clr |= clr<<2; /* fc&(3<<2) is result if source is one */
1849: }
1850:
1851: while(l > 0){
1852: r = BGSHORT(p);
1853: p += 2;
1854: l -= 2;
1855: if(r >= f->ncache)
1856: continue;
1857: c = &f->cache[r];
1858: if(!full){
1859: rect.min.y = c->top;
1860: rect.max.y = c->bottom;
1861: }else{
1862: if(c->left > 0)
1863: gbitblt(bp, pt, bp,
1864: Rect(pt.x, pt.y, pt.x+c->left, pt.y+f->height),
1865: clr);
1866: x = c->left+(c->xright-c->x);
1867: if(x < c->width)
1868: gbitblt(bp, Pt(pt.x+x, pt.y), bp,
1869: Rect(pt.x+x, pt.y, pt.x+c->width, pt.y+f->height),
1870: clr);
1871: }
1872: rect.min.x = c->x;
1873: rect.max.x = c->xright;
1874: gbitblt(bp, Pt(pt.x+c->left, pt.y+rect.min.y), f->b, rect, fc);
1875: pt.x += c->width;
1876: }
1877: }
1878:
1879: void
1880: bitloadchar(GFont *f, int ci, GSubfont *subf, int si)
1881: {
1882: GCacheinfo *c;
1883: Rectangle rect;
1884: Fontchar *fi;
1885: int y;
1886:
1887: c = &f->cache[ci];
1888: fi = &subf->info[si];
1889: /* careful about sign extension: top and bottom are uchars */
1890: y = fi->top + (f->ascent-subf->ascent);
1891: if(y < 0)
1892: y = 0;
1893: c->top = y;
1894: y = fi->bottom + (f->ascent-subf->ascent);
1895: if(y < 0)
1896: y = 0;
1897: c->bottom = y;
1898: c->width = fi->width;
1899: c->left = fi->left;
1900: c->x = ci*f->width;
1901: c->xright = c->x + ((fi+1)->x - fi->x);
1902: rect.min.y = 0;
1903: rect.max.y = f->height;
1904: rect.min.x = c->x;
1905: rect.max.x = c->x+f->width;
1906: gbitblt(f->b, rect.min, f->b, rect, 0);
1907: rect.min.x = fi->x;
1908: rect.max.x = (fi+1)->x;
1909: rect.max.y = subf->height;
1910: gbitblt(f->b, Pt(c->x, f->ascent-subf->ascent), subf->bits, rect, S);
1911: }
1912:
1913: QLock bitlock;
1914:
1915: GBitmap*
1916: id2bit(int v)
1917: {
1918: GBitmap *bp=0;
1919:
1920: if(v<0 || v>=bit.nmap || (bp=bit.map[v])==0)
1921: error(Ebadbitmap);
1922: return bp;
1923: }
1924:
1925: void
1926: bitcompact(void)
1927: {
1928: Arena *a, *ea, *na;
1929: ulong *p1, *p2, n;
1930:
1931: qlock(&bitlock);
1932: ea = &bit.arena[bit.narena];
1933: for(a=bit.arena; a<ea; a++){
1934: if(a->words == 0)
1935: continue;
1936: /* first compact what's here */
1937: p1 = p2 = a->words;
1938: while(p2 < a->wfree){
1939: n = HDR+p2[0];
1940: if(p2[2] == 0){
1941: p2 += n;
1942: continue;
1943: }
1944: if(p1 != p2){
1945: memmove(p1, p2, n*sizeof(ulong));
1946: ((GBitmap*)p1[2])->base = p1+HDR;
1947: }
1948: p2 += n;
1949: p1 += n;
1950: }
1951: /* now pull stuff from later arena to fill this one */
1952: na = a+1;
1953: while(na<ea && p1<a->words+a->nwords){
1954: p2 = na->words;
1955: if(p2 == 0){
1956: na++;
1957: continue;
1958: }
1959: while(p2 < na->wfree){
1960: n = HDR+p2[0];
1961: if(p2[2] == 0){
1962: p2 += n;
1963: continue;
1964: }
1965: if(p1+n < a->words+a->nwords){
1966: memmove(p1, p2, n*sizeof(ulong));
1967: ((GBitmap*)p1[2])->base = p1+HDR;
1968: /* block now in new arena... */
1969: p1[1] = (ulong)a;
1970: a->nbusy++;
1971: /* ... not in old arena */
1972: na->nbusy--;
1973: p2[2] = 0;
1974: p1 += n;
1975: }
1976: p2 += n;
1977: }
1978: na++;
1979: }
1980: a->wfree = p1;
1981: }
1982: for(a=bit.arena; a<ea; a++)
1983: if(a->words && a->nbusy==0)
1984: arenafree(a);
1985: qunlock(&bitlock);
1986: }
1987:
1988: void
1989: Cursortocursor(Cursor *c)
1990: {
1991: lock(&cursor);
1992: memmove(&cursor, c, sizeof(Cursor));
1993: setcursor(c);
1994: unlock(&cursor);
1995: }
1996:
1997: int
1998: cursoron(int dolock)
1999: {
2000: int ret;
2001:
2002: if(dolock)
2003: lock(&cursor);
2004: ret = 0;
2005: if(hwcurs)
2006: ret = hwgcmove(mouse.xy);
2007: else if(cursor.visible++ == 0){
2008: cursor.r.min = mouse.xy;
2009: cursor.r.max = add(mouse.xy, Pt(16, 16));
2010: cursor.r = raddp(cursor.r, cursor.offset);
2011: gbitblt(&cursorback, Pt(0, 0), &gscreen, cursor.r, S);
2012: gbitblt(&gscreen, cursor.r.min,
2013: &clr, Rect(0, 0, 16, 16), flipping? flipD[D&~S] : D&~S);
2014: gbitblt(&gscreen, cursor.r.min,
2015: &set, Rect(0, 0, 16, 16), flipping? flipD[S|D] : S|D);
2016: mbbrect(cursor.r);
2017: }
2018: if(dolock)
2019: unlock(&cursor);
2020:
2021: return ret;
2022: }
2023:
2024: void
2025: cursoroff(int dolock)
2026: {
2027: if(hwcurs)
2028: return;
2029: if(dolock)
2030: lock(&cursor);
2031: if(--cursor.visible == 0) {
2032: gbitblt(&gscreen, cursor.r.min, &cursorback, Rect(0, 0, 16, 16), S);
2033: mbbrect(cursor.r);
2034: mousescreenupdate();
2035: }
2036: if(dolock)
2037: unlock(&cursor);
2038: }
2039:
2040: /*
2041: * called by the clock routine to redraw the cursor
2042: */
2043: void
2044: mouseclock(void)
2045: {
2046: if(mouse.track){
2047: mousetrack(mouse.buttons, mouse.dx, mouse.dy);
2048: mouse.track = 0;
2049: mouse.dx = 0;
2050: mouse.dy = 0;
2051: }
2052: if(mouse.redraw && canlock(&cursor)){
2053: mouse.redraw = 0;
2054: cursoroff(0);
2055: mouse.redraw = cursoron(0);
2056: mousescreenupdate();
2057: unlock(&cursor);
2058: }
2059: }
2060:
2061: /*
2062: * called at interrupt level to update the structure and
2063: * awaken any waiting procs.
2064: */
2065: void
2066: mousetrack(int b, int dx, int dy)
2067: {
2068: int x, y;
2069:
2070: x = mouse.xy.x + dx;
2071: if(x < gscreen.r.min.x)
2072: x = gscreen.r.min.x;
2073: if(x >= gscreen.r.max.x)
2074: x = gscreen.r.max.x;
2075: y = mouse.xy.y + dy;
2076: if(y < gscreen.r.min.y)
2077: y = gscreen.r.min.y;
2078: if(y >= gscreen.r.max.y)
2079: y = gscreen.r.max.y;
2080: mouse.counter++;
2081: mouse.xy = Pt(x, y);
2082: mouse.buttons = b;
2083: mouse.redraw = 1;
2084: wakeup(&mouse.r);
2085: }
2086:
2087: /*
2088: * microsoft 3 button, 7 bit bytes
2089: *
2090: * byte 0 - 1 L R Y7 Y6 X7 X6
2091: * byte 1 - 0 X5 X4 X3 X2 X1 X0
2092: * byte 2 - 0 Y5 Y4 Y3 Y2 Y1 Y0
2093: * byte 3 - 0 M x x x x x (optional)
2094: *
2095: * shift & right button is the same as middle button (for 2 button mice)
2096: */
2097: int
2098: m3mouseputc(IOQ *q, int c)
2099: {
2100: static uchar msg[3];
2101: static int nb;
2102: static int middle;
2103: static uchar b[] = { 0, 4, 1, 5, 0, 2, 1, 5 };
2104: short x;
2105: int dx, dy, newbuttons;
2106:
2107: USED(q);
2108: /*
2109: * check bit 6 for consistency
2110: */
2111: if(nb==0){
2112: if((c&0x40) == 0){
2113: /* an extra byte gets sent for the middle button */
2114: middle = (c&0x20) ? 2 : 0;
2115: newbuttons = (mouse.buttons & ~2) | middle;
2116: mousetrack(newbuttons, 0, 0);
2117: return 0;
2118: }
2119: }
2120: msg[nb] = c;
2121: if(++nb == 3){
2122: nb = 0;
2123: newbuttons = middle | b[(msg[0]>>4)&3 | (mouseshifted ? 4 : 0)];
2124: x = (msg[0]&0x3)<<14;
2125: dx = (x>>8) | msg[1];
2126: x = (msg[0]&0xc)<<12;
2127: dy = (x>>8) | msg[2];
2128: mousetrack(newbuttons, dx, dy);
2129: }
2130: return 0;
2131: }
2132:
2133: /*
2134: * Logitech 5 byte packed binary mouse format, 8 bit bytes
2135: *
2136: * shift & right button is the same as middle button (for 2 button mice)
2137: */
2138: int
2139: mouseputc(IOQ *q, int c)
2140: {
2141: static short msg[5];
2142: static int nb;
2143: static uchar b[] = {0, 4, 2, 6, 1, 5, 3, 7, 0, 2, 2, 6, 1, 5, 3, 7};
2144: int dx, dy, newbuttons;
2145:
2146: USED(q);
2147: if((c&0xF0) == 0x80)
2148: nb=0;
2149: msg[nb] = c;
2150: if(c & 0x80)
2151: msg[nb] |= ~0xFF; /* sign extend */
2152: if(++nb == 5){
2153: newbuttons = b[((msg[0]&7)^7) | (mouseshifted ? 8 : 0)];
2154: dx = msg[1]+msg[3];
2155: dy = -(msg[2]+msg[4]);
2156: mousetrack(newbuttons, dx, dy);
2157: nb = 0;
2158: }
2159: return 0;
2160: }
2161:
2162: int
2163: mousechanged(void *m)
2164: {
2165: USED(m);
2166: return mouse.lastcounter != mouse.counter;
2167: }
2168:
2169: /*
2170: * reverse pixels into little endian order
2171: */
2172: uchar revtab0[] = {
2173: 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
2174: 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
2175: 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
2176: 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
2177: 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
2178: 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
2179: 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
2180: 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
2181: 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
2182: 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
2183: 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
2184: 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
2185: 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
2186: 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
2187: 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
2188: 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
2189: 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
2190: 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
2191: 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
2192: 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
2193: 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
2194: 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
2195: 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
2196: 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
2197: 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
2198: 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
2199: 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
2200: 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
2201: 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
2202: 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
2203: 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
2204: 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
2205: };
2206: uchar revtab1[] = {
2207: 0x00, 0x40, 0x80, 0xc0, 0x10, 0x50, 0x90, 0xd0,
2208: 0x20, 0x60, 0xa0, 0xe0, 0x30, 0x70, 0xb0, 0xf0,
2209: 0x04, 0x44, 0x84, 0xc4, 0x14, 0x54, 0x94, 0xd4,
2210: 0x24, 0x64, 0xa4, 0xe4, 0x34, 0x74, 0xb4, 0xf4,
2211: 0x08, 0x48, 0x88, 0xc8, 0x18, 0x58, 0x98, 0xd8,
2212: 0x28, 0x68, 0xa8, 0xe8, 0x38, 0x78, 0xb8, 0xf8,
2213: 0x0c, 0x4c, 0x8c, 0xcc, 0x1c, 0x5c, 0x9c, 0xdc,
2214: 0x2c, 0x6c, 0xac, 0xec, 0x3c, 0x7c, 0xbc, 0xfc,
2215: 0x01, 0x41, 0x81, 0xc1, 0x11, 0x51, 0x91, 0xd1,
2216: 0x21, 0x61, 0xa1, 0xe1, 0x31, 0x71, 0xb1, 0xf1,
2217: 0x05, 0x45, 0x85, 0xc5, 0x15, 0x55, 0x95, 0xd5,
2218: 0x25, 0x65, 0xa5, 0xe5, 0x35, 0x75, 0xb5, 0xf5,
2219: 0x09, 0x49, 0x89, 0xc9, 0x19, 0x59, 0x99, 0xd9,
2220: 0x29, 0x69, 0xa9, 0xe9, 0x39, 0x79, 0xb9, 0xf9,
2221: 0x0d, 0x4d, 0x8d, 0xcd, 0x1d, 0x5d, 0x9d, 0xdd,
2222: 0x2d, 0x6d, 0xad, 0xed, 0x3d, 0x7d, 0xbd, 0xfd,
2223: 0x02, 0x42, 0x82, 0xc2, 0x12, 0x52, 0x92, 0xd2,
2224: 0x22, 0x62, 0xa2, 0xe2, 0x32, 0x72, 0xb2, 0xf2,
2225: 0x06, 0x46, 0x86, 0xc6, 0x16, 0x56, 0x96, 0xd6,
2226: 0x26, 0x66, 0xa6, 0xe6, 0x36, 0x76, 0xb6, 0xf6,
2227: 0x0a, 0x4a, 0x8a, 0xca, 0x1a, 0x5a, 0x9a, 0xda,
2228: 0x2a, 0x6a, 0xaa, 0xea, 0x3a, 0x7a, 0xba, 0xfa,
2229: 0x0e, 0x4e, 0x8e, 0xce, 0x1e, 0x5e, 0x9e, 0xde,
2230: 0x2e, 0x6e, 0xae, 0xee, 0x3e, 0x7e, 0xbe, 0xfe,
2231: 0x03, 0x43, 0x83, 0xc3, 0x13, 0x53, 0x93, 0xd3,
2232: 0x23, 0x63, 0xa3, 0xe3, 0x33, 0x73, 0xb3, 0xf3,
2233: 0x07, 0x47, 0x87, 0xc7, 0x17, 0x57, 0x97, 0xd7,
2234: 0x27, 0x67, 0xa7, 0xe7, 0x37, 0x77, 0xb7, 0xf7,
2235: 0x0b, 0x4b, 0x8b, 0xcb, 0x1b, 0x5b, 0x9b, 0xdb,
2236: 0x2b, 0x6b, 0xab, 0xeb, 0x3b, 0x7b, 0xbb, 0xfb,
2237: 0x0f, 0x4f, 0x8f, 0xcf, 0x1f, 0x5f, 0x9f, 0xdf,
2238: 0x2f, 0x6f, 0xaf, 0xef, 0x3f, 0x7f, 0xbf, 0xff,
2239: };
2240: uchar revtab2[] = {
2241: 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
2242: 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
2243: 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
2244: 0x81, 0x91, 0xa1, 0xb1, 0xc1, 0xd1, 0xe1, 0xf1,
2245: 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
2246: 0x82, 0x92, 0xa2, 0xb2, 0xc2, 0xd2, 0xe2, 0xf2,
2247: 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
2248: 0x83, 0x93, 0xa3, 0xb3, 0xc3, 0xd3, 0xe3, 0xf3,
2249: 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
2250: 0x84, 0x94, 0xa4, 0xb4, 0xc4, 0xd4, 0xe4, 0xf4,
2251: 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
2252: 0x85, 0x95, 0xa5, 0xb5, 0xc5, 0xd5, 0xe5, 0xf5,
2253: 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
2254: 0x86, 0x96, 0xa6, 0xb6, 0xc6, 0xd6, 0xe6, 0xf6,
2255: 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
2256: 0x87, 0x97, 0xa7, 0xb7, 0xc7, 0xd7, 0xe7, 0xf7,
2257: 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
2258: 0x88, 0x98, 0xa8, 0xb8, 0xc8, 0xd8, 0xe8, 0xf8,
2259: 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
2260: 0x89, 0x99, 0xa9, 0xb9, 0xc9, 0xd9, 0xe9, 0xf9,
2261: 0x0a, 0x1a, 0x2a, 0x3a, 0x4a, 0x5a, 0x6a, 0x7a,
2262: 0x8a, 0x9a, 0xaa, 0xba, 0xca, 0xda, 0xea, 0xfa,
2263: 0x0b, 0x1b, 0x2b, 0x3b, 0x4b, 0x5b, 0x6b, 0x7b,
2264: 0x8b, 0x9b, 0xab, 0xbb, 0xcb, 0xdb, 0xeb, 0xfb,
2265: 0x0c, 0x1c, 0x2c, 0x3c, 0x4c, 0x5c, 0x6c, 0x7c,
2266: 0x8c, 0x9c, 0xac, 0xbc, 0xcc, 0xdc, 0xec, 0xfc,
2267: 0x0d, 0x1d, 0x2d, 0x3d, 0x4d, 0x5d, 0x6d, 0x7d,
2268: 0x8d, 0x9d, 0xad, 0xbd, 0xcd, 0xdd, 0xed, 0xfd,
2269: 0x0e, 0x1e, 0x2e, 0x3e, 0x4e, 0x5e, 0x6e, 0x7e,
2270: 0x8e, 0x9e, 0xae, 0xbe, 0xce, 0xde, 0xee, 0xfe,
2271: 0x0f, 0x1f, 0x2f, 0x3f, 0x4f, 0x5f, 0x6f, 0x7f,
2272: 0x8f, 0x9f, 0xaf, 0xbf, 0xcf, 0xdf, 0xef, 0xff,
2273: };
2274:
2275: void
2276: pixreverse(uchar *p, int len, int ldepth)
2277: {
2278: uchar *e;
2279: uchar *tab;
2280:
2281: switch(ldepth){
2282: case 0:
2283: tab = revtab0;
2284: break;
2285: case 1:
2286: tab = revtab1;
2287: break;
2288: case 2:
2289: tab = revtab2;
2290: break;
2291: default:
2292: return;
2293: }
2294:
2295: for(e = p + len; p < e; p++)
2296: *p = tab[*p];
2297: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.