Return to junk.c CVS log

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

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

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