tiff2img.c Source File

00001 #include   "sadie.h"
00002 /* #include   "tiffio.h" */
00003 #include   <setjmp.h>
00004 
00005 #define    BLEN    ((unsigned long)8)
00006 #define     DLEN    ((unsigned long)8192)
00007 
00008 static      unsigned    long    Swap;
00009 static      unsigned    long    Comp;
00010 static      unsigned    long    Flip;
00011 static      unsigned    long    Bits;
00012 
00013 static      jmp_buf             Env;
00014 
00015 static unsigned short sswap (register unsigned char *cptr) {
00016     unsigned char cval[2];
00017 
00018     cval[0] = cptr[1];
00019     cval[1] = cptr[0];
00020     return(*(unsigned short *)cval);
00021 }
00022 
00023 static unsigned long lswap (register unsigned char *cptr) {
00024     unsigned char cval[4];
00025 
00026     cval[0] = cptr[3];
00027     cval[1] = cptr[2];
00028     cval[2] = cptr[1];
00029     cval[3] = cptr[0];
00030     return(*(unsigned long *)cval);
00031 }
00032 
00033 static unsigned long GetIValue (unsigned long type, register unsigned char *data) {
00034     char msg[SLEN];
00035     unsigned long value = ((unsigned long)0);
00036 
00037     switch (type) {
00038     case TBYTE:
00039         value = (unsigned long)*(unsigned char *)data;
00040         break;
00041     case TSHORT:
00042         if (!Swap) {
00043             value = (unsigned long)*(unsigned short *)data;
00044         } else {
00045             value = (unsigned long)sswap(data);
00046         }
00047         break;
00048     case TLONG:
00049         if (!Swap) {
00050             value = (unsigned long)*(unsigned long *)data;
00051         } else {
00052             value = (unsigned long)lswap(data);
00053         }
00054         break;
00055     default:
00056         sprintf(msg," Unknown data type: %ld.",type);
00057         MESSAGE('E',msg);
00058         longjmp(Env,1);
00059     }
00060     return(value);
00061 }
00062 
00063 static double GetRValue (unsigned long type, register unsigned char *data) {
00064     char msg[SLEN];
00065     double value = 0.0;
00066 
00067     switch (type) {
00068     case TRATIONAL:
00069         if (!Swap) {
00070             value = ((double)*(unsigned long *)data) / ((double)*(unsigned long *)(data+4));
00071         } else {
00072             value = ((double)lswap(data)) / ((double)lswap(data+4));
00073         }
00074         break;
00075     default:
00076         sprintf(msg," Unknown data type: %ld.",type);
00077         MESSAGE('E',msg);
00078         longjmp(Env,1);
00079     }
00080     return(value);
00081 }
00082 
00083 #define NM 40
00084 #define NT 64
00085 
00086 static unsigned long GetPValue (register unsigned char *data, unsigned long nbit) {
00087     static unsigned short mmask[2][NM] = { { 0xD800, 0x9000, 0x5C00, 0x6E00, 0x3600, 0x3700, 0x6400, 0x6500, 0x6800, 0x6700,
00088                                              0x6600, 0x6680, 0x6900, 0x6980, 0x6A00, 0x6A80, 0x6B00, 0x6B80, 0x6C00, 0x6C80,
00089                                              0x6D00, 0x6D80, 0x4C00, 0x4C80, 0x4D00, 0x6000, 0x4D80, 0x0100, 0x0180, 0x01A0,
00090                                              0x0120, 0x0130, 0x0140, 0x0150, 0x0160, 0x0170, 0x01C0, 0x01D0, 0x01E0, 0x01F0 },
00091                                            { 0x03C0, 0x0C80, 0x0C90, 0x05B0, 0x0330, 0x0340, 0x0350, 0x0360, 0x0368, 0x0250,
00092                                              0x0258, 0x0260, 0x0268, 0x0390, 0x0398, 0x03A0, 0x03A8, 0x03B0, 0x03B8, 0x0290,
00093                                              0x0298, 0x02A0, 0x02A8, 0x02D0, 0x02D8, 0x0320, 0x0328, 0x0100, 0x0180, 0x01A0,
00094                                              0x0120, 0x0130, 0x0140, 0x0150, 0x0160, 0x0170, 0x01C0, 0x01D0, 0x01E0, 0x01F0 }
00095                                          };
00096     static unsigned short mnbit[2][NM] = { { 0xF800, 0xF800, 0xFC00, 0xFE00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
00097                                              0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80,
00098                                              0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFC00, 0xFF80, 0xFFE0, 0xFFE0, 0xFFE0,
00099                                              0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0 },
00100                                            { 0xFFC0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF8, 0xFFF8, 0xFFF8,
00101                                              0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8,
00102                                              0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFE0, 0xFFE0, 0xFFE0,
00103                                              0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0 }
00104                                          };
00105     static unsigned short tmask[2][NT] = { { 0x3500, 0x1C00, 0x7000, 0x8000, 0xB000, 0xC000, 0xE000, 0xF000, 0x9800, 0xA000, 0x3800, 0x4000, 0x2000, 0x0C00, 0xD000, 0xD400,
00106                                              0xA800, 0xAC00, 0x4E00, 0x1800, 0x1000, 0x2E00, 0x0600, 0x0800, 0x5000, 0x5600, 0x2600, 0x4800, 0x3000, 0x0200, 0x0300, 0x1A00,
00107                                              0x1B00, 0x1200, 0x1300, 0x1400, 0x1500, 0x1600, 0x1700, 0x2800, 0x2900, 0x2A00, 0x2B00, 0x2C00, 0x2D00, 0x0400, 0x0500, 0x0A00,
00108                                              0x0B00, 0x5200, 0x5300, 0x5400, 0x5500, 0x2400, 0x2500, 0x5800, 0x5900, 0x5A00, 0x5B00, 0x4A00, 0x4B00, 0x3200, 0x3300, 0x3400 },
00109                                            { 0x0DC0, 0x4000, 0xC000, 0x8000, 0x6000, 0x3000, 0x2000, 0x1800, 0x1400, 0x1000, 0x0800, 0x0A00, 0x0E00, 0x0400, 0x0700, 0x0C00,
00110                                              0x05C0, 0x0600, 0x0200, 0x0CE0, 0x0D00, 0x0D80, 0x06E0, 0x0500, 0x02E0, 0x0300, 0x0CA0, 0x0CB0, 0x0CC0, 0x0CD0, 0x0680, 0x0690,
00111                                              0x06A0, 0x06B0, 0x0D20, 0x0D30, 0x0D40, 0x0D50, 0x0D60, 0x0D70, 0x06C0, 0x06D0, 0x0DA0, 0x0DB0, 0x0540, 0x0550, 0x0560, 0x0570,
00112                                              0x0640, 0x0650, 0x0520, 0x0530, 0x0240, 0x0370, 0x0380, 0x0270, 0x0280, 0x0580, 0x0590, 0x02B0, 0x02C0, 0x05A0, 0x0660, 0x0670 }
00113                                          };
00114     static unsigned short tnbit[2][NT] = { { 0xFF00, 0xFC00, 0xF000, 0xF000, 0xF000, 0xF000, 0xF000, 0xF000, 0xF800, 0xF800, 0xF800, 0xF800, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
00115                                              0xFC00, 0xFC00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFF00, 0xFF00, 0xFF00,
00116                                              0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
00117                                              0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00 },
00118                                            { 0xFFC0, 0xE000, 0xC000, 0xC000, 0xE000, 0xF000, 0xF000, 0xF800, 0xFC00, 0xFC00, 0xFE00, 0xFE00, 0xFE00, 0xFF00, 0xFF00, 0xFF80,
00119                                              0xFFC0, 0xFFC0, 0xFFC0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
00120                                              0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
00121                                              0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0 }
00122                                          };
00123     static unsigned char mask[] = { 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF };
00124     static unsigned long more, type;
00125     register unsigned long lval, i, j, k;
00126     register unsigned short *sdat, sval;
00127     char msg[SLEN];
00128 
00129     if (Comp == RLEComp) {
00130         if (Bits == ((unsigned long)0)) {
00131             more = ((unsigned long)0);
00132             type = ((unsigned long)1);
00133         }
00134         while (more == ((unsigned long)0)) {
00135             type = !type;
00136             do {
00137                 sdat = ((unsigned short *)data) + Bits/((unsigned long)sizeof(*sdat)*BLEN);
00138                 k    = Bits%((unsigned long)sizeof(*sdat)*BLEN);
00139                 sval = sdat[0] << k  |  sdat[1] >> ((unsigned long)sizeof(*sdat)*BLEN-k);
00140                 for (j = ((unsigned long)0); j < ((unsigned long)NM); j += ((unsigned long)1)) {
00141                     if ((sval & mnbit[type][j])  ==  mmask[type][j]) {
00142                         more += (j+((unsigned long)1)) * NT;
00143                         for (sval = mnbit[type][j]; sval > 0; sval <<= 1) {
00144                             Bits += 1;
00145                         }
00146                         break;
00147                     }
00148                 }
00149             } while (j < NM);
00150             sdat = ((unsigned short *)data) + Bits/((unsigned long)sizeof(*sdat)*BLEN);
00151             k    = Bits%((unsigned long)sizeof(*sdat)*BLEN);
00152             sval = sdat[0] << k  |  sdat[1] >> ((unsigned long)sizeof(*sdat)*BLEN-k);
00153             for (j = ((unsigned long)0); j < ((unsigned long)NT); j += ((unsigned long)1)) {
00154                 if ((sval & tnbit[type][j])  ==  tmask[type][j]) {
00155                     more += j;
00156                     for (sval = tnbit[type][j]; sval > 0; sval <<= 1) {
00157                         Bits += 1;
00158                     }
00159                     break;
00160                 }
00161             }
00162             if (j == NT) {
00163                 sprintf(msg," Can't decode RLE-compressed image.");
00164                 MESSAGE('E',msg);
00165                 longjmp(Env,1);
00166             }
00167         }
00168         if (more > 0) {
00169             more -= 1;
00170         }
00171         lval = type;
00172     } else {
00173         lval = ((unsigned long)0);
00174         if (Bits+nbit <= BLEN*DLEN) {
00175             for (i = nbit; i > 0; i -= j) {
00176                 k = Bits % BLEN;
00177                 if (i+k <= BLEN) {
00178                     j = i;
00179                     lval |= ((unsigned long)(data[Bits/BLEN] & (mask[j] >> k))) >> ((long)(BLEN-i-k));
00180                 } else {
00181                     j = BLEN - k;
00182                     lval |= ((unsigned long)(data[Bits/BLEN] & (mask[j] >> k))) >> ((long)(i+k-BLEN));
00183                 }
00184                 Bits += j;
00185             }
00186         } else {
00187             sprintf(msg," Buffer data[%ld] too small.",DLEN);
00188             MESSAGE('E',msg);
00189             longjmp(Env,1);
00190         }
00191     }
00192     if (Flip) {
00193         lval = (((unsigned long)1) << nbit) - lval - ((unsigned long)1);
00194     }
00195     return(lval);
00196 }
00197 
00198 
00199 void UnpackBits(unsigned char *data, unsigned char *datb, short dstBytes) {
00200         char *bp;
00201         long n;
00202         int b;
00203 
00204         bp = (char*) data;
00205         while (dstBytes > 0) {
00206                 n = (long) *bp++;
00207 
00208                 /*
00209                  * Watch out for compilers that
00210                  * don't sign extend chars...
00211                  */
00212                 if (n >= 128)
00213                         n -= 256;
00214                 if (n < 0) {            /* replicate next byte -n+1 times */
00215                         if (n == -128)  /* nop */
00216                                 continue;
00217                         n = -n + 1;
00218                         dstBytes -= n;
00219                         for (b = *bp++; n-- > 0;)
00220                                 *datb++ = b;
00221                 } else {                /* copy next n+1 bytes literally */
00222                         memcpy(datb, bp, ++n);
00223                         datb += n;
00224                         bp += n; dstBytes -= n;
00225                 }
00226         }
00227 }
00228 
00229 
00230 /*-Copyright Information------------------------------------------------------*/
00231 /* Copyright (c) 1993 by the University of Arizona Digital Image Analysis Lab */
00232 /*----------------------------------------------------------------------------*/
00233 /*-General Information--------------------------------------------------------*/
00234 /*                                                                            */
00235 /*   This function reads a TIFF image from disk shorto main memory.             */
00236 /*                                                                            */
00237 /*----------------------------------------------------------------------------*/
00238 /*-Interface Information------------------------------------------------------*/
00239 void TIFF2IMG (
00240 char *name,          /*  I   String, containing the name of the disk file.    */
00241 IMAGE **out          /*  O   Address of a pointer to the image.               */
00242 /*----------------------------------------------------------------------------*/
00243 ) { unsigned char data[DLEN], *datb=NULL, *datPtr;
00244     unsigned long i, j, k, l, m, n;
00245     static char array[] = { 0x00, 0x00, 0x00, 0x01 };
00246     static char *text[] = { "Bilevel", "Grayscale", "Palette", "RGB" };
00247     static unsigned long reqd[] = { 0x00000FBB, 0x00000FBF, 0x00001FBF, 0x00000FFF };
00248     static unsigned long size[] = { 0, 1, 1, 2, 4, 8 };
00249     char msg[SLEN];
00250     short error = 0;
00251     unsigned short *sdata;
00252     unsigned long *ldata;
00253     unsigned long cnt, pos, tag, type, number, address, value, tags, pcnt, bcnt, dcnt;
00254     unsigned long nbnd, nlin, npix, nbit[3], ndat, ntab, tiff, unit;
00255     unsigned long pdat, bdat, ctab[768], *rtab, *gtab, *btab, dstBytes;
00256     double xres, yres;
00257     FILE *fp;
00258 
00259     if (TIMES) TIMING(T_TIFF2IMG);
00260 
00261     if (setjmp(Env) == 0) {
00262 
00263         /* open image file */
00264         if (!(fp=fopen(name,"r"))) {
00265             sprintf(msg," Can't open file %s.",name);
00266             MESSAGE('E',msg);
00267             goto the_end;
00268         }
00269 
00270 
00271         Comp = ((unsigned long)1); tags  = ((unsigned long)0x00000008);
00272         Flip = ((unsigned long)0); tags |= ((unsigned long)0x00000000);
00273         nbnd = ((unsigned long)1); tags |= ((unsigned long)0x00000040);
00274         nlin = ((unsigned long)0); tags |= ((unsigned long)0x00000000);
00275         npix = ((unsigned long)0); tags |= ((unsigned long)0x00000000);
00276        *nbit = ((unsigned long)1); tags |= ((unsigned long)0x00000004);
00277         ndat = ((unsigned long)0); tags |= ((unsigned long)0x00000000);
00278         ntab = ((unsigned long)0); tags |= ((unsigned long)0x00000000);
00279         tiff = ((unsigned long)0); tags |= ((unsigned long)0x00000000);
00280         unit = ((unsigned long)2); tags |= ((unsigned long)0x00000800);
00281 
00282         cnt = ((unsigned long)8);
00283         if (fread(data,(long)cnt,1,fp) != 1) {
00284             sprintf(msg," Can't read TIFF header from file %s. File Manager Error Code: %d.",name,error);
00285             MESSAGE('E',msg);
00286             longjmp(Env,1);
00287         }
00288         value = GetIValue(TSHORT,data);
00289         if (value != LilEndian  &&  value != BigEndian) {
00290             sprintf(msg," Can't read TIFF image with ByteOrder value of %ld.",value);
00291             MESSAGE('E',msg);
00292             longjmp(Env,1);
00293         }
00294         Swap  = GetIValue(TSHORT,data) != (*(unsigned long *)array != 1 ? LilEndian : BigEndian);
00295         value = GetIValue(TSHORT,data+2);
00296         if (value != MagicNumber) {
00297             sprintf(msg," Can't read TIFF image with MagicNumber value of %ld.",value);
00298             MESSAGE('E',msg);
00299             longjmp(Env,1);
00300         }
00301         cnt = ((unsigned long)2);
00302         if ((fseek(fp,(long)GetIValue(TLONG,data+4),SEEK_SET) != 0)  ||  (fread(data,(long)cnt,1,fp) != 1)) {
00303             sprintf(msg," Can't read TIFF header from file %s. File Manager Error Code: %d.",name,error);
00304             MESSAGE('E',msg);
00305             longjmp(Env,1);
00306         }
00307 
00308         for (m = GetIValue(TSHORT,data); m > ((unsigned long)0); m -= ((unsigned long)1)) {
00309 
00310             cnt = ((unsigned long)12);
00311             if (fread(data,(long)cnt,1,fp) != 1) {
00312                 sprintf(msg," Can't read TIFF header from file %s. File Manager Error Code: %d.",name,error);
00313                 MESSAGE('E',msg);
00314                 longjmp(Env,1);
00315             }
00316             pos = ftell(fp);
00317             tag    = GetIValue(TSHORT,data);
00318             type   = GetIValue(TSHORT,data+2);
00319             number = GetIValue(TLONG ,data+4);
00320             cnt    = (long)(size[type] * number);
00321             if (cnt <= ((unsigned long)4)) {
00322                 address = pos-((unsigned long)4);
00323             } else {
00324                 address = GetIValue(TLONG,data+8);
00325                 if (DLEN < cnt+((unsigned long)8)) {
00326                     sprintf(msg," Buffer data[%ld] too small.",DLEN);
00327                     MESSAGE('E',msg);
00328                     longjmp(Env,1);
00329                 }
00330                 if ((fseek(fp,(long)GetIValue(TLONG,data+8),SEEK_SET) != 0)  ||  (fread(data+8,(long)cnt,1,fp) != 1)  ||  (fseek(fp,(long)pos,SEEK_SET) != 0)) {
00331                     sprintf(msg," Can't read TIFF header from file %s. File Manager Error Code: %d.",name,error);
00332                     MESSAGE('E',msg);
00333                     longjmp(Env,1);
00334                 }
00335             }
00336 
00337             switch (tag) {
00338             case NewSubfileType:
00339                 value = GetIValue(type,data+8);
00340                 if (value != ((unsigned long)0)) {
00341                     sprintf(msg," Can't interpret TIFF image with a NewSubfileType value of %ld.",value);
00342                     MESSAGE('E',msg);
00343                     longjmp(Env,1);
00344                 }
00345                 break;
00346             case SubfileType:
00347                 value = GetIValue(type,data+8);
00348                 if (value != ((unsigned long)1)) {
00349                     sprintf(msg," Can't interpret TIFF image with a SubfileType value of %ld.",value);
00350                     MESSAGE('E',msg);
00351                     longjmp(Env,1);
00352                 }
00353                 break;
00354             case ImageWidth:
00355                 npix = GetIValue(type,data+8);
00356                 tags |= ((unsigned long)0x00000001);
00357                 break;
00358             case ImageLength:
00359                 nlin = GetIValue(type,data+8);
00360                 tags |= ((unsigned long)0x00000002);
00361                 break;
00362             case BitsPerSample:
00363                 nbnd = number;
00364                 if (nbnd != ((unsigned long)1)  &&  nbnd != ((unsigned long)3)) {
00365                     sprintf(msg," Can't interpret TIFF image with a SamplesPerPixel value of %ld.",nbnd);
00366                     MESSAGE('E',msg);
00367                     longjmp(Env,1);
00368                 }
00369                 for (i = ((unsigned long)0); i < nbnd; i += ((unsigned long)1)) {
00370                     nbit[i] = GetIValue(type,data+8+i*size[type]);
00371                 }
00372                 tags |= ((unsigned long)0x00000004);
00373                 break;
00374             case Compression:
00375                 Comp = GetIValue(type,data+8);
00376                 if (Comp != NoComp  &&  Comp != RLEComp  &&  Comp != PackBitsComp) {
00377                     sprintf(msg," Can't interpret TIFF image with a Compression value of %ld.",Comp);
00378                     MESSAGE('E',msg);
00379                     longjmp(Env,1);
00380                 }
00381                 tags |= ((unsigned long)0x00000008);
00382                 break;
00383             case PhotometricInterpretation:
00384                 value = GetIValue(type,data+8);
00385                 if (nbnd == ((unsigned long)1)  &&  *nbit == ((unsigned long)1)  &&  (value == ((unsigned long)0)  ||  value == ((unsigned long)1))) {
00386                     tiff = BTIFF;
00387                 } else if (nbnd == ((unsigned long)1)  &&  Comp != RLEComp  &&  (*nbit == ((unsigned long)4)  ||  *nbit == ((unsigned long)8))  &&  (value == ((unsigned long)0)  ||  value == ((unsigned long)1))) {
00388                     tiff = GTIFF;
00389                 } else if (nbnd == ((unsigned long)1)  &&  Comp != RLEComp  &&  (*nbit == ((unsigned long)4)  ||  *nbit == ((unsigned long)8))  &&  value == ((unsigned long)3)) {
00390                     tiff = PTIFF;
00391                 } else if (nbnd == ((unsigned long)3)  &&  Comp != RLEComp  &&  value == ((unsigned long)2)) {
00392                     tiff = RTIFF;
00393                 } else {
00394                     sprintf(msg," Can't interpret TIFF image with a SamplesPerPixel value of %ld, a Compression value of %ld, a BitsPerSample value of %ld, and a PhotometricInterpretation value of %ld.",nbnd,Comp,*nbit,value);
00395                     MESSAGE('E',msg);
00396                     longjmp(Env,1);
00397                 }
00398                 Flip  = (value == ((unsigned long)0)   ||   value == ((unsigned long)1)  &&  Comp == RLEComp);
00399                 tags |= ((unsigned long)0x00000010);
00400                 break;
00401             case Thresholding:
00402                 value = GetIValue(type,data+8);
00403                 if (value != ((unsigned long)1)) {
00404                     sprintf(msg," Can't interpret TIFF image with a Thresholding value of %ld.",value);
00405                     MESSAGE('E',msg);
00406                     longjmp(Env,1);
00407                 }
00408                 break;
00409             case FillOrder:
00410                 value = GetIValue(type,data+8);
00411                 if (value != ((unsigned long)1)) {
00412                     sprintf(msg," Can't interpret TIFF image with a FillOrder value of %ld.",value);
00413                     MESSAGE('E',msg);
00414                     longjmp(Env,1);
00415                 }
00416                 break;
00417             case StripOffsets:
00418                 ndat = number;
00419                 pcnt = size[type];
00420                 pdat = address;
00421                 if (ndat > nlin) {
00422                     sprintf(msg," TIFF image has a StripOffsets number of %ld, but an ImageLength value of %ld.",ndat,nlin);
00423                     MESSAGE('E',msg);
00424                     longjmp(Env,1);
00425                 }
00426                 tags |= ((unsigned long)0x00000020);
00427                 break;
00428             case Orientation:
00429                 value = GetIValue(type,data+8);
00430                 if (value != ((unsigned long)1)) {
00431                     sprintf(msg," TIFF image has an Orientation value of %ld. Image may need to be rotated and/or mirrored.",value);
00432                     MESSAGE('W',msg);
00433                 }
00434                 break;
00435             case SamplesPerPixel:
00436                 value = GetIValue(type,data+8);
00437                 if (value != ((unsigned long)1)  &&  value != ((unsigned long)3)) {
00438                     sprintf(msg," Can't interpret TIFF image with a SamplesPerPixel value of %ld.",value);
00439                     MESSAGE('E',msg);
00440                     longjmp(Env,1);
00441                 } else if (value != nbnd) {
00442                     sprintf(msg," TIFF image has a SamplesPerPixel value of %ld, but a BitsPerSample number of %ld.",value,nbnd);
00443                     MESSAGE('E',msg);
00444                     longjmp(Env,1);
00445                 }
00446                 tags |= ((unsigned long)0x00000040);
00447                 break;
00448             case RowsPerStrip:
00449                 value = GetIValue(type,data+8);
00450                 if (ndat != (int)(((double)nlin+(double)value-1.0)/(double)value)) {
00451                     sprintf(msg," TIFF image has a RowsPerStrip value of %ld, but a StripsPerImage value of %ld and an ImageLength value of %ld.",value,ndat,nlin);
00452                     MESSAGE('E',msg);
00453                     longjmp(Env,1);
00454                 }
00455                 tags |= ((unsigned long)0x00000080);
00456                 break;
00457             case StripByteCounts:
00458                 bcnt = size[type];
00459                 bdat = address;
00460                 if (number != ndat) {
00461                     sprintf(msg," TIFF image has a StripByteCounts number of %ld, but a StripOffsets number of %ld.",number,ndat);
00462                     MESSAGE('E',msg);
00463                     longjmp(Env,1);
00464                 }
00465                 tags |= ((unsigned long)0x00000100);
00466                 break;
00467             case XResolution:
00468                 xres = GetRValue(type,data+8);
00469                 tags |= ((unsigned long)0x00000200);
00470                 break;
00471             case YResolution:
00472                 yres = GetRValue(type,data+8);
00473                 tags |= ((unsigned long)0x00000400);
00474                 break;
00475             case PlanarConfiguration:
00476                 value = GetIValue(type,data+8);
00477                 if (value != ((unsigned long)1)) {
00478                     sprintf(msg," Can't interpret TIFF image with a PlanarConfiguration value of %ld.",value);
00479                     MESSAGE('E',msg);
00480                     longjmp(Env,1);
00481                 }
00482                 break;
00483             case ResolutionUnit:
00484                 unit = GetIValue(type,data+8);
00485                 tags |= ((unsigned long)0x00000800);
00486                 break;
00487             case ColorMap:
00488                 ntab = number;
00489                 if (ntab != ((unsigned long)3)*(((unsigned long)1)<<(*nbit))) {
00490                     sprintf(msg," TIFF image has a ColorMap number of %ld, but a BitsPerSample value of %ld.",ntab,*nbit);
00491                     MESSAGE('E',msg);
00492                     longjmp(Env,1);
00493                 }
00494                 for (i = ((unsigned long)0); i < ntab; i += ((unsigned long)1)) {
00495                     ctab[i] = GetIValue(type,data+8+i*size[type]);
00496                 }
00497                 rtab = ctab + ((unsigned long)0)*(((unsigned long)1)<<(*nbit));
00498                 gtab = ctab + ((unsigned long)1)*(((unsigned long)1)<<(*nbit));
00499                 btab = ctab + ((unsigned long)2)*(((unsigned long)1)<<(*nbit));
00500                 tags |= ((unsigned long)0x00001000);
00501                 break;
00502             default:
00503                 break;
00504             }
00505         }
00506 
00507         if ((tags & reqd[tiff]) != reqd[tiff]) {
00508             sprintf(msg," Missing tags in TIFF image: 0x%08lX.",reqd[tiff]^(tags&reqd[tiff]));
00509             MESSAGE('W',msg);
00510         }
00511 
00512         if (!CHECKIMG(*out)) GETMEM(tiff != PTIFF ? (int)nbnd : 3,(int)nlin,(int)npix,out);
00513         if (!*out) longjmp(Env,1);
00514 
00515         (*out)->nbit = (int)nbit[0];
00516         for (i = m = ((unsigned long)1); i < nbnd; i += ((unsigned long)1)) {
00517             if ((*out)->nbit < (int)nbit[i]) {
00518                 (*out)->nbit = (int)nbit[i];
00519             }
00520             if (nbit[i] != nbit[i-((unsigned long)1)]) {
00521                 m = ((unsigned long)0);
00522             }
00523         }
00524         if (m  &&  *nbit == size[TLONG]*BLEN) {
00525             type = TLONG;
00526         } else if (m  &&  *nbit == size[TSHORT]*BLEN) {
00527             type = TSHORT;
00528         } else {
00529             type = TBYTE;
00530         }
00531 
00532         if (Comp == PackBitsComp) {
00533                 if ((datb = (unsigned char *)malloc(DLEN*sizeof(char))) == NULL) {
00534                 MESSAGE('E'," Memory request failed.");
00535                 longjmp(Env,1);
00536                 }
00537             dstBytes = ((unsigned long)0);
00538             for (i = ((unsigned long)0); i < nbnd; i += ((unsigned long)1)) {
00539                 dstBytes += nbit[i];
00540             }
00541             dstBytes = (dstBytes*npix + 7) / 8;
00542         }
00543 
00544         l = ((unsigned long)0);
00545         m = ((unsigned long)0);
00546         n = ((unsigned long)0);
00547         Bits = ((unsigned long)0);
00548 
00549         for (j = ((unsigned long)0); j < nlin; j += ((unsigned long)1)) {
00550 
00551             l -= Bits;
00552             if (l == ((unsigned long)0)) {
00553                 if (n > ndat) {
00554                     sprintf(msg," Can't read TIFF data from file %s.",name);
00555                     MESSAGE('E',msg);
00556                     longjmp(Env,1);
00557                 } else if ((fseek(fp,(long)(pdat+n*pcnt),SEEK_SET) != 0)  ||  (fread(&address,(long)pcnt,1,fp) != 1)  ||  (fseek(fp,(long)(bdat+n*bcnt),SEEK_SET) != 0)  ||  (fread(&cnt,(long)bcnt,1,fp) != 1)) {
00558                     sprintf(msg," Can't read TIFF data from file %s. File Manager Error Code: %d.",name,error);
00559                     MESSAGE('E',msg);
00560                     longjmp(Env,1);
00561                 }
00562                 if (Swap) {
00563                     address = GetIValue(pcnt == size[TSHORT] ? TSHORT : TLONG,(unsigned char *)&address);
00564                     cnt     = GetIValue(pcnt == size[TSHORT] ? TSHORT : TLONG,(unsigned char *)&cnt    );
00565                 }
00566                 m  = cnt;
00567                 n += ((unsigned long)1);
00568             } else {
00569                 memmove(data,data+Bits,(size_t)l);
00570             }
00571             if (m > ((unsigned long)0)) {
00572                 dcnt = m < DLEN-l ? m : DLEN-l;
00573                 if ((fseek(fp,(long)(address+cnt-m),SEEK_SET) != 0)  ||  (fread(data+1,(long)dcnt,1,fp) != 1)) {
00574                     sprintf(msg," Can't read TIFF data from file %s. File Manager Error Code: %d.",name,error);
00575                     MESSAGE('E',msg);
00576                     longjmp(Env,1);
00577                 }
00578                 if (Swap) {
00579                     if (type == TSHORT) {
00580                         for (sdata = ((unsigned short *)(data+l)); sdata < ((unsigned short *)(data+l+cnt)); sdata++) {
00581                             *sdata = sswap((unsigned char *)sdata);
00582                         }
00583                     } else if (type == TLONG) {
00584                         for (ldata = ((unsigned long *)(data+l)); ldata < ((unsigned long *)(data+l+cnt)); ldata++) {
00585                             *ldata = lswap((unsigned char *)ldata);
00586                         }
00587                     }
00588                 }
00589                 l += dcnt;
00590                 m -= dcnt;
00591             }
00592 
00593             Bits = ((unsigned long)0);
00594             if (Comp != PackBitsComp) {
00595                 datPtr = data;
00596             } else {
00597                 UnpackBits(data,datb,(int)dstBytes);
00598                 datPtr = datb;
00599             }
00600 
00601             switch (tiff) {
00602             case BTIFF:
00603                 for (k = ((unsigned long)0); k < npix; k += ((unsigned long)1)) {
00604                     (*out)->data[0][j][k] = (PIXEL)GetPValue(datPtr,nbit[0]);
00605                 }
00606                 break;
00607             case GTIFF:
00608                 for (k = ((unsigned long)0); k < npix; k += ((unsigned long)1)) {
00609                     (*out)->data[0][j][k] = (PIXEL)GetPValue(datPtr,nbit[0]);
00610                 }
00611                 break;
00612             case PTIFF:
00613                 for (k = ((unsigned long)0); k < npix; k += ((unsigned long)1)) {
00614                     value = GetPValue(datPtr,nbit[0]);
00615                     (*out)->data[0][j][k] = (PIXEL)rtab[value];
00616                     (*out)->data[1][j][k] = (PIXEL)gtab[value];
00617                     (*out)->data[2][j][k] = (PIXEL)btab[value];
00618                 }
00619                 break;
00620             case RTIFF:
00621                 for (k = ((unsigned long)0); k < npix; k += ((unsigned long)1)) {
00622                     for (i = ((unsigned long)0); i < nbnd; i += ((unsigned long)1)) {
00623                         (*out)->data[i][j][k] = (PIXEL)GetPValue(datPtr,nbit[i]);
00624                     }
00625                 }
00626                 break;
00627             default:
00628                 break;
00629             }
00630             Bits = Bits/BLEN + (Bits%BLEN ? ((unsigned long)1) : ((unsigned long)0));
00631             Bits = Bits/size[type] + (Bits%size[type] ? size[type] : ((unsigned long)0));
00632 
00633         }
00634 
00635         if (NAMES) {
00636             RANGE(*out);
00637             MESSAGE('I',"");
00638             MESSAGE('I',"TIFF2IMG");
00639             MESSAGE('I',"");
00640             sprintf(msg," Input file:                                 %s",name);
00641             MESSAGE('I',msg); 
00642             sprintf(msg," Input format:                               TIFF %s",text[tiff]);
00643             MESSAGE('I',msg); 
00644             sprintf(msg," Number of bands, lines, pixels:             %d, %d, %d",(*out)->nbnd,(*out)->nlin,(*out)->npix);
00645             MESSAGE('I',msg);
00646             sprintf(msg," Number of bits/pixel/band:                  %d",(*out)->nbit);
00647             MESSAGE('I',msg);
00648             sprintf(msg," Graylevel minimum, maximum:                 %10.4e, %10.4e",(*out)->gmin,(*out)->gmax);
00649             MESSAGE('I',msg);
00650             MESSAGE('I'," ...............");
00651         }
00652     }
00653 
00654  the_end:
00655     if (fclose(fp)) {
00656         sprintf(msg," Can't close file %s.",name);
00657         MESSAGE('W',msg);
00658     }
00659     if (datb != NULL) {
00660         free(datb);
00661     }
00662     if (TIMES) TIMING(T_EXIT);
00663 
00664 
00665 
00666 }