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
00016 sswap (register unsigned char *cptr)
00017 {
00018   unsigned char cval[2];
00019 
00020   cval[0] = cptr[1];
00021   cval[1] = cptr[0];
00022   return (*(unsigned short *) cval);
00023 }
00024 
00025 static unsigned long
00026 lswap (register unsigned char *cptr)
00027 {
00028   unsigned char cval[4];
00029 
00030   cval[0] = cptr[3];
00031   cval[1] = cptr[2];
00032   cval[2] = cptr[1];
00033   cval[3] = cptr[0];
00034   return (*(unsigned long *) cval);
00035 }
00036 
00037 static unsigned long
00038 GetIValue (unsigned long type, register unsigned char *data)
00039 {
00040   char msg[SLEN];
00041   unsigned long value = ((unsigned long) 0);
00042 
00043   switch (type)
00044     {
00045     case TBYTE:
00046       value = (unsigned long) *(unsigned char *) data;
00047       break;
00048     case TSHORT:
00049       if (!Swap)
00050         {
00051           value = (unsigned long) *(unsigned short *) data;
00052         }
00053       else
00054         {
00055           value = (unsigned long) sswap (data);
00056         }
00057       break;
00058     case TLONG:
00059       if (!Swap)
00060         {
00061           value = (unsigned long) *(unsigned long *) data;
00062         }
00063       else
00064         {
00065           value = (unsigned long) lswap (data);
00066         }
00067       break;
00068     default:
00069       sprintf (msg, " Unknown data type: %ld.", type);
00070       MESSAGE ('E', msg);
00071       longjmp (Env, 1);
00072     }
00073   return (value);
00074 }
00075 
00076 static double
00077 GetRValue (unsigned long type, register unsigned char *data)
00078 {
00079   char msg[SLEN];
00080   double value = 0.0;
00081 
00082   switch (type)
00083     {
00084     case TRATIONAL:
00085       if (!Swap)
00086         {
00087           value =
00088             ((double) *(unsigned long *) data) /
00089             ((double) *(unsigned long *) (data + 4));
00090         }
00091       else
00092         {
00093           value = ((double) lswap (data)) / ((double) lswap (data + 4));
00094         }
00095       break;
00096     default:
00097       sprintf (msg, " Unknown data type: %ld.", type);
00098       MESSAGE ('E', msg);
00099       longjmp (Env, 1);
00100     }
00101   return (value);
00102 }
00103 
00104 #define NM 40
00105 #define NT 64
00106 
00107 static unsigned long
00108 GetPValue (register unsigned char *data, unsigned long nbit)
00109 {
00110   static unsigned short mmask[2][NM] =
00111     { {0xD800, 0x9000, 0x5C00, 0x6E00, 0x3600, 0x3700, 0x6400, 0x6500, 0x6800,
00112        0x6700,
00113        0x6600, 0x6680, 0x6900, 0x6980, 0x6A00, 0x6A80, 0x6B00, 0x6B80, 0x6C00,
00114        0x6C80,
00115        0x6D00, 0x6D80, 0x4C00, 0x4C80, 0x4D00, 0x6000, 0x4D80, 0x0100, 0x0180,
00116        0x01A0,
00117        0x0120, 0x0130, 0x0140, 0x0150, 0x0160, 0x0170, 0x01C0, 0x01D0, 0x01E0,
00118        0x01F0},
00119   {0x03C0, 0x0C80, 0x0C90, 0x05B0, 0x0330, 0x0340, 0x0350, 0x0360, 0x0368,
00120    0x0250,
00121    0x0258, 0x0260, 0x0268, 0x0390, 0x0398, 0x03A0, 0x03A8, 0x03B0, 0x03B8,
00122    0x0290,
00123    0x0298, 0x02A0, 0x02A8, 0x02D0, 0x02D8, 0x0320, 0x0328, 0x0100, 0x0180,
00124    0x01A0,
00125    0x0120, 0x0130, 0x0140, 0x0150, 0x0160, 0x0170, 0x01C0, 0x01D0, 0x01E0,
00126    0x01F0}
00127   };
00128   static unsigned short mnbit[2][NM] =
00129     { {0xF800, 0xF800, 0xFC00, 0xFE00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
00130        0xFF00,
00131        0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80,
00132        0xFF80,
00133        0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFF80, 0xFC00, 0xFF80, 0xFFE0, 0xFFE0,
00134        0xFFE0,
00135        0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
00136        0xFFF0},
00137   {0xFFC0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF8, 0xFFF8,
00138    0xFFF8,
00139    0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8,
00140    0xFFF8,
00141    0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFF8, 0xFFE0, 0xFFE0,
00142    0xFFE0,
00143    0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
00144    0xFFF0}
00145   };
00146   static unsigned short tmask[2][NT] =
00147     { {0x3500, 0x1C00, 0x7000, 0x8000, 0xB000, 0xC000, 0xE000, 0xF000, 0x9800,
00148        0xA000, 0x3800, 0x4000, 0x2000, 0x0C00, 0xD000, 0xD400,
00149        0xA800, 0xAC00, 0x4E00, 0x1800, 0x1000, 0x2E00, 0x0600, 0x0800, 0x5000,
00150        0x5600, 0x2600, 0x4800, 0x3000, 0x0200, 0x0300, 0x1A00,
00151        0x1B00, 0x1200, 0x1300, 0x1400, 0x1500, 0x1600, 0x1700, 0x2800, 0x2900,
00152        0x2A00, 0x2B00, 0x2C00, 0x2D00, 0x0400, 0x0500, 0x0A00,
00153        0x0B00, 0x5200, 0x5300, 0x5400, 0x5500, 0x2400, 0x2500, 0x5800, 0x5900,
00154        0x5A00, 0x5B00, 0x4A00, 0x4B00, 0x3200, 0x3300, 0x3400},
00155   {0x0DC0, 0x4000, 0xC000, 0x8000, 0x6000, 0x3000, 0x2000, 0x1800, 0x1400,
00156    0x1000, 0x0800, 0x0A00, 0x0E00, 0x0400, 0x0700, 0x0C00,
00157    0x05C0, 0x0600, 0x0200, 0x0CE0, 0x0D00, 0x0D80, 0x06E0, 0x0500, 0x02E0,
00158    0x0300, 0x0CA0, 0x0CB0, 0x0CC0, 0x0CD0, 0x0680, 0x0690,
00159    0x06A0, 0x06B0, 0x0D20, 0x0D30, 0x0D40, 0x0D50, 0x0D60, 0x0D70, 0x06C0,
00160    0x06D0, 0x0DA0, 0x0DB0, 0x0540, 0x0550, 0x0560, 0x0570,
00161    0x0640, 0x0650, 0x0520, 0x0530, 0x0240, 0x0370, 0x0380, 0x0270, 0x0280,
00162    0x0580, 0x0590, 0x02B0, 0x02C0, 0x05A0, 0x0660, 0x0670}
00163   };
00164   static unsigned short tnbit[2][NT] =
00165     { {0xFF00, 0xFC00, 0xF000, 0xF000, 0xF000, 0xF000, 0xF000, 0xF000, 0xF800,
00166        0xF800, 0xF800, 0xF800, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
00167        0xFC00, 0xFC00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFE00,
00168        0xFE00, 0xFE00, 0xFE00, 0xFE00, 0xFF00, 0xFF00, 0xFF00,
00169        0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
00170        0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
00171        0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00,
00172        0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00, 0xFF00},
00173   {0xFFC0, 0xE000, 0xC000, 0xC000, 0xE000, 0xF000, 0xF000, 0xF800, 0xFC00,
00174    0xFC00, 0xFE00, 0xFE00, 0xFE00, 0xFF00, 0xFF00, 0xFF80,
00175    0xFFC0, 0xFFC0, 0xFFC0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0,
00176    0xFFE0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
00177    0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
00178    0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
00179    0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
00180    0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0}
00181   };
00182   static unsigned char mask[] =
00183     { 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF };
00184   static unsigned long more, type;
00185   register unsigned long lval, i, j, k;
00186   register unsigned short *sdat, sval;
00187   char msg[SLEN];
00188 
00189   if (Comp == RLEComp)
00190     {
00191       if (Bits == ((unsigned long) 0))
00192         {
00193           more = ((unsigned long) 0);
00194           type = ((unsigned long) 1);
00195         }
00196       while (more == ((unsigned long) 0))
00197         {
00198           type = !type;
00199           do
00200             {
00201               sdat =
00202                 ((unsigned short *) data) +
00203                 Bits / ((unsigned long) sizeof (*sdat) * BLEN);
00204               k = Bits % ((unsigned long) sizeof (*sdat) * BLEN);
00205               sval =
00206                 sdat[0] << k | sdat[1] >> ((unsigned long) sizeof (*sdat) *
00207                                            BLEN - k);
00208               for (j = ((unsigned long) 0); j < ((unsigned long) NM);
00209                    j += ((unsigned long) 1))
00210                 {
00211                   if ((sval & mnbit[type][j]) == mmask[type][j])
00212                     {
00213                       more += (j + ((unsigned long) 1)) * NT;
00214                       for (sval = mnbit[type][j]; sval > 0; sval <<= 1)
00215                         {
00216                           Bits += 1;
00217                         }
00218                       break;
00219                     }
00220                 }
00221             }
00222           while (j < NM);
00223           sdat =
00224             ((unsigned short *) data) +
00225             Bits / ((unsigned long) sizeof (*sdat) * BLEN);
00226           k = Bits % ((unsigned long) sizeof (*sdat) * BLEN);
00227           sval =
00228             sdat[0] << k | sdat[1] >> ((unsigned long) sizeof (*sdat) * BLEN -
00229                                        k);
00230           for (j = ((unsigned long) 0); j < ((unsigned long) NT);
00231                j += ((unsigned long) 1))
00232             {
00233               if ((sval & tnbit[type][j]) == tmask[type][j])
00234                 {
00235                   more += j;
00236                   for (sval = tnbit[type][j]; sval > 0; sval <<= 1)
00237                     {
00238                       Bits += 1;
00239                     }
00240                   break;
00241                 }
00242             }
00243           if (j == NT)
00244             {
00245               sprintf (msg, " Can't decode RLE-compressed image.");
00246               MESSAGE ('E', msg);
00247               longjmp (Env, 1);
00248             }
00249         }
00250       if (more > 0)
00251         {
00252           more -= 1;
00253         }
00254       lval = type;
00255     }
00256   else
00257     {
00258       lval = ((unsigned long) 0);
00259       if (Bits + nbit <= BLEN * DLEN)
00260         {
00261           for (i = nbit; i > 0; i -= j)
00262             {
00263               k = Bits % BLEN;
00264               if (i + k <= BLEN)
00265                 {
00266                   j = i;
00267                   lval |=
00268                     ((unsigned long) (data[Bits / BLEN] & (mask[j] >> k))) >>
00269                     ((long) (BLEN - i - k));
00270                 }
00271               else
00272                 {
00273                   j = BLEN - k;
00274                   lval |=
00275                     ((unsigned long) (data[Bits / BLEN] & (mask[j] >> k))) >>
00276                     ((long) (i + k - BLEN));
00277                 }
00278               Bits += j;
00279             }
00280         }
00281       else
00282         {
00283           sprintf (msg, " Buffer data[%ld] too small.", DLEN);
00284           MESSAGE ('E', msg);
00285           longjmp (Env, 1);
00286         }
00287     }
00288   if (Flip)
00289     {
00290       lval = (((unsigned long) 1) << nbit) - lval - ((unsigned long) 1);
00291     }
00292   return (lval);
00293 }
00294 
00295 void
00296 UnpackBits (unsigned char *data, unsigned char *datb, short dstBytes)
00297 {
00298   char *bp;
00299   long n;
00300   int b;
00301 
00302   bp = (char *) data;
00303   while (dstBytes > 0)
00304     {
00305       n = (long) *bp++;
00306 
00307       /*
00308        * Watch out for compilers that
00309        * don't sign extend chars...
00310        */
00311       if (n >= 128)
00312         n -= 256;
00313       if (n < 0)
00314         {                       /* replicate next byte -n+1 times */
00315           if (n == -128)        /* nop */
00316             continue;
00317           n = -n + 1;
00318           dstBytes -= n;
00319           for (b = *bp++; n-- > 0;)
00320             *datb++ = b;
00321         }
00322       else
00323         {                       /* copy next n+1 bytes literally */
00324           memcpy (datb, bp, ++n);
00325           datb += n;
00326           bp += n;
00327           dstBytes -= n;
00328         }
00329     }
00330 }
00331 
00332 /*-Copyright Information------------------------------------------------------*/
00333 /* Copyright (c) 1993 by the University of Arizona Digital Image Analysis Lab */
00334 /*----------------------------------------------------------------------------*/
00335 /*-General Information--------------------------------------------------------*/
00336 /*                                                                            */
00337 /*   This function reads a TIFF image from disk shorto main memory.             */
00338 /*                                                                            */
00339 /*----------------------------------------------------------------------------*/
00340 /*-Interface Information------------------------------------------------------*/
00341 void
00342 TIFF2IMG (char *name,           /*  I   String, containing the name of the disk file.    */
00343           IMAGE ** out          /*  O   Address of a pointer to the image.               */
00344 /*----------------------------------------------------------------------------*/
00345   )
00346 {
00347   unsigned char data[DLEN], *datb = NULL, *datPtr;
00348   unsigned long i, j, k, l, m, n;
00349   static char array[] = { 0x00, 0x00, 0x00, 0x01 };
00350   static char *text[] = { "Bilevel", "Grayscale", "Palette", "RGB" };
00351   static unsigned long reqd[] =
00352     { 0x00000FBB, 0x00000FBF, 0x00001FBF, 0x00000FFF };
00353   static unsigned long size[] = { 0, 1, 1, 2, 4, 8 };
00354   char msg[SLEN];
00355   short error = 0;
00356   unsigned short *sdata;
00357   unsigned long *ldata;
00358   unsigned long cnt, pos, tag, type, number, address, value, tags, pcnt, bcnt,
00359     dcnt;
00360   unsigned long nbnd, nlin, npix, nbit[3], ndat, ntab, tiff, unit;
00361   unsigned long pdat, bdat, ctab[768], *rtab, *gtab, *btab, dstBytes;
00362   double xres, yres;
00363   FILE *fp;
00364 
00365   if (TIMES)
00366     TIMING (T_TIFF2IMG);
00367 
00368   if (setjmp (Env) == 0)
00369     {
00370 
00371       /* open image file */
00372       if (!(fp = fopen (name, "r")))
00373         {
00374           sprintf (msg, " Can't open file %s.", name);
00375           MESSAGE ('E', msg);
00376           goto the_end;
00377         }
00378 
00379       Comp = ((unsigned long) 1);
00380       tags = ((unsigned long) 0x00000008);
00381       Flip = ((unsigned long) 0);
00382       tags |= ((unsigned long) 0x00000000);
00383       nbnd = ((unsigned long) 1);
00384       tags |= ((unsigned long) 0x00000040);
00385       nlin = ((unsigned long) 0);
00386       tags |= ((unsigned long) 0x00000000);
00387       npix = ((unsigned long) 0);
00388       tags |= ((unsigned long) 0x00000000);
00389       *nbit = ((unsigned long) 1);
00390       tags |= ((unsigned long) 0x00000004);
00391       ndat = ((unsigned long) 0);
00392       tags |= ((unsigned long) 0x00000000);
00393       ntab = ((unsigned long) 0);
00394       tags |= ((unsigned long) 0x00000000);
00395       tiff = ((unsigned long) 0);
00396       tags |= ((unsigned long) 0x00000000);
00397       unit = ((unsigned long) 2);
00398       tags |= ((unsigned long) 0x00000800);
00399 
00400       cnt = ((unsigned long) 8);
00401       if (fread (data, (long) cnt, 1, fp) != 1)
00402         {
00403           sprintf (msg,
00404                    " Can't read TIFF header from file %s. File Manager Error Code: %d.",
00405                    name, error);
00406           MESSAGE ('E', msg);
00407           longjmp (Env, 1);
00408         }
00409       value = GetIValue (TSHORT, data);
00410       if (value != LilEndian && value != BigEndian)
00411         {
00412           sprintf (msg, " Can't read TIFF image with ByteOrder value of %ld.",
00413                    value);
00414           MESSAGE ('E', msg);
00415           longjmp (Env, 1);
00416         }
00417       Swap =
00418         GetIValue (TSHORT,
00419                    data) != (*(unsigned long *) array !=
00420                              1 ? LilEndian : BigEndian);
00421       value = GetIValue (TSHORT, data + 2);
00422       if (value != MagicNumber)
00423         {
00424           sprintf (msg,
00425                    " Can't read TIFF image with MagicNumber value of %ld.",
00426                    value);
00427           MESSAGE ('E', msg);
00428           longjmp (Env, 1);
00429         }
00430       cnt = ((unsigned long) 2);
00431       if ((fseek (fp, (long) GetIValue (TLONG, data + 4), SEEK_SET) != 0)
00432           || (fread (data, (long) cnt, 1, fp) != 1))
00433         {
00434           sprintf (msg,
00435                    " Can't read TIFF header from file %s. File Manager Error Code: %d.",
00436                    name, error);
00437           MESSAGE ('E', msg);
00438           longjmp (Env, 1);
00439         }
00440 
00441       for (m = GetIValue (TSHORT, data); m > ((unsigned long) 0);
00442            m -= ((unsigned long) 1))
00443         {
00444 
00445           cnt = ((unsigned long) 12);
00446           if (fread (data, (long) cnt, 1, fp) != 1)
00447             {
00448               sprintf (msg,
00449                        " Can't read TIFF header from file %s. File Manager Error Code: %d.",
00450                        name, error);
00451               MESSAGE ('E', msg);
00452               longjmp (Env, 1);
00453             }
00454           pos = ftell (fp);
00455           tag = GetIValue (TSHORT, data);
00456           type = GetIValue (TSHORT, data + 2);
00457           number = GetIValue (TLONG, data + 4);
00458           cnt = (long) (size[type] * number);
00459           if (cnt <= ((unsigned long) 4))
00460             {
00461               address = pos - ((unsigned long) 4);
00462             }
00463           else
00464             {
00465               address = GetIValue (TLONG, data + 8);
00466               if (DLEN < cnt + ((unsigned long) 8))
00467                 {
00468                   sprintf (msg, " Buffer data[%ld] too small.", DLEN);
00469                   MESSAGE ('E', msg);
00470                   longjmp (Env, 1);
00471                 }
00472               if ((fseek (fp, (long) GetIValue (TLONG, data + 8), SEEK_SET) !=
00473                    0) || (fread (data + 8, (long) cnt, 1, fp) != 1)
00474                   || (fseek (fp, (long) pos, SEEK_SET) != 0))
00475                 {
00476                   sprintf (msg,
00477                            " Can't read TIFF header from file %s. File Manager Error Code: %d.",
00478                            name, error);
00479                   MESSAGE ('E', msg);
00480                   longjmp (Env, 1);
00481                 }
00482             }
00483 
00484           switch (tag)
00485             {
00486             case NewSubfileType:
00487               value = GetIValue (type, data + 8);
00488               if (value != ((unsigned long) 0))
00489                 {
00490                   sprintf (msg,
00491                            " Can't interpret TIFF image with a NewSubfileType value of %ld.",
00492                            value);
00493                   MESSAGE ('E', msg);
00494                   longjmp (Env, 1);
00495                 }
00496               break;
00497             case SubfileType:
00498               value = GetIValue (type, data + 8);
00499               if (value != ((unsigned long) 1))
00500                 {
00501                   sprintf (msg,
00502                            " Can't interpret TIFF image with a SubfileType value of %ld.",
00503                            value);
00504                   MESSAGE ('E', msg);
00505                   longjmp (Env, 1);
00506                 }
00507               break;
00508             case ImageWidth:
00509               npix = GetIValue (type, data + 8);
00510               tags |= ((unsigned long) 0x00000001);
00511               break;
00512             case ImageLength:
00513               nlin = GetIValue (type, data + 8);
00514               tags |= ((unsigned long) 0x00000002);
00515               break;
00516             case BitsPerSample:
00517               nbnd = number;
00518               if (nbnd != ((unsigned long) 1) && nbnd != ((unsigned long) 3))
00519                 {
00520                   sprintf (msg,
00521                            " Can't interpret TIFF image with a SamplesPerPixel value of %ld.",
00522                            nbnd);
00523                   MESSAGE ('E', msg);
00524                   longjmp (Env, 1);
00525                 }
00526               for (i = ((unsigned long) 0); i < nbnd;
00527                    i += ((unsigned long) 1))
00528                 {
00529                   nbit[i] = GetIValue (type, data + 8 + i * size[type]);
00530                 }
00531               tags |= ((unsigned long) 0x00000004);
00532               break;
00533             case Compression:
00534               Comp = GetIValue (type, data + 8);
00535               if (Comp != NoComp && Comp != RLEComp && Comp != PackBitsComp)
00536                 {
00537                   sprintf (msg,
00538                            " Can't interpret TIFF image with a Compression value of %ld.",
00539                            Comp);
00540                   MESSAGE ('E', msg);
00541                   longjmp (Env, 1);
00542                 }
00543               tags |= ((unsigned long) 0x00000008);
00544               break;
00545             case PhotometricInterpretation:
00546               value = GetIValue (type, data + 8);
00547               if (nbnd == ((unsigned long) 1) && *nbit == ((unsigned long) 1)
00548                   && (value == ((unsigned long) 0)
00549                       || value == ((unsigned long) 1)))
00550                 {
00551                   tiff = BTIFF;
00552                 }
00553               else if (nbnd == ((unsigned long) 1) && Comp != RLEComp
00554                        && (*nbit == ((unsigned long) 4)
00555                            || *nbit == ((unsigned long) 8))
00556                        && (value == ((unsigned long) 0)
00557                            || value == ((unsigned long) 1)))
00558                 {
00559                   tiff = GTIFF;
00560                 }
00561               else if (nbnd == ((unsigned long) 1) && Comp != RLEComp
00562                        && (*nbit == ((unsigned long) 4)
00563                            || *nbit == ((unsigned long) 8))
00564                        && value == ((unsigned long) 3))
00565                 {
00566                   tiff = PTIFF;
00567                 }
00568               else if (nbnd == ((unsigned long) 3) && Comp != RLEComp
00569                        && value == ((unsigned long) 2))
00570                 {
00571                   tiff = RTIFF;
00572                 }
00573               else
00574                 {
00575                   sprintf (msg,
00576                            " 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.",
00577                            nbnd, Comp, *nbit, value);
00578                   MESSAGE ('E', msg);
00579                   longjmp (Env, 1);
00580                 }
00581               Flip = (value == ((unsigned long) 0)
00582                       || value == ((unsigned long) 1) && Comp == RLEComp);
00583               tags |= ((unsigned long) 0x00000010);
00584               break;
00585             case Thresholding:
00586               value = GetIValue (type, data + 8);
00587               if (value != ((unsigned long) 1))
00588                 {
00589                   sprintf (msg,
00590                            " Can't interpret TIFF image with a Thresholding value of %ld.",
00591                            value);
00592                   MESSAGE ('E', msg);
00593                   longjmp (Env, 1);
00594                 }
00595               break;
00596             case FillOrder:
00597               value = GetIValue (type, data + 8);
00598               if (value != ((unsigned long) 1))
00599                 {
00600                   sprintf (msg,
00601                            " Can't interpret TIFF image with a FillOrder value of %ld.",
00602                            value);
00603                   MESSAGE ('E', msg);
00604                   longjmp (Env, 1);
00605                 }
00606               break;
00607             case StripOffsets:
00608               ndat = number;
00609               pcnt = size[type];
00610               pdat = address;
00611               if (ndat > nlin)
00612                 {
00613                   sprintf (msg,
00614                            " TIFF image has a StripOffsets number of %ld, but an ImageLength value of %ld.",
00615                            ndat, nlin);
00616                   MESSAGE ('E', msg);
00617                   longjmp (Env, 1);
00618                 }
00619               tags |= ((unsigned long) 0x00000020);
00620               break;
00621             case Orientation:
00622               value = GetIValue (type, data + 8);
00623               if (value != ((unsigned long) 1))
00624                 {
00625                   sprintf (msg,
00626                            " TIFF image has an Orientation value of %ld. Image may need to be rotated and/or mirrored.",
00627                            value);
00628                   MESSAGE ('W', msg);
00629                 }
00630               break;
00631             case SamplesPerPixel:
00632               value = GetIValue (type, data + 8);
00633               if (value != ((unsigned long) 1)
00634                   && value != ((unsigned long) 3))
00635                 {
00636                   sprintf (msg,
00637                            " Can't interpret TIFF image with a SamplesPerPixel value of %ld.",
00638                            value);
00639                   MESSAGE ('E', msg);
00640                   longjmp (Env, 1);
00641                 }
00642               else if (value != nbnd)
00643                 {
00644                   sprintf (msg,
00645                            " TIFF image has a SamplesPerPixel value of %ld, but a BitsPerSample number of %ld.",
00646                            value, nbnd);
00647                   MESSAGE ('E', msg);
00648                   longjmp (Env, 1);
00649                 }
00650               tags |= ((unsigned long) 0x00000040);
00651               break;
00652             case RowsPerStrip:
00653               value = GetIValue (type, data + 8);
00654               if (ndat !=
00655                   (int) (((double) nlin + (double) value -
00656                           1.0) / (double) value))
00657                 {
00658                   sprintf (msg,
00659                            " TIFF image has a RowsPerStrip value of %ld, but a StripsPerImage value of %ld and an ImageLength value of %ld.",
00660                            value, ndat, nlin);
00661                   MESSAGE ('E', msg);
00662                   longjmp (Env, 1);
00663                 }
00664               tags |= ((unsigned long) 0x00000080);
00665               break;
00666             case StripByteCounts:
00667               bcnt = size[type];
00668               bdat = address;
00669               if (number != ndat)
00670                 {
00671                   sprintf (msg,
00672                            " TIFF image has a StripByteCounts number of %ld, but a StripOffsets number of %ld.",
00673                            number, ndat);
00674                   MESSAGE ('E', msg);
00675                   longjmp (Env, 1);
00676                 }
00677               tags |= ((unsigned long) 0x00000100);
00678               break;
00679             case XResolution:
00680               xres = GetRValue (type, data + 8);
00681               tags |= ((unsigned long) 0x00000200);
00682               break;
00683             case YResolution:
00684               yres = GetRValue (type, data + 8);
00685               tags |= ((unsigned long) 0x00000400);
00686               break;
00687             case PlanarConfiguration:
00688               value = GetIValue (type, data + 8);
00689               if (value != ((unsigned long) 1))
00690                 {
00691                   sprintf (msg,
00692                            " Can't interpret TIFF image with a PlanarConfiguration value of %ld.",
00693                            value);
00694                   MESSAGE ('E', msg);
00695                   longjmp (Env, 1);
00696                 }
00697               break;
00698             case ResolutionUnit:
00699               unit = GetIValue (type, data + 8);
00700               tags |= ((unsigned long) 0x00000800);
00701               break;
00702             case ColorMap:
00703               ntab = number;
00704               if (ntab !=
00705                   ((unsigned long) 3) * (((unsigned long) 1) << (*nbit)))
00706                 {
00707                   sprintf (msg,
00708                            " TIFF image has a ColorMap number of %ld, but a BitsPerSample value of %ld.",
00709                            ntab, *nbit);
00710                   MESSAGE ('E', msg);
00711                   longjmp (Env, 1);
00712                 }
00713               for (i = ((unsigned long) 0); i < ntab;
00714                    i += ((unsigned long) 1))
00715                 {
00716                   ctab[i] = GetIValue (type, data + 8 + i * size[type]);
00717                 }
00718               rtab =
00719                 ctab + ((unsigned long) 0) * (((unsigned long) 1) << (*nbit));
00720               gtab =
00721                 ctab + ((unsigned long) 1) * (((unsigned long) 1) << (*nbit));
00722               btab =
00723                 ctab + ((unsigned long) 2) * (((unsigned long) 1) << (*nbit));
00724               tags |= ((unsigned long) 0x00001000);
00725               break;
00726             default:
00727               break;
00728             }
00729         }
00730 
00731       if ((tags & reqd[tiff]) != reqd[tiff])
00732         {
00733           sprintf (msg, " Missing tags in TIFF image: 0x%08lX.",
00734                    reqd[tiff] ^ (tags & reqd[tiff]));
00735           MESSAGE ('W', msg);
00736         }
00737 
00738       if (!CHECKIMG (*out))
00739         GETMEM (tiff != PTIFF ? (int) nbnd : 3, (int) nlin, (int) npix, out);
00740       if (!*out)
00741         longjmp (Env, 1);
00742 
00743       (*out)->nbit = (int) nbit[0];
00744       for (i = m = ((unsigned long) 1); i < nbnd; i += ((unsigned long) 1))
00745         {
00746           if ((*out)->nbit < (int) nbit[i])
00747             {
00748               (*out)->nbit = (int) nbit[i];
00749             }
00750           if (nbit[i] != nbit[i - ((unsigned long) 1)])
00751             {
00752               m = ((unsigned long) 0);
00753             }
00754         }
00755       if (m && *nbit == size[TLONG] * BLEN)
00756         {
00757           type = TLONG;
00758         }
00759       else if (m && *nbit == size[TSHORT] * BLEN)
00760         {
00761           type = TSHORT;
00762         }
00763       else
00764         {
00765           type = TBYTE;
00766         }
00767 
00768       if (Comp == PackBitsComp)
00769         {
00770           if ((datb =
00771                (unsigned char *) malloc (DLEN * sizeof (char))) == NULL)
00772             {
00773               MESSAGE ('E', " Memory request failed.");
00774               longjmp (Env, 1);
00775             }
00776           dstBytes = ((unsigned long) 0);
00777           for (i = ((unsigned long) 0); i < nbnd; i += ((unsigned long) 1))
00778             {
00779               dstBytes += nbit[i];
00780             }
00781           dstBytes = (dstBytes * npix + 7) / 8;
00782         }
00783 
00784       l = ((unsigned long) 0);
00785       m = ((unsigned long) 0);
00786       n = ((unsigned long) 0);
00787       Bits = ((unsigned long) 0);
00788 
00789       for (j = ((unsigned long) 0); j < nlin; j += ((unsigned long) 1))
00790         {
00791 
00792           l -= Bits;
00793           if (l == ((unsigned long) 0))
00794             {
00795               if (n > ndat)
00796                 {
00797                   sprintf (msg, " Can't read TIFF data from file %s.", name);
00798                   MESSAGE ('E', msg);
00799                   longjmp (Env, 1);
00800                 }
00801               else if ((fseek (fp, (long) (pdat + n * pcnt), SEEK_SET) != 0)
00802                        || (fread (&address, (long) pcnt, 1, fp) != 1)
00803                        || (fseek (fp, (long) (bdat + n * bcnt), SEEK_SET) !=
00804                            0) || (fread (&cnt, (long) bcnt, 1, fp) != 1))
00805                 {
00806                   sprintf (msg,
00807                            " Can't read TIFF data from file %s. File Manager Error Code: %d.",
00808                            name, error);
00809                   MESSAGE ('E', msg);
00810                   longjmp (Env, 1);
00811                 }
00812               if (Swap)
00813                 {
00814                   address =
00815                     GetIValue (pcnt == size[TSHORT] ? TSHORT : TLONG,
00816                                (unsigned char *) &address);
00817                   cnt =
00818                     GetIValue (pcnt == size[TSHORT] ? TSHORT : TLONG,
00819                                (unsigned char *) &cnt);
00820                 }
00821               m = cnt;
00822               n += ((unsigned long) 1);
00823             }
00824           else
00825             {
00826               memmove (data, data + Bits, (size_t) l);
00827             }
00828           if (m > ((unsigned long) 0))
00829             {
00830               dcnt = m < DLEN - l ? m : DLEN - l;
00831               if ((fseek (fp, (long) (address + cnt - m), SEEK_SET) != 0)
00832                   || (fread (data + 1, (long) dcnt, 1, fp) != 1))
00833                 {
00834                   sprintf (msg,
00835                            " Can't read TIFF data from file %s. File Manager Error Code: %d.",
00836                            name, error);
00837                   MESSAGE ('E', msg);
00838                   longjmp (Env, 1);
00839                 }
00840               if (Swap)
00841                 {
00842                   if (type == TSHORT)
00843                     {
00844                       for (sdata = ((unsigned short *) (data + l));
00845                            sdata < ((unsigned short *) (data + l + cnt));
00846                            sdata++)
00847                         {
00848                           *sdata = sswap ((unsigned char *) sdata);
00849                         }
00850                     }
00851                   else if (type == TLONG)
00852                     {
00853                       for (ldata = ((unsigned long *) (data + l));
00854                            ldata < ((unsigned long *) (data + l + cnt));
00855                            ldata++)
00856                         {
00857                           *ldata = lswap ((unsigned char *) ldata);
00858                         }
00859                     }
00860                 }
00861               l += dcnt;
00862               m -= dcnt;
00863             }
00864 
00865           Bits = ((unsigned long) 0);
00866           if (Comp != PackBitsComp)
00867             {
00868               datPtr = data;
00869             }
00870           else
00871             {
00872               UnpackBits (data, datb, (int) dstBytes);
00873               datPtr = datb;
00874             }
00875 
00876           switch (tiff)
00877             {
00878             case BTIFF:
00879               for (k = ((unsigned long) 0); k < npix;
00880                    k += ((unsigned long) 1))
00881                 {
00882                   (*out)->data[0][j][k] = (PIXEL) GetPValue (datPtr, nbit[0]);
00883                 }
00884               break;
00885             case GTIFF:
00886               for (k = ((unsigned long) 0); k < npix;
00887                    k += ((unsigned long) 1))
00888                 {
00889                   (*out)->data[0][j][k] = (PIXEL) GetPValue (datPtr, nbit[0]);
00890                 }
00891               break;
00892             case PTIFF:
00893               for (k = ((unsigned long) 0); k < npix;
00894                    k += ((unsigned long) 1))
00895                 {
00896                   value = GetPValue (datPtr, nbit[0]);
00897                   (*out)->data[0][j][k] = (PIXEL) rtab[value];
00898                   (*out)->data[1][j][k] = (PIXEL) gtab[value];
00899                   (*out)->data[2][j][k] = (PIXEL) btab[value];
00900                 }
00901               break;
00902             case RTIFF:
00903               for (k = ((unsigned long) 0); k < npix;
00904                    k += ((unsigned long) 1))
00905                 {
00906                   for (i = ((unsigned long) 0); i < nbnd;
00907                        i += ((unsigned long) 1))
00908                     {
00909                       (*out)->data[i][j][k] =
00910                         (PIXEL) GetPValue (datPtr, nbit[i]);
00911                     }
00912                 }
00913               break;
00914             default:
00915               break;
00916             }
00917           Bits =
00918             Bits / BLEN +
00919             (Bits % BLEN ? ((unsigned long) 1) : ((unsigned long) 0));
00920           Bits =
00921             Bits / size[type] +
00922             (Bits % size[type] ? size[type] : ((unsigned long) 0));
00923 
00924         }
00925 
00926       if (NAMES)
00927         {
00928           RANGE (*out);
00929           MESSAGE ('I', "");
00930           MESSAGE ('I', "TIFF2IMG");
00931           MESSAGE ('I', "");
00932           sprintf (msg, " Input file:                                 %s",
00933                    name);
00934           MESSAGE ('I', msg);
00935           sprintf (msg,
00936                    " Input format:                               TIFF %s",
00937                    text[tiff]);
00938           MESSAGE ('I', msg);
00939           sprintf (msg,
00940                    " Number of bands, lines, pixels:             %d, %d, %d",
00941                    (*out)->nbnd, (*out)->nlin, (*out)->npix);
00942           MESSAGE ('I', msg);
00943           sprintf (msg, " Number of bits/pixel/band:                  %d",
00944                    (*out)->nbit);
00945           MESSAGE ('I', msg);
00946           sprintf (msg,
00947                    " Graylevel minimum, maximum:                 %10.4e, %10.4e",
00948                    (*out)->gmin, (*out)->gmax);
00949           MESSAGE ('I', msg);
00950           MESSAGE ('I', " ...............");
00951         }
00952     }
00953 
00954 the_end:
00955   if (fclose (fp))
00956     {
00957       sprintf (msg, " Can't close file %s.", name);
00958       MESSAGE ('W', msg);
00959     }
00960   if (datb != NULL)
00961     {
00962       free (datb);
00963     }
00964   if (TIMES)
00965     TIMING (T_EXIT);
00966 
00967 }