home *** CD-ROM | disk | FTP | other *** search
/ Der Mediaplex Sampler - Die 6 von Plex / 6_v_plex.zip / 6_v_plex / DISK5 / WIN_12 / IDEPIX2.ZIP / TIFFACS.ZIP / READIMAG.C < prev    next >
C/C++ Source or Header  |  1993-06-26  |  18KB  |  705 lines
  1. /*-------------------------------------------------------
  2.  
  3.     T I F F A C S : Unterstⁿtzungsroutinen fⁿr TIFF-Dateien
  4.             Ursprⁿnglich von Aldus, von mir auf dem
  5.             Walnut-Creek - Source-Code-ROM gefunden.
  6.  
  7.             Der ursprⁿngliche Source ist TIFF 4.0 und
  8.             auch ansonsten ein ziemlicher Mⁿll.
  9.  
  10.             Diese Version hat Funktionsprototypen und
  11.             ein paar Fehler weniger, aber im Grunde ist
  12.             sie auch ein ziemlicher Mⁿll.
  13.  
  14.             Im Mircosoft System Journal 4/93 ist eine ganz
  15.             brauchbare TIF-Routine dabei, aber eben nicht PD
  16.  
  17.             Bernd Herd
  18.             Rudolf Virchow Str. 8
  19.             6842 Bⁿrstadt
  20.             06206/79222
  21.  
  22.        R E A D I M A G :read_imag  liest einen Bildausschnitt aus
  23.                    der TIFF-Datei, streifenⁿbergreifend,
  24.                                    dekomprimierend...
  25.  
  26.   -------------------------------------------------------------*/
  27.  
  28. /* the new improved read image.  Reads and holds in memory the strip
  29.    tables.  Should be 40-50 percent faster than the old readimage */
  30.  
  31. /* modified 1/12/88 by BGM  To handle default tag values for various */
  32. /* nonessiential tags and motorola files.  To become compatable with */
  33. /* proposed tiff specification, Still need to add code which will    */
  34. /* simulate the presense of the Strip byte count tables.             */
  35.  
  36. #include <windows.h>
  37. #include <io.h>
  38. #include <string.h>
  39. #pragma hdrstop
  40. #include "tiff.h"
  41. #include "tiffi.h"
  42.  
  43.  
  44.  
  45. //----------------- Funktionsprototypen -----------------------
  46. int image_att_read(SHORT fhandle, SHORT fdtype);
  47.  
  48.  
  49. LONG far *sbc_table = 0;
  50. LONG far *so_table = 0;
  51. LONGPTR    decblk = 0;
  52. LONGPTR decblk2 = 0;
  53. SHORT    l_compression = 0;
  54.  
  55. LONG    maxbytesstrip = 0;
  56.  
  57. extern SHORT    readimg_handle;
  58. static    DWORD    width;
  59. static    DWORD    height;
  60. static    SHORT    bits_per_sample;
  61. static    SHORT    samples_per_pixel;
  62. static    LONG    rows_per_strip;
  63. static    SHORT    bytes_per_line;
  64. static     LONG    number_strips;
  65. static  LONG    end_strip_lines;        /* lines in last strip */
  66. static  LONG    old_start;
  67. static    SHORT    one_strip_image;
  68.  
  69.  
  70. /* function return values */
  71. LONG  read_image( SHORT   fhandle,            // Dateihandle der offenen TIF-Datei
  72.           SHORT   fdtype,        // zu lesender Subfile-Typ
  73.           SHORT   plane,        // Gerade zu bearbeitendes Plane (Farbebene)
  74.           LONG    startpos,        // 1. zu bearbeitende Zeile
  75.           LONG    numlines,        // Anzahl zu bearbeitende Zeilen
  76.           LONGPTR buffer,        // Ergebnispuffer
  77.           LONG    max_length)        // Gr÷▀e der Puffers
  78. {
  79.     /* define the attributes of this image */
  80.  
  81. LONG    start_strip;
  82. LONG    end_strip;
  83. LONG    startoffset;
  84. LONG    endoffset;
  85. LONG    seek_addr;
  86. LONG    bytes_to_read;
  87. LONG     ldc;        /* length decompressed */
  88. LONG    temp;
  89. LONG    endflag;    /* use the end_strip_lines variable */
  90.  
  91. if(fhandle != readimg_handle) {  /* first time through */
  92.                 /* with this image */
  93.  
  94.     readimg_handle = fhandle;
  95.  
  96.     /* go get the attributes of this image */
  97.  
  98.     if(!image_att_read(fhandle,fdtype)) {
  99.         return(0);
  100.     }
  101.     /* find out how many lines are in the last strip */
  102.     if((end_strip_lines = (height/*-1*/) % rows_per_strip) == 0 ) {
  103.         end_strip_lines = rows_per_strip;
  104.     }
  105.  
  106. } /* and that concludes the set up processing */
  107.  
  108. /* once the setup processing is done, start computing the parameters
  109.     for this particular read */
  110.  
  111.  
  112. /* compute strip number to start reading at */
  113.  
  114. start_strip = startpos/rows_per_strip;
  115. startoffset = (LONG)(startpos%rows_per_strip) * bytes_per_line;
  116.  
  117. /* compute end strip */
  118.  
  119. end_strip = (startpos +numlines-1) /rows_per_strip;
  120. endoffset = ((startpos + numlines-1) % rows_per_strip) * bytes_per_line;
  121.  
  122. /* make sure that the user has not asked for more that 64k of data */
  123. /* and that both strips are contained in the file */
  124.  
  125. endflag = 0;
  126. if(end_strip >= number_strips-1) {
  127.     end_strip = number_strips -1;
  128.     endflag = 1;
  129. }
  130.  
  131. if(start_strip> number_strips)
  132.     return(0);
  133.  
  134. if((temp = numlines * bytes_per_line) > max_length )
  135.     return(0);
  136.  
  137. if(temp > 65535)
  138.     return(0);
  139.  
  140. /* now read in the data.  There are 8 cases that can occure during 
  141.        a read.  they are:
  142.  
  143.     1. strip uncompressed, rows contained in one strip.
  144.     2. strip uncompressed, rows consume one strip
  145.     3. strip uncompressed, rows cross strip boundry
  146.     4. strip uncompressed, rows cross more than one strip
  147.         boundry.
  148.  
  149.     5. strip compressed, rows contained in one strip.
  150.     6. strip compressed, rows consume one strip
  151.     7. strip compressed, rows cross strip boundry.
  152.     8. strip compressed, rows cross more than one strip
  153.         boundry.
  154.  
  155. have I forgot any thing?  The method of reading chosen here,
  156. allows future compression schemes to be added to the routine
  157. very easily.
  158.  */
  159.  
  160. if(start_strip == end_strip) {
  161.     /* the requested image rows are contained in the same 
  162.         strip */
  163.     switch(l_compression) {  /* do things differently */
  164.                 /* if the image is compressed */
  165.     case PACK_TIGHTLY:
  166.         /* read just the bytes needed.  case 1 is no */
  167.         /* compression */
  168.         /* compute seek address */
  169.         seek_addr = so_table[start_strip] + startoffset;
  170.         if(lseek(fhandle,seek_addr,0) != seek_addr) {
  171.             /* error in reading file */
  172.             return(0);
  173.         }
  174.  
  175.         bytes_to_read= endoffset - startoffset + bytes_per_line; 
  176.  
  177.         if(tlRead(fhandle,buffer,(SHORT)bytes_to_read)!=(SHORT)bytes_to_read) {
  178.             /* error in reading file */
  179.             return(0);
  180.         }
  181.         break;
  182.  
  183.     case ONE_D_MOD_HUFFMAN:
  184.         if(start_strip != old_start) {
  185.             old_start = start_strip;
  186.             seek_addr = so_table[start_strip];
  187.  
  188.             if(lseek(fhandle,seek_addr,0) != seek_addr) {
  189.                 /* error in reading file */
  190.                 return(0);
  191.             }
  192.             
  193.             if(tlRead(fhandle,decblk2,(SHORT)sbc_table[start_strip])
  194.                      != (SHORT)sbc_table[start_strip]){
  195.                 /* error in reading the file */
  196.                 return(0);
  197.             }
  198.     
  199.     /* now, decompress the buffer */
  200.  
  201.             if(endflag && start_strip == number_strips -1) {
  202.                 temp = end_strip_lines;
  203.             } else {
  204.                 temp = rows_per_strip;
  205.             }
  206.  
  207.             ldc = decompress_block(decblk,decblk2,(SHORT) width,
  208.                 temp,sbc_table[start_strip]);
  209.  
  210.     /* check here to make sure that the compression 
  211.      * algorithim decompressed the entire strip */
  212.  
  213.             if(ldc != temp * bytes_per_line) {
  214.                 return(0);
  215.             }
  216.         }
  217.     /* the block is in memory already */
  218.     /* so just move the requested line out */        
  219.  
  220.         bigcopy(buffer,(LONGPTR)&decblk[startoffset],
  221.             endoffset - startoffset + bytes_per_line);
  222.         break;
  223.  
  224.  
  225.     case PACKBITS:             // Packbits-Kompression
  226.         if(start_strip != old_start) {
  227.             old_start = start_strip;
  228.             seek_addr = so_table[start_strip];
  229.  
  230.             if(lseek(fhandle,seek_addr,0) != seek_addr) {
  231.                 /* error in reading file */
  232.                 return(0);
  233.             }
  234.             
  235.             if(tlRead(fhandle,decblk2,(SHORT)sbc_table[start_strip])
  236.                      != (SHORT)sbc_table[start_strip]){
  237.                 /* error in reading the file */
  238.                 return(0);
  239.             }
  240.     
  241.     /* now, decompress the buffer */
  242.  
  243.             if(endflag && start_strip == number_strips -1) {
  244.                 temp = end_strip_lines;
  245.             } else {
  246.                 temp = rows_per_strip;
  247.             }
  248.  
  249.             if ( !UnpackBits( decblk2, decblk, temp * bytes_per_line) )
  250.                                 return 0;
  251. /*            ldc = decompress_block(decblk,decblk2,width,
  252.                 temp,sbc_table[start_strip]);
  253.  
  254.     * check here to make sure that the compression 
  255.      * algorithim decompressed the entire strip *
  256.  
  257.             if(ldc != temp * bytes_per_line) {
  258.                 return(0);
  259.             } */
  260.         }
  261.     /* the block is in memory already */
  262.     /* so just move the requested line out */        
  263.  
  264.         bigcopy(buffer,(LONGPTR)&decblk[startoffset],
  265.             endoffset - startoffset + bytes_per_line);
  266.         break;
  267.     }
  268.  
  269. } else {
  270.     /* requested rows cross strip boundry. */
  271.     /* position file pointer to requested start strip */
  272.     switch(l_compression) {  /* do things differently */
  273.                 /* if the image is compressed */
  274.     case PACK_TIGHTLY:
  275.         /* read from the start address, to the end of the strip */
  276.         /* compute seek address */
  277.         seek_addr = so_table[start_strip] + startoffset;
  278.         if(lseek(fhandle,seek_addr,0) != seek_addr) {
  279.             /* error in reading file */
  280.             return(0);
  281.         }
  282.  
  283.         bytes_to_read= sbc_table[start_strip] - startoffset;
  284.  
  285.         if(tlRead(fhandle,buffer,(SHORT)bytes_to_read)!=(SHORT)bytes_to_read) {
  286.             /* error in reading file */
  287.             return(0);
  288.         }
  289.  
  290.         /* update the buffer to point to */
  291.         /* the next area to read */
  292.  
  293.         buffer += bytes_to_read;
  294.  
  295.         /* now read as many strips as needed to get the
  296.          * required lines */
  297.  
  298.         for(start_strip++;start_strip<end_strip;start_strip++) {
  299.             if(lseek(fhandle,so_table[start_strip],0)
  300.                      != so_table[start_strip]){
  301.                 /* seek failed, return bad */
  302.                 return(0);
  303.             }
  304.  
  305.             if((LONG)tlRead(fhandle,buffer,sbc_table[start_strip])
  306.                      != sbc_table[start_strip]) {
  307.                 /* read failed, return bad */
  308.                 return(0);
  309.             }
  310.  
  311.             buffer += sbc_table[start_strip];
  312.         }
  313.  
  314.         /* now read the tail end */
  315.  
  316.         bytes_to_read= endoffset;
  317.  
  318.         if(        //        lseek(fhandle,buffer,so_table[start_strip]) // sieht unsinnig aus ...
  319.            lseek(fhandle,so_table[start_strip],0) // so vielleicht besser ?
  320.              != so_table[start_strip]){
  321.             /* seek failed */
  322.             return(0);
  323.         }
  324.  
  325.         if(tlRead(fhandle,buffer,(SHORT)bytes_to_read)!=(SHORT)bytes_to_read) {
  326.             /* bad read */
  327.             return(0);
  328.         }
  329.         break;
  330.  
  331.     case ONE_D_MOD_HUFFMAN:
  332.         seek_addr = so_table[start_strip];
  333.  
  334.         if(lseek(fhandle,seek_addr,0) != seek_addr) {
  335.             /* error in reading file */
  336.             return(0);
  337.         }
  338.         
  339.         if((LONG)tlRead(fhandle,decblk2,sbc_table[start_strip])
  340.             != sbc_table[start_strip]){
  341.             /* error in reading the file */
  342.             return(0);
  343.         }
  344.  
  345. /* now, decompress the buffer */
  346.  
  347.         
  348.         if(endflag && start_strip == number_strips -1) {
  349.             temp = end_strip_lines;
  350.         } else {
  351.             temp = rows_per_strip;
  352.         }
  353.         ldc = decompress_block(decblk,decblk2,(SHORT) width,
  354.                 temp,sbc_table[start_strip]);
  355.  
  356. /* check here to make sure that the compression algorithim
  357.  * decompressed the entire strip */
  358.  
  359.         if(ldc != temp * bytes_per_line) {
  360.             return(0);
  361.         }
  362.  
  363.         
  364.         /* move the starting part of the buffer to memory */
  365.  
  366.         bigcopy(buffer,(LONGPTR)&decblk[startoffset],ldc - startoffset);
  367.         buffer += ldc - startoffset;
  368.  
  369.         for(start_strip++;start_strip<end_strip;start_strip++) {
  370.             if(lseek(fhandle,so_table[start_strip],0) !=
  371.                     so_table[start_strip]) {
  372.             /* error in positioning the file */
  373.                 return(0);
  374.             }
  375.             if(tlRead(fhandle,decblk2,(SHORT)sbc_table[start_strip])!=
  376.                         (SHORT)sbc_table[start_strip]) {
  377.                 /* read failed */
  378.                 return(0);
  379.             }
  380.             if(endflag && start_strip == number_strips -1) {
  381.                 temp = end_strip_lines;
  382.             } else {
  383.                 temp = rows_per_strip;
  384.             }
  385.             ldc = decompress_block(decblk,decblk2,(SHORT) width,
  386.                     temp,sbc_table[start_strip]);
  387.             if(ldc != temp * bytes_per_line) {
  388.                 return(0);
  389.             }
  390.             bigcopy(buffer,(LONGPTR)&decblk[startoffset],ldc);
  391.  
  392.             buffer += ldc;
  393.         }
  394.  
  395.         /* now read the partial strip */
  396.  
  397.         if(lseek(fhandle,so_table[end_strip],0) !=
  398.                         so_table[end_strip]) {
  399.         /* error in positioning the file */
  400.             return(0);
  401.         }
  402.         if(tlRead(fhandle,decblk2,(SHORT)sbc_table[end_strip]) !=
  403.                     (SHORT)sbc_table[end_strip]) {
  404.             /* read failed */
  405.             return(0);
  406.         }
  407.  
  408.         if(endflag && end_strip == number_strips -1) {
  409.             temp = end_strip_lines;
  410.         } else {
  411.             temp = rows_per_strip;
  412.         }
  413.         ldc = decompress_block(decblk,decblk2,(SHORT) width,
  414.                 temp,sbc_table[end_strip]);
  415.  
  416.         bigcopy(buffer,decblk,endoffset+bytes_per_line);
  417.         break;
  418.  
  419.  
  420.     case PACKBITS:
  421.         seek_addr = so_table[start_strip];
  422.  
  423.         if(lseek(fhandle,seek_addr,0) != seek_addr) {
  424.             /* error in reading file */
  425.             return(0);
  426.         }
  427.         
  428.         if((LONG)tlRead(fhandle,decblk2,sbc_table[start_strip])
  429.             != sbc_table[start_strip]){
  430.             /* error in reading the file */
  431.             return(0);
  432.         }
  433.  
  434. /* now, decompress the buffer */
  435.  
  436.         
  437.         if(endflag && start_strip == number_strips -1) {
  438.             temp = end_strip_lines;
  439.         } else {
  440.             temp = rows_per_strip;
  441.         }
  442.  
  443.         if ( !UnpackBits( decblk2, decblk, temp * bytes_per_line) ) {
  444.                 readimg_handle = -1;
  445.                 return(0);
  446.         }
  447.  
  448.         /* move the starting part of the buffer to memory */
  449.  
  450.         bigcopy(buffer,(LONGPTR)&decblk[startoffset],ldc - startoffset);
  451.         buffer += ldc - startoffset;
  452.  
  453.         for(start_strip++;start_strip<end_strip;start_strip++) {
  454.             if(lseek(fhandle,so_table[start_strip],0) !=
  455.                     so_table[start_strip]) {
  456.             /* error in positioning the file */
  457.                 return(0);
  458.             }
  459.             if(tlRead(fhandle,decblk2,(SHORT)sbc_table[start_strip])!=
  460.                         (SHORT)sbc_table[start_strip]) {
  461.                 /* read failed */
  462.                 return(0);
  463.             }
  464.             if(endflag && start_strip == number_strips -1) {
  465.                 temp = end_strip_lines;
  466.             } else {
  467.                 temp = rows_per_strip;
  468.             }
  469.  
  470.             if ( !UnpackBits( decblk2, decblk, temp * bytes_per_line) ) {
  471.                     readimg_handle = -1;
  472.                     return(0);
  473.             }
  474.  
  475.             bigcopy(buffer,(LONGPTR)&decblk[startoffset],ldc);
  476.  
  477.             buffer += ldc;
  478.         }
  479.  
  480.         /* now read the partial strip */
  481.  
  482.         if(lseek(fhandle,so_table[end_strip],0) !=
  483.                         so_table[end_strip]) {
  484.         /* error in positioning the file */
  485.             return(0);
  486.         }
  487.         if(tlRead(fhandle,decblk2,(SHORT)sbc_table[end_strip]) !=
  488.                     (SHORT)sbc_table[end_strip]) {
  489.             /* read failed */
  490.             return(0);
  491.         }
  492.  
  493.         if(endflag && end_strip == number_strips -1) {
  494.             temp = end_strip_lines;
  495.         } else {
  496.             temp = rows_per_strip;
  497.         }
  498.  
  499.         if ( !UnpackBits( decblk2, decblk, temp * bytes_per_line) ) {
  500.                 readimg_handle = -1;
  501.                 return(0);
  502.         }
  503.  
  504.         bigcopy(buffer,decblk,endoffset+bytes_per_line);
  505.         break;
  506.         }
  507.     }
  508. return(numlines);
  509. }
  510.  
  511.     
  512. /* read all the tags so we can decipher this muther */
  513.  
  514. int image_att_read(SHORT fhandle, SHORT fdtype)
  515. {
  516.     TIFF_DIR_ENTRY dirent;
  517.     LONG    strip_offset;
  518.     LONG    bytes_to_read;
  519.     LONG i;
  520.  
  521.     if(!read_tag(fhandle,fdtype,IMAGE_WIDTH_TAG,
  522.         (LONGPTR)&width,(SHORT)LONG_SIZE)) {
  523.         /* failure in reading tag */
  524.         readimg_handle = -1;
  525.         return(0);
  526.     }
  527.  
  528.     if(!read_tag(fhandle,fdtype,IMAGE_LENGTH_TAG,
  529.         (LONGPTR)&height,(SHORT)LONG_SIZE)) {
  530.         /* failure in reading tag */
  531.         readimg_handle = -1;
  532.         return(0);
  533.     }
  534.  
  535.     if(!read_tag(fhandle,fdtype,BITS_PER_SAMPLE_TAG,
  536.         (LONGPTR)&bits_per_sample,(SHORT)SHORT_SIZE)) {
  537.         /* read tag failed, set bits_per_sample to 1 */
  538.         bits_per_sample = 1;
  539.     }
  540.  
  541.     if(!read_tag(fhandle,fdtype,SAMPLES_PER_PIXEL_TAG,
  542.         (LONGPTR)&samples_per_pixel,(SHORT)SHORT_SIZE)) {
  543.         /* read tag failed, set samples_per_pixel to 1 */
  544.         samples_per_pixel = 1;
  545.     }
  546.     
  547.     if(!read_tag(fhandle,fdtype,ROWS_PER_STRIP_TAG,
  548.         (LONGPTR)&rows_per_strip,(SHORT)LONG_SIZE)) {
  549.         /* read tag failed, set value to img height */
  550.         rows_per_strip = height;
  551.     }
  552.  
  553.     bytes_per_line = ((width * bits_per_sample * samples_per_pixel)
  554.             +7) / 8;
  555.  
  556.     if(rows_per_strip == height) {  /* one strip per image */
  557.         one_strip_image = TRUE;
  558.     } else {
  559.         one_strip_image = FALSE;
  560.     }
  561.  
  562.     if(!read_tag(fhandle,fdtype,COMPRESSION_TAG,
  563.         (LONGPTR)&l_compression,(SHORT)SHORT_SIZE)) {
  564.         /* if read tag fails, set compression to */
  565.         /* 1 */
  566.         l_compression = 1;
  567.         /* this is type 1 pack as many pixels into a */
  568.         /* byte as possible */
  569.     }
  570.  
  571.  
  572.     /* now read in the directory entry for the strip offset */
  573.     /* tag. */
  574.  
  575.     if(!read_dirent(fhandle,fdtype,STRIP_OFFSETS_TAG,
  576.         (TIFF_DIR_ENTRY far *)&dirent)) {
  577.         /* read_dirent failed, return 0 */
  578.         readimg_handle = -1;
  579.         return(0);
  580.     }
  581.  
  582.     number_strips = dirent.length;
  583.     old_start     = number_strips+1;
  584.     strip_offset  = dirent.value_offset;
  585.  
  586.     /* allocate space for the strip table */
  587.     /* this memory will need to be freed by the */
  588.     /* close_read function */
  589.     /* the +1 is so that we have room to compute the strip tables */
  590.     /* if we need to. */
  591.  
  592.     bytes_to_read = number_strips * (LONG)LONG_SIZE;
  593.  
  594.     so_table = (LONG far *)bigalloc(bytes_to_read + sizeof(long));
  595.     sbc_table= (LONG far *)bigalloc(bytes_to_read + sizeof (long));
  596.  
  597.  
  598.     if(!so_table) {
  599.         readimg_handle = -1;
  600.         return(0);
  601.     }
  602.     
  603.     if(!sbc_table) {
  604.         bigfree(so_table);
  605.         so_table = 0;
  606.         readimg_handle = -1;
  607.         return(0);
  608.     }
  609.     
  610.     if(one_strip_image) {
  611.         so_table [0] = dirent.value_offset;
  612.         sbc_table[0] = bytes_per_line * height;
  613.     } else {
  614.         if(lseek(fhandle,strip_offset,0) != strip_offset) {
  615.             readimg_handle = -1;
  616.             bigfree(so_table);
  617.             so_table = 0;
  618.             return(0);
  619.         }
  620.     
  621.         if(tlRead(fhandle,so_table,(SHORT)bytes_to_read) != (short)bytes_to_read) {
  622.             readimg_handle = -1;
  623.             bigfree(so_table);
  624.             so_table = 0;
  625.             return(0);
  626.         }
  627.  
  628.         /* now check the originator and swap the bytes if */
  629.         /* necessary */
  630.         for(i=0;i<number_strips;i++) {
  631.             reorder((LONG far *)&so_table[i],LONG_SIZE);
  632.         }
  633.     }
  634.         /* now read the strip byte count tables */
  635.         /* if the strip byte count table is not present, then */
  636.         /* we need to fudge the data by using the strip offsets */
  637.         /* to compute the strip byte counts */
  638.     
  639.         if(!read_dirent(fhandle,fdtype,STRIP_BYTE_COUNTS_TAG,
  640.             (TIFF_DIR_ENTRY far *)&dirent)) {
  641.             /* read_dirent failed, fudge the data */
  642.             so_table[number_strips+1] = bytes_per_line *
  643.                 height - so_table[0];
  644.             for(i=0;i<number_strips;i++) {
  645.                 sbc_table[i] = so_table[i+1] -
  646.                          so_table[i];
  647.             }
  648.             goto NOREAD_STRIP_COUNTS;        //Mies!
  649.         }
  650.  
  651.             
  652.     if(one_strip_image) 
  653.         sbc_table [0] = dirent.value_offset;
  654.         else {
  655.         strip_offset = dirent.value_offset;
  656.         if(lseek(fhandle,strip_offset,0) != strip_offset) {
  657.             readimg_handle = -1;
  658.             bigfree(so_table);
  659.             so_table = 0;
  660.             bigfree(sbc_table);
  661.             sbc_table = 0;
  662.             return(0);
  663.             }
  664.     
  665.     
  666.         if(tlRead(fhandle,sbc_table,(SHORT)bytes_to_read) != (SHORT)bytes_to_read) {
  667.             readimg_handle = -1;
  668.             bigfree(so_table);
  669.             so_table = 0;
  670.             bigfree(sbc_table);
  671.             sbc_table = 0;
  672.             return(0);
  673.         }
  674.  
  675.         /* swap the bytes if necessary */
  676.         for(i=0;i<number_strips;i++) {
  677.             reorder((LONG far *)&sbc_table[i],LONG_SIZE);
  678.         }
  679.             
  680.     }
  681. NOREAD_STRIP_COUNTS:
  682. /* find the biggest strip and allocate memory for it */    
  683.  
  684.     maxbytesstrip = 0;
  685.     for(i=0; i < number_strips; i++) {
  686.         if(maxbytesstrip < sbc_table[i] ) {
  687.             maxbytesstrip = sbc_table[i];
  688.         }
  689.     }
  690.  
  691.     if(l_compression == ONE_D_MOD_HUFFMAN ||
  692.        l_compression == PACKBITS) {
  693.         decblk2 = (LONGPTR) bigalloc(maxbytesstrip);
  694.         if(decblk2 == (LONGPTR)0){
  695.             return(0);
  696.         }
  697.         decblk=(LONGPTR)bigalloc((rows_per_strip+1) *  bytes_per_line);
  698.         if(decblk == (LONGPTR)0) {
  699.             bigfree(decblk2);
  700.             return(0);
  701.         }
  702.     }
  703.     return(1);
  704. }
  705.