Return to mktab.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / libgnot

Annotation of lucent/sys/src/libgnot/mktab.c, revision 1.1.1.1

1.1       root        1: #include       <u.h>
                      2: #include       <libc.h>
                      3: 
                      4: int    table(int n);
                      5: int    in, lin;
                      6: int    ou, lou;
                      7: int    b;
                      8: int    lendian;
                      9: 
                     10: main(int argc, char *argv[])
                     11: {
                     12:        int i, osiz, osizb;
                     13:        ulong v;
                     14: 
                     15:        ARGBEGIN{
                     16:        case 'l':
                     17:                lendian = 1;
                     18:                break;
                     19:        default:
                     20:                fprint(2, "Usage: %s [-l] in-ldepth out-ldepth\n", argv0);
                     21:                exits("usage");
                     22:        }ARGEND
                     23:        if(argc != 2) {
                     24:                fprint(2, "Usage: %s [-l] in-ldepth out-ldepth\n", argv0);
                     25:                exits("usage");
                     26:        }
                     27:        lin = atol(argv[0]);
                     28:        lou = atol(argv[1]);
                     29:        if(in < 0 || in > 5 || ou < 0 || ou > 5) {
                     30:                fprint(2, "ldepths must be in range [0,5]\n");
                     31:                exits("ldepth range");
                     32:        }
                     33:        in = 1<<lin;
                     34:        ou = 1<<lou;
                     35:        if(ou > in){
                     36:                osizb = 0;
                     37:                if(ou/in <= 4) {
                     38:                        b = 8;
                     39:                        osiz = (2*ou)/in;
                     40:                } else {
                     41:                        b = (32*in)/ou;
                     42:                        osiz = 8;
                     43:                }
                     44:        } else {
                     45:                if(in/ou > 8) {
                     46:                        fprint(2, "too big a contraction table\n");
                     47:                        exits("toobig");
                     48:                }
                     49:                if(in == ou) {
                     50:                        fprint(2, "identity\n");
                     51:                        exits("identity");
                     52:                }
                     53:                b = 8;
                     54:                osiz = lendian? 0 : 1;
                     55:                osizb = 8 >> (lin-lou);
                     56:        }
                     57:        if(lendian)
                     58:                print("static ulong ");
                     59:        else if(osiz <= 2)
                     60:                print("static uchar ");
                     61:        else if(osiz <= 4)
                     62:                print("static ushort ");
                     63:        else
                     64:                print("static ulong ");
                     65:        print("tab%d%d[%d] =\n{\n", lin, lou, (1<<b));
                     66:        for(i=0; i<(1<<b); i++) {
                     67:                v = table(i);
                     68:                if(lendian){
                     69:                        v <<= 32 - 4*osiz - osizb;
                     70:                        print(" 0x%.8ux,", v);
                     71:                } else
                     72:                        print(" 0x%.*ux,", osiz, v);
                     73:                if(lendian || osiz==8) {
                     74:                        if(i%4 == 3)
                     75:                                print("\n");
                     76:                } else {
                     77:                        if(i%8 == 7)
                     78:                                print("\n");
                     79:                }
                     80:        }
                     81:        print("};\n");
                     82:        exits(0);
                     83: }
                     84: 
                     85: /*
                     86:  * Byte n of size b bits contains pixels with in bits/pixel.
                     87:  * Convert each pixel to a pixel with ou bits/pixel,
                     88:  * and assemble into an int.
                     89:  * When expanding, a 0 pixel goes to 0, an all 1's pixel
                     90:  * goes to all 1's, and the other input pixels equally divide
                     91:  * the output pixel maximum.  (E.g., in=2, ou=8: 0->0, 1->255/3,
                     92:  * 2-> 255/3 * 2, 3-> 255).  You get this effect by just
                     93:  * duplicating the input pixel as many times as necessary.
                     94:  * This works even if lendian is true.
                     95:  */
                     96: int
                     97: table(int n)
                     98: {
                     99:        int i, j, x, t;
                    100: 
                    101:        x = 0;
                    102:        for(i=0; i<b/in; i++) {
                    103:                t = n >> (b-in);
                    104:                n <<= in;
                    105:                t &= (1<<in) - 1;
                    106:                x <<= ou;
                    107:                if(ou > in) {
                    108:                        for(j=0; j<ou/in; j++) {
                    109:                                x |= t;
                    110:                                t <<= in;
                    111:                        }
                    112:                } else {
                    113:                        x |= t >> (in-ou);
                    114:                }
                    115:        }
                    116:        return x;
                    117: }

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