Return to pfb.c CVS log

Up to [Research Unix] / researchv10no / cmd / pico

Annotation of researchv10no/cmd/pico/pfb.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <fb.h>
        !             3: #include "pico.h"
        !             4: 
        !             5: extern short   CURSCRATCH, CUROLD;
        !             6: extern struct  SRC src[MANY];
        !             7: extern char    frameb, metheus;
        !             8: extern int     DEF_LL, DEF_NL;
        !             9: 
        !            10: fbreg  G;      /* place holder (68 bytes) */
        !            11: fbreg *F = &G; /* initial value */
        !            12: int delay=0;
        !            13: 
        !            14: #define Delay  delay+=2
        !            15: 
        !            16: fbsnore()
        !            17: {      int it;
        !            18:        if (!frameb) return;
        !            19:        if((it=open("/dev/iti0", 2))<0 || ioctl(it, ITIADDR, &fb.addr)<0)
        !            20:        {       fprintf(stderr, "pico: cannot open framebuffer\n");
        !            21:                frameb = 0;
        !            22:        } else
        !            23:        {       fb.fd = it;
        !            24:                F=fb.addr;
        !            25:        }
        !            26: }
        !            27: 
        !            28: closefb()
        !            29: {      close(fb.fd);
        !            30: }
        !            31: 
        !            32: fbputitall(k)
        !            33: {      register fbreg *f=F;
        !            34:        register unsigned char *pr, *pg, *pb;
        !            35:        struct SRC *from = &src[k];
        !            36:        register int j, ex = from->sx + from->ex;
        !            37:        int i, offset, delta, sx = from->sx;
        !            38:        int sy = from->sy, ey = from->sy + from->ey;
        !            39: 
        !            40:        if (!frameb) return;
        !            41: 
        !            42:        offset = sy*DEF_LL + sx;
        !            43:        delta  = DEF_LL - ex + sx;
        !            44: 
        !            45:        pr = from->pixred+offset;
        !            46:        pg = from->pixgrn+offset;
        !            47:        pb = from->pixblu+offset;
        !            48: 
        !            49:        f->red.csr=f->grn.csr=f->blu.csr=F_IXW;
        !            50: 
        !            51:        switch (from->nchan)
        !            52:        {       case 1:
        !            53:                        for (i = sy; i < ey; i++, pr+=delta)
        !            54:                        {       f->red.x=f->grn.x=f->blu.x=sx;
        !            55:                                f->red.y=f->grn.y=f->blu.y=i;
        !            56:                                for (j = sx; j < ex; j++)
        !            57:                                {       f->red.z=f->grn.z=f->blu.z= (*pr++);
        !            58:                                        Delay;
        !            59:                                }
        !            60:                        }
        !            61:                        break;
        !            62:                case 4:
        !            63:                case 3:
        !            64:                        for (i = sy; i < ey; i++, pr+=delta, pg+=delta, pb+=delta)
        !            65:                        {       f->red.x=f->grn.x=f->blu.x=sx;
        !            66:                                f->red.y=f->grn.y=f->blu.y=i;
        !            67:                                for (j = sx; j < ex; j++)
        !            68:                                {       f->red.z=*pr++; Delay;
        !            69:                                        f->grn.z=*pg++; Delay;
        !            70:                                        f->blu.z=*pb++; Delay;
        !            71:                        }       }
        !            72:                        break;
        !            73:                default:
        !            74:                        fprintf(stderr, "undefined number of channels\n");
        !            75:                        break;
        !            76:                }
        !            77: }
        !            78: 
        !            79: fbgetitall(from)
        !            80:        struct SRC *from;
        !            81: {
        !            82:        register fbreg *f=F;
        !            83:        register unsigned char *pr, *pg, *pb;
        !            84:        register int j, ex = from->sx + from->ex;
        !            85:        int i, offset, delta, sx = from->sx;
        !            86:        int sy = from->sy, ey = from->sy + from->ey;
        !            87: 
        !            88:        if (!frameb) yyerror("framebuffer is not open");
        !            89: 
        !            90:        if (from == Old)
        !            91:                fprintf(stderr, "reading screen...");
        !            92: 
        !            93:        offset = sy*DEF_LL + sx;
        !            94:        delta  = DEF_LL - ex + sx;
        !            95: 
        !            96:        pr = from->pixred+offset;
        !            97:        pg = from->pixgrn+offset;
        !            98:        pb = from->pixblu+offset;
        !            99: 
        !           100:        f->red.csr=f->blu.csr=f->grn.csr=F_IXR;
        !           101: 
        !           102:        switch (from->nchan)
        !           103:        {       case 1:
        !           104:                        for (i = sy; i < ey; i++, pr+=delta, pg+=delta, pb+=delta)
        !           105:                        {       f->red.x=f->grn.x=f->blu.x=sx;
        !           106:                                f->red.y=f->grn.y=f->blu.y=i;
        !           107:                                for (j = sx; j < ex; j++)
        !           108:                                {       *pg = *pb = *pr = f->grn.z; Delay;
        !           109:                                        pg++; pb++; pr++;
        !           110:                                }
        !           111:                        }
        !           112:                        break;
        !           113:                case 4:
        !           114:                case 3:
        !           115:                        for (i = sy; i < ey; i++, pr+=delta, pg+=delta, pb+=delta)
        !           116:                        {       f->red.x=f->grn.x=f->blu.x=sx;
        !           117:                                f->red.y=f->grn.y=f->blu.y=i;
        !           118:                                for (j = sx; j < ex; j++)
        !           119:                                {       *pr++ = f->red.z; Delay;
        !           120:                                        *pg++ = f->grn.z; Delay;
        !           121:                                        *pb++ = f->blu.z; Delay;
        !           122:                        }       }
        !           123:                        break;
        !           124:                default:
        !           125:                        fprintf(stderr, "undefined number of channels\n");
        !           126:                        break;
        !           127:        }
        !           128:        RESIDENT;
        !           129: }
        !           130: 
        !           131: fbup()  
        !           132: {      if (!frameb) yyerror("up: no access to framebuffer");
        !           133:        F->red.scroll = F->grn.scroll = F->blu.scroll = 32;
        !           134: }
        !           135: 
        !           136: fbdown()
        !           137: {      if (!frameb) yyerror("down: no access to framebuffer");
        !           138:        F->red.scroll = F->grn.scroll = F->blu.scroll =  0;
        !           139: }
        !           140: 
        !           141: fblyank(x, y)
        !           142: {      register fbreg *f=F;
        !           143:        register int i;
        !           144:        register unsigned char *pr, *pg, *pb;
        !           145:        extern char faster;
        !           146: 
        !           147:        if (!faster)
        !           148:        {       fbyank(x, y);
        !           149:                return;
        !           150:        } else
        !           151:        {       if (x != 0)
        !           152:                        return;
        !           153:        }
        !           154:        i = (y < 1 || y >= DEF_LL) ? 0 : DEF_LL*(y-1);
        !           155:        pr = scratchred+i;
        !           156:        pg = scratchgrn+i;
        !           157:        pb = scratchblu+i;
        !           158: 
        !           159:        f->red.y=f->grn.y=f->blu.y=y-1; Delay;
        !           160:        for (i = 0; i < DEF_LL; i++)
        !           161:        {       f->red.x=f->grn.x=f->blu.x=i; Delay;
        !           162:                f->red.z = *pr++; Delay;
        !           163:                f->grn.z = *pg++; Delay;
        !           164:                f->blu.z = *pb++; Delay;
        !           165:        }
        !           166:        return 1;
        !           167: }
        !           168: 
        !           169: fbyank(x, y)
        !           170: {      register fbreg *f=F;
        !           171:        register int i = DEF_LL*y+x;
        !           172:        unsigned char *pr = scratchred+i;
        !           173:        unsigned char *pg = scratchgrn+i;
        !           174:        unsigned char *pb = scratchblu+i;
        !           175: 
        !           176:        f->red.x=f->grn.x=f->blu.x=x; Delay;
        !           177:        f->red.y=f->grn.y=f->blu.y=y; Delay;
        !           178: 
        !           179:        f->red.z = *pr; Delay;
        !           180:        f->grn.z = *pg; Delay;
        !           181:        f->blu.z = *pb; Delay;
        !           182: 
        !           183:        return *pr;
        !           184: }
        !           185: 
        !           186: redcmap(i, z)
        !           187: {      if (frameb) fbredcmap(i, z);
        !           188:        else if (metheus) metredcmap(i, z);
        !           189: }
        !           190: 
        !           191: grncmap(i, z)
        !           192: {      if (frameb) fbgrncmap(i, z);
        !           193:        else if (metheus) metgrncmap(i, z);
        !           194: }
        !           195: 
        !           196: blucmap(i, z)
        !           197: {      if (frameb) fbblucmap(i, z);
        !           198:        else if (metheus) metblucmap(i, z);
        !           199: }
        !           200: 
        !           201: getcmap(i, r,g,b)
        !           202: {
        !           203:        if (frameb) return fbgetcmap(i, r,g,b);
        !           204:        else if (metheus) return metgetcmap(i, r,g,b);
        !           205:        return 0;
        !           206: }
        !           207: 
        !           208: fbredcmap(i, z)
        !           209: {      F->map.addr = i%256;
        !           210:        F->map.sele =  0;
        !           211:        F->map.data = z;
        !           212:        return z;
        !           213: }
        !           214: fbgrncmap(i, z)
        !           215: {      F->map.addr = i%256;
        !           216:        F->map.sele = 16;
        !           217:        F->map.data = z;
        !           218:        return z;
        !           219: }
        !           220: fbblucmap(i, z)
        !           221: {      F->map.addr = i%256;
        !           222:        F->map.sele = 32;
        !           223:        F->map.data = z;
        !           224:        return z;
        !           225: }
        !           226: 
        !           227: fbgetcmap(i, r,g,b)
        !           228: {      fbreg *f=F;
        !           229:        int h = 0, k = 0;
        !           230: 
        !           231:        f->map.addr = i%256;
        !           232:        if (r) { h++; f->map.sele =  0; k += f->map.data; }
        !           233:        if (g) { h++; f->map.sele = 16; k += f->map.data; }
        !           234:        if (b) { h++; f->map.sele = 32; k += f->map.data; }
        !           235:        if (h > 1)
        !           236:                k /= h;
        !           237:        return k;
        !           238: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.