Return to qdump.c CVS log

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

Annotation of researchv10dc/cmd/qsnap/qdump.c, revision 1.1.1.1

1.1       root        1: #include       <stdio.h>
                      2: #include       <sys/types.h>
                      3: #include       <sys/stat.h>
                      4: #include       "defines.h"
                      5: 
                      6: #define Min(a,b)       ((a)>(b)?(b):(a))
                      7: #define Max(a,b)       ((a)<(b)?(b):(a))
                      8: 
                      9: int Bright=0;
                     10: int Film = 0;
                     11: int Filter = GREEN;
                     12: int Reso;
                     13: int setbright=0;
                     14: int Xmax, Ymax, Xmin, Ymin;
                     15: 
                     16: unsigned char nq[9];
                     17: 
                     18: Usage(str)
                     19:        char *str;
                     20: {      fprintf(stderr, "qdump: %s\n", str);
                     21:        fprintf(stderr, "usage: qdump -bfF [N ...] file\n");
                     22:        fprintf(stderr, "b  brightness  [0-8,9], defaults to 0 (2k) or 2 (4k)\n");
                     23:        fprintf(stderr, "f  filmtype [0-2], defaults to 0 (custom,lin,pola)\n");
                     24:        fprintf(stderr, "F  bwfilter [0-3], defaults to 2 (n,r,g,b)\n");
                     25:        exit(1);
                     26: }
                     27: 
                     28: main(argc, argv)
                     29:        char **argv;
                     30: {
                     31:        int i=1, base=2;        /* base of option arguments */
                     32:        char c;
                     33: 
                     34:        if (argc > 1 && argv[1][0] == '-')
                     35:        {       base++;
                     36:                while ((c = argv[1][i++]) != '\0')
                     37:                        switch (c) {
                     38:        /* bright   */  case 'b': if (argc >= base)
                     39:                                  {     sscanf(argv[base-1], "%d", &Bright);
                     40:                                        base++;
                     41:                                        Bright = Bright%10;
                     42:                                        setbright = 1;
                     43:                                        break;
                     44:                                  } else
                     45:                                        Usage("missing argument for `b' flag");
                     46:        /* filmtype */  case 'f': if (argc >= base)
                     47:                                  {     sscanf(argv[base-1], "%d", &Film);
                     48:                                        Film = Film%8;
                     49:                                        base++;
                     50:                                        if (Film == 6)
                     51:                                                Usage("unknown film type");
                     52:                                        break;
                     53:                                  } else
                     54:                                        Usage("missing argument for `f' flag");
                     55:        /* filter */    case 'F': if (argc >= base)
                     56:                                  {     sscanf(argv[base-1], "%d", &Filter);
                     57:                                        Filter = Filter%4;
                     58:                                        base++;
                     59:                                        break;
                     60:                                  } else
                     61:                                        Usage("missing argument for `F' flag");
                     62:                        default : Usage("unknown option");
                     63:                        }
                     64:        }
                     65:        if (base != argc)
                     66:                Usage("bad arglist");
                     67: 
                     68:        qreset();
                     69:        nocalibs();
                     70:        Reso = resolution();
                     71:        if (Reso == 4 && !setbright)
                     72:                Bright = 2;
                     73: 
                     74:        Xmax = 1024*Reso; Ymax = 768*Reso;
                     75:        Xmin = -512*Reso; Ymin = 384*Reso;
                     76: 
                     77:        filmtype(Film);
                     78:        if (Bright != 9)
                     79:        {       getbright(nq);
                     80:                brightness(Bright, Bright, Bright, Bright);
                     81:                printf("brightness %d (%d)\n", Bright, nq[Bright]);
                     82:        }
                     83:        handshake(1);
                     84:        snap(argv[base-1]);
                     85:        exit(0);
                     86: }
                     87: 
                     88: snap(name)
                     89:        char *name;
                     90: {
                     91:        register i, fd;
                     92:        register unsigned char *p;
                     93:        int h, w;
                     94: 
                     95:        if ((fd = open(name, 0)) == -1)
                     96:        {       perror(name);
                     97:                exit(1);
                     98:        }
                     99:        h = w = dimension(fd);
                    100:        printf("%s: %dx%d\n", name, w, h);
                    101: 
                    102:        window(Xmin, Ymin, Min(Xmax, w), Min(Ymax, h));
                    103:        singlepass(Filter);
                    104:        straight(fd, h, w);
                    105: }
                    106: 
                    107: straight(fd, h, w)
                    108: {      register int i;
                    109:        unsigned char obuf[4096];
                    110:        int realw = Min(Xmax, w);
                    111:        int realh = Min(Ymax, h);
                    112:        int j;
                    113: 
                    114:        for (i = 0; i < realh; i++)
                    115:        {       if (read(fd, obuf, w) != w)
                    116:                {       fprintf(stderr, "qdump: unexpected eof\n");
                    117:                        exit(1);
                    118:                }
                    119:                qwrite(obuf, realw);
                    120:        }
                    121: }
                    122: 
                    123: dimension(fd)
                    124: {      struct stat bam;
                    125:        int N;
                    126:        extern float fsqrt();
                    127: 
                    128:        if (fstat(fd, &bam)==0)
                    129:        {       N = bam.st_size;
                    130:                N = (int) fsqrt((double)N+1.0);
                    131:                return N;
                    132:        }
                    133:        return 0;
                    134: }

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