Return to qdump.c CVS log

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

Annotation of researchv10no/cmd/qsnap/qdump.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: 
        !             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.