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 / TIFWRITE.C < prev    next >
C/C++ Source or Header  |  1993-06-23  |  10KB  |  476 lines
  1. /* ------------------------------------------------------------------ */
  2. /*                                      */
  3. /*        TIFF IMAGE DATA WRITE AND UPDATE FUNCTION          */
  4. /*                                      */
  5. /*        DEVELOPED BY:    VIJAY RANGARAJAN              */
  6. /*        DATE:        8/26/86                   */
  7. /*                                      */
  8. /*        DEST CORPORATION                      */
  9. /*                                      */
  10. /* ------------------------------------------------------------------ */
  11.  
  12. /* this version is backedup as tifwrite.bak prior to new changes */
  13. /* this version stores compressed data, but the image looks distorted */
  14. /* changes - 9/15   10.00am */
  15.  
  16. #include <windows.h>
  17. #pragma hdrstop
  18.  
  19. #define  T_273    273
  20. #define  T_279    279
  21. #include <io.h>
  22. #include "tiff.h"
  23. #include "tiffi.h"
  24. #include "apptag.h"
  25.  
  26. void strpofst_update_ptr(void);
  27. void update_strp_ifd(int fl_handl);
  28. void write_tagval(int handle, short tagnum, long tagln, long tagval);
  29.  
  30.  
  31. extern int write();
  32.  
  33. extern short field_mem_tab[];
  34. extern long    field_data_endpos;
  35. extern long    field_data_pos;
  36. extern long    ifdsize;
  37. extern long    get_cpos();
  38. extern int    field_data_write();
  39. extern short fields_exist;
  40.  
  41. short    image_begin;
  42.  
  43. static long    strpofst_pos;
  44. static long    strpbytcnt_pos;
  45. static long    sav_fil_pos;
  46. static long    *strpofst_mem_ptr;
  47. static long    *strpbytcnt_mem_ptr;
  48.  
  49. static long    curnt_pos;
  50. static long    strperimg;
  51. static int    filhandle;
  52.  
  53.    /********* should be an array indexed by fhandle ***********************/
  54. static short  status = 0;
  55.  
  56. static long offset_strip_mem[500];
  57. static long count_strip_mem[500];
  58.  
  59.    /* included to handled compress data  9/11 */
  60.  
  61. static char    far *comp_buffer = 0L;
  62. static char    far *comp_ptr = 0L;
  63. static char    far *rawbuf_ptr;
  64. static long    comp_size = 0L;
  65. static long    lines_alloc = 0L;
  66. static long    line_count;
  67. static short compress_type;
  68. static short comp_count;
  69. static long    tot_comp_count;
  70. static long    tot_byte_count;
  71.  
  72.   /* ---------------------------------------- */
  73.  
  74.  
  75.  
  76. short byte_width;
  77.  
  78.  
  79. void strpofst_update_ptr(void), strpbytcnt_update_ptr(long), write_tagval();
  80.  
  81. long  write_image(int       fhandle,        // Dateihandle der offenen TIFF_Datei
  82.           SHORT     fdtype,            // Subfile-Typ
  83.           SHORT     plane,            // Farbebene
  84.           long      startpos,        // Anfangszeile
  85.           long      numlines,        // Anzahl der Zeilen
  86.           char far *    buffer_ptr)        // Zeiger auf Datenpuffer
  87. {
  88.  
  89.     long   image_length;
  90.     long   image_width;
  91.     static long     l_bytewidth;        /* 9/16 */
  92.     static long     rowsprstrp;
  93.     long   get_tagval();
  94.     long   num_bytes;
  95.     long   i;
  96.     int      j;
  97.     long bitssamp;
  98.     long samppix;
  99.  
  100.     if (status == 0) {
  101.         status = 1;
  102.         image_begin = 1;
  103.  
  104.         image_length = get_tagval(T_IMG_LENGTH);
  105.         image_width =  get_tagval(T_IMG_WIDTH);
  106.  
  107.         if((bitssamp = get_tagval(T_BITS_SAMPLE)) == NULL) {
  108.             bitssamp = BITSSAMP;
  109.         }
  110.  
  111.         if((samppix = get_tagval(T_SAMP_PIX)) == NULL) {
  112.             samppix = SAMPPIXEL;
  113.         }
  114.  
  115.         compress_type = (short) get_tagval(T_COMPRESS);  /* comp 9/11 */
  116.  
  117.         /* keep in mind here that data may be lost if the number */
  118.         /* of bytes per line exceeds 65535 */
  119.  
  120.         byte_width = (short)(image_width * samppix * bitssamp + 7 ) / 8;
  121.         l_bytewidth = (image_width * samppix * bitssamp + 7 ) / 8;
  122.         tot_byte_count = 0L;
  123.  
  124.         rowsprstrp = get_tagval(T_RWPRSTRP);
  125.         if (rowsprstrp == 0)
  126.             rowsprstrp = image_length;
  127.  
  128.         filhandle = fhandle;
  129.         strperimg = (image_length + rowsprstrp -1)/rowsprstrp;
  130.  
  131.  
  132.         if (set_position(fhandle, field_data_endpos) < 0)
  133.             return (0L);
  134.  
  135.         strpofst_mem_ptr = (long *) &(offset_strip_mem[0]);
  136.  
  137.         strpbytcnt_mem_ptr = (long *) &(count_strip_mem[0]);
  138.  
  139.         sav_fil_pos = get_cpos(fhandle);
  140.  
  141.         if (strperimg == 1) {
  142.             *strpofst_mem_ptr   =(long) sav_fil_pos;
  143.             *strpbytcnt_mem_ptr =(long)(l_bytewidth * image_length);    /**/ // Ob das wohl richtg ist?
  144.         }
  145.  
  146.     }
  147.  
  148. /*  Get current file position */
  149.  
  150.     num_bytes = (long) (l_bytewidth * numlines);
  151.     line_count = numlines;
  152.     lines_alloc = line_count;
  153.  
  154.     if (strperimg != 1) {
  155.         sav_fil_pos = get_cpos(fhandle);
  156.         strpofst_update_ptr();
  157.     }
  158.  
  159. /*  Check if data is to be compressed 9/11 */
  160.  
  161.     switch(compress_type) {
  162.  
  163.         case ONE_D_MOD:
  164.  
  165.      /* Compress image data using 1D modified Huffman code technique
  166.       * and allocate necessary buffer size for compressed data    */
  167.  
  168.             j = 1;         /* one line compression */
  169.             comp_size = (l_bytewidth * (j * 6));
  170.             if ((comp_buffer = bigalloc(comp_size)) == 
  171.                     (char far *) 0x0000) {
  172.                 return(0L);
  173.             }
  174.             comp_ptr = comp_buffer;
  175.             rawbuf_ptr = buffer_ptr;
  176.             while (line_count > 0) {
  177.  
  178.                 /* compress 1 line 9/15 */
  179.  
  180.                 comp_count = compress_block(rawbuf_ptr,
  181.                          comp_ptr, l_bytewidth, j);
  182.  
  183.  
  184.                 rawbuf_ptr += (l_bytewidth * j);
  185.                 tot_comp_count = (long) comp_count;
  186.  
  187.  
  188.                 if (write_img_data (fhandle, comp_buffer,
  189.                          tot_comp_count) < 0) {
  190.                     bigfree(comp_buffer);
  191.                     return(0L);
  192.                 }
  193.  
  194.                 tot_byte_count += tot_comp_count; /* 9/12 */
  195.  
  196.                 line_count -= j;
  197.  
  198.             }  /* end of outer while loop */
  199.  
  200. /*  new addition 9/12 */
  201.  
  202.             if (strperimg ==1) {
  203.                 *strpbytcnt_mem_ptr = tot_byte_count;
  204.             }
  205.             else {
  206.                 strpbytcnt_update_ptr(tot_byte_count);
  207.                 tot_byte_count = 0L;    /* 10/9 vj */
  208.             }
  209.  
  210.             bigfree(comp_buffer);
  211.             break;
  212.                               
  213.         case PACKBITS:
  214.  
  215.      /* Bilddaten mit det PackBits-Codierung komprimieren.        */ 
  216.  
  217.             j = 1;         /* one line compression */
  218.             comp_size = (l_bytewidth * (j * 6));
  219.             if ((comp_buffer = bigalloc(comp_size)) == NULL) 
  220.                 return(0L);
  221.  
  222.             rawbuf_ptr = buffer_ptr;
  223.             while (line_count > 0) {
  224.  
  225.                 /* compress 1 line 9/15 */
  226.  
  227.                     comp_ptr   = comp_buffer;
  228.                 BigPackBits(&rawbuf_ptr, &comp_ptr, l_bytewidth * j);
  229.  
  230. /*                comp_count = compress_block(rawbuf_ptr,
  231.                          comp_ptr, l_bytewidth, j);
  232.  
  233.  
  234.                 rawbuf_ptr += (l_bytewidth * j); 
  235.                 tot_comp_count = (long) comp_count; */
  236.  
  237.                 tot_comp_count = comp_ptr - comp_buffer;
  238.  
  239.                 if (write_img_data (fhandle, comp_buffer,
  240.                          tot_comp_count) < 0) {
  241.                     bigfree(comp_buffer);
  242.                     return(0L);
  243.                 }
  244.  
  245.                 tot_byte_count += tot_comp_count; /* 9/12 */
  246.  
  247.                 line_count -= j;
  248.  
  249.             }  /* end of outer while loop */
  250.  
  251. /*  new addition 9/12 */
  252.  
  253.             if (strperimg ==1) {
  254.                 *strpbytcnt_mem_ptr = tot_byte_count;
  255.             }
  256.             else {
  257.                 strpbytcnt_update_ptr(tot_byte_count);
  258.                 tot_byte_count = 0L;    /* 10/9 vj */
  259.             }
  260.  
  261.             bigfree(comp_buffer);
  262.             break;
  263.                               
  264.         /* ----- end of case ---------- */
  265.  
  266.         default:     /*  Write image data onto the file */
  267.  
  268.             if (write_img_data (fhandle, buffer_ptr, num_bytes)<0){
  269.                 return (0L);
  270.             }
  271.  
  272.             if (strperimg !=1)
  273.                 strpbytcnt_update_ptr(num_bytes); /* 9/12 */
  274.  
  275.     }    /* close braces for switch loop */
  276.  
  277.  
  278.     return(numlines);
  279. }
  280.  
  281.  
  282. /*  Write image data function */
  283.  
  284.  
  285. int write_img_data(int fhndle, char far *bufptr, long bytesize)
  286.  
  287.    {
  288.    int smallbytesize;
  289.  
  290.    smallbytesize = (int) bytesize;
  291.    if ((tlpWrite (fhndle, bufptr, smallbytesize)) != smallbytesize)
  292.       return (-1);
  293.  
  294.    return (0);
  295.    }
  296.  
  297.  
  298. /*  Update stripoffset table */
  299.  
  300. void strpofst_update_ptr(void)
  301.    {
  302.    *strpofst_mem_ptr = sav_fil_pos;
  303.    ++strpofst_mem_ptr;
  304.    }
  305.  
  306. /*  Update stripbytecount table */
  307.  
  308. void strpbytcnt_update_ptr(long no_bytes)
  309.    {
  310.  
  311.    *strpbytcnt_mem_ptr = no_bytes;
  312.    strpbytcnt_mem_ptr++;
  313.    }
  314.  
  315.  
  316.  
  317.  
  318.  
  319.  
  320.  
  321.  
  322. /*  Get the value of the specfied tag */
  323.  
  324.    long get_tagval(SHORT tag_num)
  325.    {
  326.  
  327.    short *field_ptr;
  328.    short tag_index;
  329.    long  tag_val, *ptr;
  330.    short i;
  331.  
  332.    field_ptr = field_mem_tab+1;
  333.  
  334.    i = field_mem_tab[0];
  335.    while (i-- > 0)
  336.        {
  337.        if (tag_num != *field_ptr)
  338.       {
  339.       field_ptr += 6;
  340.       }
  341.  
  342.        else
  343.       {
  344.       field_ptr += 4;
  345.       ptr = (long *) field_ptr;
  346.       tag_val = *ptr;
  347.       return(tag_val);
  348.       }
  349.  
  350.        }
  351.  
  352.    return(0L);
  353.    }
  354.  
  355.  
  356. /*  Position the file */
  357.  
  358. int set_position(int fhandl, long fil_pos)
  359.  
  360.  
  361.   {
  362.      long    lseek();
  363.      int    mode = 0;
  364.  
  365.      if (lseek(fhandl, fil_pos, mode) < 0)
  366.     return (-1);
  367.  
  368.      return (0);
  369.   }
  370.  
  371.  
  372.  
  373.  
  374. /* Close TIFF creating subsystem */
  375.  
  376.    int close_create(int fhndl)
  377.    {
  378.  
  379.    image_begin = 0;
  380.    fields_exist = 0;
  381.    status = 0;        /* reset for next file */
  382.  
  383.     if(strperimg != 1) {
  384.         strpofst_pos = get_cpos(fhndl);
  385.         if(write_strptrs(fhndl,&(offset_strip_mem[0]),(strperimg*4))< 0)
  386.             return (0);
  387.  
  388.         strpbytcnt_pos = get_cpos(fhndl);
  389.         if(write_strptrs(fhndl,&(count_strip_mem[0]),(strperimg*4)) < 0)
  390.             return (0);
  391.  
  392.     }
  393.     else {
  394.         strpofst_pos   = offset_strip_mem[0];
  395.         strpbytcnt_pos = count_strip_mem[0];
  396.     }
  397.  
  398.     update_strp_ifd(fhndl);
  399.  
  400.     if (rewrite_field_data(fhndl) < 0)
  401.         return (0);
  402.  
  403.    return(1);
  404.    }
  405.  
  406. /*  Write strip offset table onto the file */
  407.  
  408. int write_strptrs(int handle, long *strp_mem, long length)
  409.  
  410.    {
  411.    int smalllength;
  412.  
  413.    smalllength = (int) length;
  414.    if ((write (handle, strp_mem, smalllength)) != smalllength)
  415.       return (-1);
  416.    return (0);
  417.    }
  418.  
  419.  
  420. /*  Update strip tags data in ifd */
  421.  
  422. void update_strp_ifd(int fl_handl)
  423.  
  424.    {
  425.    short tagnum = T_273;
  426.    write_tagval(fl_handl, tagnum, strperimg, strpofst_pos);
  427.  
  428.    tagnum = T_279;
  429.    write_tagval(fl_handl, tagnum, strperimg, strpbytcnt_pos);
  430.  
  431.    }
  432.  
  433.  
  434.  
  435. /*  Write tag length and tag value into the tag */
  436.  
  437. void write_tagval(int handle, short tagnum, long tagln, long tagval)
  438.  
  439.    {
  440.    short *field_ptr;
  441.    long  tag_val, *ptr;
  442.    short i;
  443.  
  444.    field_ptr = field_mem_tab+1;
  445.    i = field_mem_tab[0];
  446.    while (i-- > 0)
  447.        {
  448.        if (tagnum != *field_ptr)
  449.       {
  450.       field_ptr += 6;
  451.       }
  452.  
  453.        else
  454.       {
  455.       field_ptr += 2;
  456.       ptr = (long *) field_ptr;
  457.       *ptr++ = tagln;
  458.       *ptr++ = tagval;
  459.       break;
  460.       }
  461.        }
  462.    }
  463.  
  464.  
  465. /*  Rewrite the field data */
  466.  
  467. int rewrite_field_data(int handle)
  468.  
  469.    {
  470.  
  471.    if (set_position(handle, field_data_pos) < 0)
  472.       return (-1);
  473.    field_data_write (handle, ifdsize);
  474.    return (0);
  475.    }
  476.