[BACK]Return to library.c CVS log [TXT] [DIR] Up to [Research Unix] / researchv10dc / cmd / qsnap

Annotation of researchv10dc/cmd/qsnap/library.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include "defines.h"
        !             3: 
        !             4: static char Mode = 2;  /* remembers resolution for check in window() */
        !             5: 
        !             6: advance(how)
        !             7: {
        !             8:        if (how)
        !             9:                qcmd("\020", 1);        /* enable frame advance */
        !            10:        else
        !            11:                qcmd("\017", 1);        /* disable frame advance */
        !            12:        qpause();
        !            13: }
        !            14: 
        !            15: shutter(how)
        !            16: {
        !            17:        if (how)
        !            18:                qcmd("\033", 1);        /* open shutter */
        !            19:        else
        !            20:                qcmd("\032", 1);        /* close and advance film */
        !            21:        qpause();
        !            22:        qpause();
        !            23:        qpause();
        !            24:        qpause();
        !            25:        qpause();
        !            26:        qpause();
        !            27: }
        !            28: 
        !            29: beep()
        !            30: {
        !            31:        qcmd("\021", 1);        /* beep */
        !            32:        qpause();
        !            33: }
        !            34: 
        !            35: loadluts(wbuf)         /* 8 bit wide lookup tables */
        !            36:        char *wbuf;
        !            37: {      char rbuf[768];
        !            38:        register int i;
        !            39: 
        !            40:        qcmd("\000", 1);        /* load the rgb LUT's */
        !            41:        qpause();
        !            42:        qwrite(wbuf, 768);
        !            43:        qpause();
        !            44:        qcmd("\001", 1);        /* read back rgb LUT's */
        !            45:        qpause();
        !            46: 
        !            47:        if (qread(rbuf, 768) != 768)
        !            48:                return 0;
        !            49:        else
        !            50:                for(i = 0; i < 768; i++)
        !            51:                        if (rbuf[i] != wbuf[i])
        !            52:                                return 0;
        !            53:        qpause();
        !            54:        return 1;
        !            55: }
        !            56: 
        !            57: load12luts(wbuf)       /* 12 bit wide lookup tables */
        !            58:        short *wbuf;
        !            59: {
        !            60:        register int i;
        !            61:        short rbuf[768];
        !            62: 
        !            63:        printf("loading 12 bit lookup tables\n"); fflush(stdout);
        !            64:        qpause();
        !            65:        qcmd("\094", 1);        /* load the rgb LUT's */
        !            66:        qpause();
        !            67:        qwrite((char *)wbuf, 1536);     /* sizeof(short)*768 */
        !            68:        qpause();
        !            69:        qcmd("\096", 1);        /* read back rgb LUT's */
        !            70:        qpause();
        !            71: 
        !            72:        if (qread((char *)rbuf, 1536) != 1536)
        !            73:                return 0;
        !            74:        else
        !            75:                for(i = 0; i < 768; i++)
        !            76:                        if (rbuf[i] != wbuf[i])
        !            77:                                return 0;
        !            78:        qpause();
        !            79:        return 1;
        !            80: }
        !            81: 
        !            82: singlepass(how)
        !            83: {      /* set single pass pixel mode */
        !            84:        switch (how) {
        !            85:        default     :
        !            86:        case NEUTRAL:   qcmd("\002", 1); printf("singlepass neutral\n"); break;
        !            87:        case RED    :   qcmd("\003", 1); printf("singlepass red\n"); break;
        !            88:        case GREEN  :   qcmd("\004", 1); printf("singlepass green\n"); break;
        !            89:        case BLUE   :   qcmd("\005", 1); printf("singlepass blue\n"); break;
        !            90:        }
        !            91:        qpause();
        !            92: }
        !            93: 
        !            94: threepass()
        !            95: {      /* set three pass pixel mode */
        !            96:        qcmd("\006", 1);
        !            97:        qpause();
        !            98:        printf("3pass mode\n");
        !            99: }
        !           100: 
        !           101: nocalibs()
        !           102: {      /* disable automatic calibrations */
        !           103:        qcmd("\037", 1);
        !           104:        qpause(); qpause();
        !           105: }
        !           106: 
        !           107: testpattern(which)
        !           108: {
        !           109:        if (which)
        !           110:                qcmd("\012", 1);        /* test pattern 1 */
        !           111:        else
        !           112:                qcmd("\013", 1);        /* test pattern 0 */
        !           113:        qpause();
        !           114: }
        !           115: 
        !           116: linedelay(n)
        !           117:        unsigned char n;
        !           118: {      /* interline time delay - to match host speed to qcr scanrate */
        !           119: 
        !           120:        qcmd("\014", 1);
        !           121:        qpause();
        !           122:        qwrite(n, 1);           /* max delay n msec per line */
        !           123:        qpause();
        !           124: }
        !           125: 
        !           126: version(data)
        !           127:        char *data;
        !           128: {
        !           129:        qcmd("\015", 1);
        !           130:        qpause();
        !           131:        qread(data, 14);
        !           132:        qpause();
        !           133: }
        !           134: 
        !           135: window(x, y, w, h)
        !           136: {
        !           137:        unsigned char buf[8];
        !           138:        int maxsz = (Mode == 2)?1536:3072;      /* 1536 = 2*768 = 2*3/4*1024 */
        !           139: 
        !           140:        if (w+x > maxsz || h-y > maxsz)
        !           141:        {       printf("error: bad image size\n");
        !           142:                if (Mode == 2)
        !           143:                        printf("\tmax: -1024,  768, 1024,  -768\n");
        !           144:                else
        !           145:                        printf("\tmax: -2048, 1536, 2048, -1536\n");
        !           146:                printf("\thave: %4d, %4d, %4d, %4d\n", x, y, x+w, y-h);
        !           147:                return;
        !           148:        }
        !           149:        buf[0] = (x>>8)&255; buf[1] = x&255;
        !           150:        buf[2] = (w>>8)&255; buf[3] = w&255;
        !           151:        buf[4] = (y>>8)&255; buf[5] = y&255;
        !           152:        buf[6] = (h>>8)&255; buf[7] = h&255;
        !           153:        qpause();
        !           154:        qcmd("\016", 1);
        !           155:        qpause();
        !           156:        qwrite(buf, 8);
        !           157:        qpause();
        !           158:        printf("window (%dx%d): %d %d %d %d\n", w, h, x, y, x+w, y-h);
        !           159: }
        !           160: 
        !           161: filmtype(n)
        !           162: {
        !           163:        if (n == NONE || n == TMAX_100)
        !           164:        {       customluts(n);
        !           165:                return;
        !           166:        }
        !           167:        qcmd("\043", 1);
        !           168:        qpause();
        !           169:        switch (n) {
        !           170:        default:
        !           171:        case LINEAR    : qwrite("\001", 1); printf("linear lut's\n"); break;
        !           172:        case POLA559   : qwrite("\002", 1); printf("filmtype pola559\n"); break;
        !           173:        case EKTA100   : qwrite("\003", 1); printf("filmtype ekat100\n"); break;
        !           174:        case EKTA100_4k: qwrite("\004", 1); printf("filmtype ekta100_4k\n"); break;
        !           175:        case POLA559_4k: qwrite("\005", 1); printf("filmtype pola559_4k\n"); break;
        !           176:        case POLA809_4k: qwrite("\007", 1); printf("filmtype pola809_4k\n"); break;
        !           177:        }
        !           178:        qpause();
        !           179: }
        !           180: 
        !           181: moduleno()
        !           182: {      char c;
        !           183: 
        !           184:        qcmd("\045", 1);
        !           185:        qpause();
        !           186:        qread(&c, 1);
        !           187:        qpause();
        !           188:        switch (c) {
        !           189:        case 240: printf("no module\n"); break;
        !           190:        case  16: printf("35mm module\n"); break;
        !           191:        case  32: printf("4x5\" module\n"); break;
        !           192:        case  64: printf("8x10\" module\n"); break;
        !           193:        default : printf("bad module number %d\n", c);
        !           194:        }
        !           195:        return c;       /*  (none, m35, m120, or m240) */
        !           196: }
        !           197: 
        !           198: setreso(n)
        !           199: {
        !           200:        if (n == '2')
        !           201:        {       qcmd("\077", 1);
        !           202:                printf("2k mode set\n"); 
        !           203:        } else if (n == '4')
        !           204:        {       qcmd("\078", 1);
        !           205:                printf("4k mode set \n"); 
        !           206:        } else
        !           207:        {       printf("resolution must be either 2 or 4\n");
        !           208:                return;
        !           209:        }
        !           210:        qpause();
        !           211:        fflush(stdout);
        !           212: }
        !           213: 
        !           214: resolution()
        !           215: {
        !           216:        Mode = qreso();
        !           217:        switch (Mode) {
        !           218:        case 2:  printf("2k mode\n"); break;
        !           219:        case 4:  printf("4k mode\n"); break;
        !           220:        default: printf("qcr: bad resolution %d\n", Mode);
        !           221:        }
        !           222:        fflush(stdout);
        !           223:        qpause();
        !           224:        return Mode;
        !           225: }
        !           226: 
        !           227: handshake(how)
        !           228: {
        !           229:        if (how)
        !           230:                qcmd("\063", 1);        /* enable full handshake */
        !           231:        else
        !           232:                qcmd("\062", 1);        /* disable (default) */
        !           233:        qpause();
        !           234: }
        !           235: 
        !           236: rotate(how)
        !           237: {
        !           238:        if (how)
        !           239:                qcmd("\067", 1);        /* enable 90 deg rotation */
        !           240:        else
        !           241:                qcmd("\066", 1);        /* disable (default) */
        !           242:        qpause();
        !           243: }
        !           244: 
        !           245: brightness(r,g,b,n)
        !           246: {
        !           247:        char buf[4]; int oval;
        !           248: 
        !           249:        buf[0] = r; buf[1] = g; buf[2] = b; buf[3] = n;
        !           250:        qcmd("\055", 1); qpause();
        !           251:        qwrite(buf, 4);  qpause();
        !           252: }
        !           253: 
        !           254: getbright(nq)
        !           255:        char *nq;
        !           256: {      char buf[10]; int i;
        !           257: 
        !           258:        qcmd("\073", 1); qpause();
        !           259:        qread(buf, 10);  qpause();
        !           260:        for (i = 0; i < 9; i++)
        !           261:                nq[i] = buf[i+1]&0xFF;
        !           262:        qpause();
        !           263: }
        !           264: 
        !           265: whaterror(n)
        !           266: {      /* primary erro code, as shown on display lights:
        !           267:                128     64      32      16
        !           268:                  8      4       2       1
        !           269:        */
        !           270:        switch (n) {
        !           271:        case   1:       printf("out of film\n"); break;
        !           272:        case 129:       printf("unexpected command byte\n"); break;
        !           273:        case 130:       printf("unexpected data byte\n"); break;
        !           274:        case 131:       printf("illegal command byte\n"); break;
        !           275:        case 132:       printf("illegal data byte\n"); break;
        !           276:        case 133:       printf("command interrupt\n"); break;
        !           277:        case 134:       printf("unimplemented function\n"); break;
        !           278:        case 145:       printf("memory fault\n"); break;
        !           279:        case 146:       printf("gpib interface fault\n"); break;
        !           280:        case 147:       printf("crt beam calibration fault\n"); break;
        !           281:        case 161:       printf("module fault\n"); break;
        !           282:        case 162:       printf("filter wheel fault\n"); break;
        !           283:        default:        printf("-bad primary code (%d)-\n", n); break;
        !           284:        }
        !           285: }
        !           286: 
        !           287: qerror()
        !           288: {      char buf[8];
        !           289: 
        !           290:        qcmd("\044", 1);
        !           291:        qpause();
        !           292:        qread(buf, 8);
        !           293:        whaterror(buf[0]&0xFF);
        !           294:        qpause();
        !           295:        printf("Error: pri=0x%02x sec=0x%02x", (buf[0]&0xFF), (buf[1]&0xFF));
        !           296:        printf("\n\tH=0x%02x L=0x%02x ", (buf[2]&0xFF), (buf[3]&0xFF));
        !           297:        printf("D=0x%02x \n\tE=0x%02x ", (buf[4]&0xFF), (buf[5]&0xFF));
        !           298:        printf("B=0x%02x C=0x%02x\n", (buf[6]&0xFF), (buf[7]&0xFF));
        !           299: }
        !           300: 
        !           301: qreso()
        !           302: {      unsigned char buf[64];
        !           303:        int i, j;
        !           304: 
        !           305:        qpause();
        !           306:        qcmd("\074", 1);
        !           307:        qpause();
        !           308:        qpause();
        !           309:        qread(buf, 1);
        !           310:        qread(&buf[1], buf[0]);
        !           311:        qpause();
        !           312:        qpause();
        !           313:        return (int) buf[18];
        !           314: }
        !           315: 
        !           316: qstatus()
        !           317: {      unsigned char buf[64];
        !           318:        int i, j;
        !           319: 
        !           320:        qcmd("\074", 1);
        !           321:        qpause();
        !           322:        memset(buf, 0, 64);
        !           323:        qread(buf, 1);
        !           324:        printf("QCR status (%d bytes):\n", buf[0]);
        !           325:        qread(&buf[1], buf[0]);
        !           326:        for (i = 0; i < 38; i++)
        !           327:        {       switch (i) {
        !           328:                case  6: printf("\timage height: %d\n", qnum(buf[i],buf[i+1]));
        !           329:                         i++; break;
        !           330:                case  8: printf("\ty-offset    : %d\n", qnum(buf[i],buf[i+1]));
        !           331:                         i++; break;
        !           332:                case 10: printf("\timage  width: %d\n", qnum(buf[i],buf[i+1]));
        !           333:                         i++; break;
        !           334:                case 12: printf("\tx-offset    : %d\n", qnum(buf[i],buf[i+1]));
        !           335:                         i++; break;
        !           336:                case 26: printf("\tframe counter: %d\n", qnum(buf[i],buf[i+1]));
        !           337:                         i++; break;
        !           338:                case 36: printf("\tdrift value : %d\n", qnum(buf[i],buf[i+1]));
        !           339:                         i++; break;
        !           340:                default: whatstatus(i, buf[i]); break;
        !           341:                }
        !           342:        }
        !           343: }
        !           344: 
        !           345: qnum(a, b)
        !           346:        unsigned char a, b;
        !           347: {      short n;
        !           348: 
        !           349:        n = b + a<<8;
        !           350:        return (int)n;
        !           351: }
        !           352: 
        !           353: whatstatus(n, m)
        !           354:        unsigned char m;
        !           355: {
        !           356:        switch (n) {
        !           357:        case  0: if (m) printf("\texternal luts loaded\n"); break;
        !           358:        case  1: if (m) printf("\tneutral  luts loaded\n"); break;
        !           359:        case  2: printf("\t%d msec interline time delay\n", m); break;
        !           360:        case  3: if (m) printf("\tend of film\n"); break;
        !           361:        case  4: printf("\tautomatic filter wheel %sabled\n",(m)?"dis":" en");break;
        !           362:        case  5: printf("\tauto camera operation  %sabled\n",(m)?"dis":" en");break;
        !           363:        case 14: printf("\tmodule no: %d\n", m); break;
        !           364:        case 15: printf("\tautomatic calibration %sabled\n",(m)?"en":"dis");break;
        !           365:        case 16: printf("\tautomatic warbling    %sabled\n",(m)?"dis":" en");break;
        !           366:        case 17: printf("\trunlength black jumps %sabled\n",(m)?"dis":" en");break;
        !           367:        case 18: printf("\tresolution: %dk\n", m); break;
        !           368:        case 19: printf("\tmode was %sternally selected\n", (m)?"ex":"in");break;
        !           369:        case 20: if (m) printf("\timage is 90 degrees rotated\n"); break;
        !           370:        case 21: if (m) printf("\timage is mirrored\n"); break;
        !           371:        case 22: if (m) printf("\tunbuffered raster mode\n"); break;
        !           372:        case 23: if (m) printf("\treturn to no filter disabled\n"); break;
        !           373:        case 24: if (m) printf("\tx and y coordinates are swapped\n"); break;
        !           374:        case 25: if (m) printf("\tred repeat is enabled\n"); break;
        !           375:        case 28: if (m) printf("\tfilm is in camera\n"); break;
        !           376:        case 29: if (m) printf("\thalf frame mode enabled\n"); break;
        !           377:        case 30: if (m) printf("\tbulk back is in use\n"); break;
        !           378:        case 31: if (m) printf("\timage is 180 degrees rotated\n"); break;
        !           379:        case 32: if (m) printf("\t12 bit lookup tables are loaded\n"); break;
        !           380:        case 33: printf("\tinternal timing constant 1: %d\n", m); break;
        !           381:        case 34: printf("\tinternal timing constant 2: %d\n", m); break;
        !           382:        case 35: if (m) printf("\t'irradiance modulation' is active\n"); break;
        !           383:        default: printf("\t%2d: %2d\n", n, m); break;
        !           384:        }
        !           385: }
        !           386: 
        !           387: /* customized lookup tables */
        !           388: 
        !           389: #include "qlut2.h"     /* 8b  generated by /usr/gerard/CAL/QCR/qlutnew.c */
        !           390: 
        !           391: /*
        !           392: #include "LUT_pola52.h"        ** awful, reversed? **
        !           393: */
        !           394: 
        !           395: unsigned char lutpola52[] = {  /* pola52 lut for brightness 148 */
        !           396:           0,   46,   54,   61,   67,   68,   68,   69,   69,   70, 
        !           397:          70,   71,   71,   72,   72,   73,   73,   74,   74,   75, 
        !           398:          75,   76,   76,   77,   77,   78,   78,   79,   79,   80, 
        !           399:          80,   81,   81,   82,   82,   83,   83,   84,   84,   85, 
        !           400:          85,   85,   86,   86,   86,   86,   87,   87,   87,   88, 
        !           401:          88,   88,   88,   89,   89,   89,   90,   90,   90,   90, 
        !           402:          91,   91,   91,   92,   92,   92,   92,   93,   93,   93, 
        !           403:          94,   94,   94,   94,   95,   95,   95,   96,   96,   96, 
        !           404:          96,   97,   97,   97,   98,   98,   98,   98,   99,   99, 
        !           405:          99,  100,  100,  100,  100,  101,  101,  101,  102,  102, 
        !           406:         103,  103,  104,  104,  105,  105,  105,  106,  106,  107, 
        !           407:         107,  108,  108,  109,  109,  110,  110,  111,  111,  112, 
        !           408:         112,  113,  113,  114,  114,  115,  115,  115,  116,  116, 
        !           409:         117,  117,  118,  118,  119,  119,  120,  120,  120,  121, 
        !           410:         121,  122,  122,  122,  123,  123,  124,  124,  124,  125, 
        !           411:         125,  126,  126,  126,  127,  127,  128,  128,  128,  129, 
        !           412:         129,  130,  130,  130,  131,  131,  132,  132,  132,  133, 
        !           413:         133,  134,  134,  134,  135,  135,  136,  136,  136,  137, 
        !           414:         137,  138,  138,  139,  139,  139,  140,  140,  141,  141, 
        !           415:         141,  142,  142,  143,  143,  144,  144,  144,  145,  145, 
        !           416:         146,  146,  147,  147,  147,  148,  148,  149,  149,  150, 
        !           417:         150,  150,  151,  151,  152,  152,  153,  154,  154,  155, 
        !           418:         156,  157,  158,  159,  160,  161,  161,  162,  163,  164, 
        !           419:         165,  166,  167,  168,  169,  169,  171,  173,  175,  176, 
        !           420:         178,  180,  182,  184,  185,  188,  195,  201,  205,  208, 
        !           421:         211,  215,  218,  221,  234,  255, 
        !           422: };
        !           423: 
        !           424: 
        !           425: customluts(n)
        !           426: {      short all12uts[768];
        !           427:        unsigned char alluts[768];
        !           428:        register int i;
        !           429: 
        !           430:        switch (n) {
        !           431:        case TMAX_100:
        !           432:                for (i = 0; i < 768; i++)
        !           433:                        alluts[i] = qcr_lut[i%256];
        !           434:                if (!loadluts(alluts))
        !           435:                printf("loading new lookup tables failed\n");
        !           436:                break;
        !           437:        default:        /* polaroid type 52 */
        !           438:                for (i = 0; i < 768; i++)
        !           439:                        alluts[i] = lutpola52[i%256];
        !           440:                if (!loadluts(alluts))
        !           441:                printf("loading new lookup tables failed\n");
        !           442:                break;
        !           443:        }
        !           444: }
        !           445: 
        !           446: /*
        !           447: not implemented:
        !           448: 18      n       +      red     runlength encoded single pass pixel mode
        !           449: 19      n       +      green   runlength sppm
        !           450: 20      n       +      blue    runlength sppm
        !           451: 21      n       +      neutral runlength sppm
        !           452: 22      n       +      three pass runlength image
        !           453: 
        !           454: 24      -       -      disable automatic filter wheel control
        !           455: 25      -       -      enable  automatic filter wheel control (default)
        !           456: 
        !           457: 29     256      -      load a neutral LUT (default for neutral is blue lut)
        !           458: 30     256      -      read neutral LUT
        !           459: 31/32   -       -      disable/enable automatic calibrations
        !           460: 33/34   -       -      disable/enable warble sounds at end of image
        !           461: 38      -       +      start an intensity calibration for used levels
        !           462: 39      -       +      intensity calibration for all 9 levels
        !           463: 
        !           464: 40/41   -       -      disable/enable black jumping (for runlength)
        !           465: 48/49   -       -      disable/enable mirror imaging
        !           466: 52/53   -       -      disable/enable end-of-image filter wheel movement
        !           467: 54/55   -       -      disable/enable switch of x/y coordinates
        !           468: 56/57   -       -      disable/enable red repeat mode
        !           469: */
unix.superglobalmegacorp.com

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