Return to Q2snap.c CVS log

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

Annotation of researchv10no/cmd/qsnap/Q2snap.c, revision 1.1

1.1     ! root        1: #include       <stdio.h>
        !             2: #include       <sys/types.h>
        !             3: #include       <sys/stat.h>
        !             4: #include       "defines.h"
        !             5: #include       "/graphics/piclib/piclib.h"
        !             6: 
        !             7: #define XTIMES         Times
        !             8: #define YTIMES         Times
        !             9: #define Min(a,b)       ((a)>(b)?(b):(a))
        !            10: #define Max(a,b)       ((a)<(b)?(b):(a))
        !            11: 
        !            12: int Dither=0, Times=3, Bright=0;
        !            13: int Film = 0;
        !            14: int Filter = GREEN;
        !            15: int Reso;
        !            16: int redonly = 0;
        !            17: int mustrot = 0;
        !            18: int settimes= 0;
        !            19: int setbright=0;
        !            20: 
        !            21: unsigned char nq[9];
        !            22: char *malloc();
        !            23: unsigned char *rgb;
        !            24: 
        !            25: Usage(str)
        !            26:        char *str;
        !            27: {      fprintf(stderr, "qsnap: %s\n", str);
        !            28:        fprintf(stderr, "usage: qsnap -bdfmrRFL [N ...] file\n");
        !            29:        fprintf(stderr, "b  brightness  [0-8,9], defaults to 0 (2k) or 2 (4k)\n");
        !            30:        fprintf(stderr, "d  dither image +- N [2-255]\n");
        !            31:        fprintf(stderr, "f  filmtype [0-2], defaults to 0 (custom,lin,pola)\n");
        !            32:        fprintf(stderr, "m  enlargement [1- ], defaults to 3(2k) or 6(4k)\n");
        !            33:        fprintf(stderr, "r  expose red only (for multiple red overlays)\n");
        !            34:        fprintf(stderr, "F  bwfilter [0-3], defaults to 2 (n,r,g,b)\n");
        !            35:        fprintf(stderr, "R  rotate image 90o clockwise\n");
        !            36:        fprintf(stderr, "L  straight (no m,d), headerless 1 chan, line by line\n");
        !            37:        exit(1);
        !            38: }
        !            39: 
        !            40: main(argc, argv)
        !            41:        char **argv;
        !            42: {
        !            43:        int i=1, base=2;        /* base of option arguments */
        !            44:        int linebyline = 0;
        !            45:        char c;
        !            46: 
        !            47:        if (argc > 1 && argv[1][0] == '-')
        !            48:        {       base++;
        !            49:                while ((c = argv[1][i++]) != '\0')
        !            50:                        switch (c) {
        !            51:        /* bright   */  case 'b': if (argc >= base)
        !            52:                                  {     sscanf(argv[base-1], "%d", &Bright);
        !            53:                                        base++;
        !            54:                                        Bright = Bright%10;
        !            55:                                        setbright = 1;
        !            56:                                        break;
        !            57:                                  } else
        !            58:                                        Usage("missing argument for `b' flag");
        !            59:        /* dither   */  case 'd': if (argc >= base)
        !            60:                                  {     sscanf(argv[base-1], "%d", &Dither);
        !            61:                                        base++;
        !            62:                                        if (Dither < 0) Dither = -Dither;
        !            63:                                        break;
        !            64:                                  } else
        !            65:                                        Usage("missing argument for `d' flag");
        !            66: 
        !            67:        /* filmtype */  case 'f': if (argc >= base)
        !            68:                                  {     sscanf(argv[base-1], "%d", &Film);
        !            69:                                        Film = Film%8;
        !            70:                                        base++;
        !            71:                                        if (Film == 6)
        !            72:                                                Usage("unknown film type");
        !            73:                                        break;
        !            74:                                  } else
        !            75:                                        Usage("missing argument for `f' flag");
        !            76:        /* multiply */  case 'm': if (argc >= base)
        !            77:                                  {     sscanf(argv[base-1], "%d", &Times);
        !            78:                                        base++;
        !            79:                                        settimes = 1;
        !            80:                                        break;
        !            81:                                  } else
        !            82:                                        Usage("missing argument for `m' flag");
        !            83:        /* filter */    case 'F': if (argc >= base)
        !            84:                                  {     sscanf(argv[base-1], "%d", &Filter);
        !            85:                                        Filter = Filter%4;
        !            86:                                        base++;
        !            87:                                        break;
        !            88:                                  } else
        !            89:                                        Usage("missing argument for `F' flag");
        !            90:                        case 'R': mustrot = 1; break;
        !            91:                        case 'L': linebyline = 1; break;
        !            92:                        case 'r': redonly = 1; break;
        !            93:                        default : Usage("unknown option");
        !            94:                        }
        !            95:        }
        !            96:        if (base != argc) Usage("bad arglist");
        !            97:        qreset();
        !            98:        nocalibs();
        !            99:        Reso = resolution();
        !           100:        if (Reso == 4)
        !           101:        {       if (!settimes)  Times = 6;
        !           102:                if (!setbright) Bright = 2;
        !           103:        }
        !           104: 
        !           105:        rotate(mustrot);
        !           106:        filmtype(Film);
        !           107:        if (Bright != 9)
        !           108:        {       getbright(nq);
        !           109:                brightness(Bright, Bright, Bright, Bright);
        !           110:                printf("brightness %d (%d)\n", Bright, nq[Bright]);
        !           111:        }
        !           112:        handshake(0);
        !           113:        linedelay(1);
        !           114: 
        !           115:        if (linebyline)
        !           116:                znap(argv[base-1]);
        !           117:        else
        !           118:                snap(argv[base-1]);
        !           119:        exit(0);
        !           120: }
        !           121: 
        !           122: znap(name)
        !           123:        char *name;
        !           124: {
        !           125:        register i;
        !           126:        int fd, h, w;
        !           127:        unsigned char obuf[8192];
        !           128:        int Xmax = 1024*Reso, Ymax = 768*Reso;
        !           129:        int Xmin = -512*Reso, Ymin = 384*Reso;
        !           130: 
        !           131:        if ((fd = open(name, 0)) < 0)
        !           132:        {       fprintf(stderr, "cannot open %s\n", name);
        !           133:                return;
        !           134:        }
        !           135:        w = dimension(fd);
        !           136:        if (w > Xmax) { fprintf(stderr, "image too wide (%d)\n", w); exit(1); }
        !           137:        h = Min(Ymax, w);
        !           138: 
        !           139:        printf("%s: %dx%d\n", name, w, h);
        !           140:        window(Xmin+500, Ymin, w, h);
        !           141:        singlepass(Filter);
        !           142:        for (i = 0; i < h; i++)
        !           143:        {       read(fd, obuf, w);
        !           144:                qwrite(obuf, w);
        !           145:        }
        !           146:        printf("done\n");
        !           147: }
        !           148: 
        !           149: snap(name)
        !           150:        char *name;
        !           151: {
        !           152:        int fd, h, w;
        !           153:        int Xmax = 1024*Reso, Ymax = 768*Reso;
        !           154:        int Xmin = -512*Reso, Ymin = 384*Reso;
        !           155:        struct pfile image;
        !           156: 
        !           157:        if((fd = openf(name, &image)) == -1 || !readf(fd, &image))
        !           158:        {       fprintf(stderr, "bad image %s\n", name);
        !           159:                return;
        !           160:        }
        !           161:        w = image.r.corner.x - image.r.origin.x;
        !           162:        if (w*XTIMES > Xmax)
        !           163:        {       fprintf(stderr, "width is too large\n");
        !           164:                fprintf(stderr, "you have: %dx%d=%d\n",w,XTIMES,w*XTIMES);
        !           165:                exit(1);
        !           166:        }
        !           167:        h = image.r.corner.y - image.r.origin.y;
        !           168:        h = Min(Ymax/YTIMES, h);
        !           169:        printf("%s: %dx%d\n", name, w, h);
        !           170:        window(Xmin, Ymin, w*XTIMES, h*YTIMES);
        !           171: 
        !           172:        if (image.nchan == 1)
        !           173:        {       singlepass(Filter);
        !           174:                onechannel(image.pixred, h, w);
        !           175:        } else
        !           176:        {       threepass();
        !           177:                printf("red\n"); onechannel(image.pixred, h, w);
        !           178:                if (redonly) goto done;
        !           179:                printf("grn\n"); onechannel(image.pixgrn, h, w);
        !           180:                printf("blu\n"); onechannel(image.pixblu, h, w);
        !           181:        }
        !           182: done:  printf("done\n");
        !           183: }
        !           184: 
        !           185: onechannel(from, h, w)
        !           186:        unsigned char *from;
        !           187: {
        !           188:        if (Dither)
        !           189:        {       prerand();
        !           190:                onedither(from, h, w);
        !           191:        } else
        !           192:                 straight(from, h, w);
        !           193: }
        !           194: 
        !           195: straight(from, h, w)
        !           196:        unsigned char *from;
        !           197: {
        !           198:        register i, j, k;
        !           199:        register unsigned char *p, *q;
        !           200:        unsigned char obuf[8192];
        !           201:        int chunk = w*XTIMES;
        !           202: 
        !           203:        for (i = 0, p = from; i < h; i++)
        !           204:        {       q = obuf;
        !           205:                for (j = 0; j < w; j++, p++)
        !           206:                for (k = 0; k < XTIMES; k++)
        !           207:                        *q++ = *p;
        !           208:                for (k = 0; k < YTIMES; k++)
        !           209:                {       qwrite(obuf, chunk);
        !           210:                        if (chunk > 2048) qwait(200);
        !           211:        }       }
        !           212: }
        !           213: 
        !           214: short Nrand[5000];
        !           215: 
        !           216: prerand()
        !           217: {      register int i, D1=Dither, D2=Dither/2;
        !           218: 
        !           219:        for (i = 0; i < 5000; i++)
        !           220:                Nrand[i] = (short) (nrand(D1) - D2);
        !           221: }
        !           222: 
        !           223: onedither(from, h, w)
        !           224:        unsigned char *from;
        !           225: {
        !           226:        register int c, m, kk=0;
        !           227:        register unsigned char *op, *q;
        !           228:        unsigned char *p, obuf[8192];
        !           229:        int i, j, k;
        !           230:        int chunk = w*XTIMES;
        !           231: 
        !           232:        for (i = 0, p = from; i < h; i++, p = op)
        !           233:        for (k = 0; k < YTIMES; k++)
        !           234:        {       q = obuf;
        !           235:                op = p;
        !           236:                j = w;
        !           237:                do{
        !           238:                        m = XTIMES;
        !           239:                        do{
        !           240:                                c = *op + Nrand[kk];
        !           241:                                if (++kk >= 5000) kk = 0;
        !           242:                                if(c<0)
        !           243:                                        c=0;
        !           244:                                if(c>255)
        !           245:                                        c=255;
        !           246:                                *q++ = c;
        !           247:                        }while(--m);
        !           248:                        op++;
        !           249:                }while(--j);
        !           250:                qwrite(obuf, chunk);
        !           251:        }
        !           252: }
        !           253: 
        !           254: qwait(n)
        !           255: {      int i;
        !           256:        for (i = 0; i < n; i++) ;
        !           257: }
        !           258: 
        !           259: dimension(fd)
        !           260: {      struct stat bam;
        !           261:        int N;
        !           262:        extern float fsqrt();
        !           263: 
        !           264:        if (fstat(fd, &bam)==0)
        !           265:        {       N = bam.st_size;
        !           266:                N = (int) fsqrt((double)N+1.0);
        !           267:                return N;
        !           268:        }
        !           269:        return 0;
        !           270: }

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