home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / grafik / disptiff / tifcreat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-04-27  |  10.4 KB  |  554 lines
  1. /* ------------------------------------------------------------------ */
  2. /*                                      */
  3. /*        TIFF CREATING SYSTEM                      */
  4. /*                                      */
  5. /*        DEVELOPED BY:    VIJAY RANGARAJAN              */
  6. /*                                      */
  7. /*        DATE:        8/21/1986                  */
  8. /*                                      */
  9. /*        DEST CORPORATION                      */
  10. /*                                      */
  11. /*                                      */
  12. /* ------------------------------------------------------------------ */
  13.  
  14. #include "tifstruc.h"
  15.  
  16. #define MAX_TAG        301        /* the maximum tag value */
  17.  
  18.    extern int write();
  19.    extern int set_position();
  20.  
  21.    void init_tif_hdr();
  22.    void check_tag();
  23.    int    field_data_write();
  24.    int    write_tag_val();
  25.    int    find_type();
  26.    long get_cpos();
  27.    short check_strp_tags();
  28.    long header_fil1_pos;              /* header file position */
  29.    long field_data_pos;               /* ifd file position */
  30.    long field_data_endpos;              /* ifd end position */
  31.    long next_val_pos;
  32.    long ifdsize;                  /* total byte size in ifd */
  33.  
  34.    short del_tag_flag = 0;
  35.    short no_more_strp_del = 0;
  36.    short fields_exist;
  37.    short *field_mem_ptr;
  38.    char tag_273;
  39.    char tag_279;
  40.    int tot_tag_num;
  41.    short no_of_tags;
  42.    int filehandle;
  43.  
  44.    short field_mem_tab[256];
  45.  
  46.    ifdstrc subfile, strpofst, strpbtcnt;
  47.  
  48.    short write_fields(thandle, filetype, buf_ptr, sizebytes)
  49.  
  50.    int    thandle;
  51.    short filetype;
  52.    short far *buf_ptr;
  53.    long sizebytes;
  54.  
  55.    {
  56.    int header_write(), build_tags(), header_rewrite();
  57.  
  58.      fields_exist = 1;
  59.      del_tag_flag = 0;
  60.      no_more_strp_del = 0;
  61.      filehandle = thandle;
  62.      init_tif_hdr();                /* create Tiff header */
  63.  
  64. /* Get current position of the file and save it */
  65. /* Write header information into the file */
  66.  
  67.      header_fil1_pos = get_cpos(thandle);
  68.  
  69.      if (header_write(thandle) < 0)
  70.     return (0);
  71.  
  72.      if (build_tags(buf_ptr, filetype, sizebytes) < 0)
  73.     return (0);
  74.  
  75.      field_data_pos = get_cpos(thandle);
  76.  
  77.      if (field_data_write(thandle, ifdsize) < 0)
  78.     return(0);
  79.  
  80.      field_data_endpos = get_cpos(thandle);
  81.  
  82.      tiff_header.first_ifd_addr = field_data_pos;
  83.      if (header_rewrite(thandle, header_fil1_pos) < 0)
  84.     return(0);
  85.  
  86.      return(no_of_tags);
  87.    }
  88.  
  89.  
  90.  
  91. /* Create TIFF header */
  92.  
  93. void init_tif_hdr()
  94.  
  95.    {
  96.      tiff_header.byteorder = INTEL_FMT;
  97.      tiff_header.version = TIF_VERSION;
  98.      tiff_header.first_ifd_addr = ZERO;
  99.  
  100.      tag_273 = 0;
  101.      tag_279 = 0;
  102.      tot_tag_num = 0;
  103.      no_of_tags = 0;
  104.    }
  105.  
  106.  
  107. /* write header structure into the file */
  108.  
  109. int header_write(flhndle)
  110.  
  111.    int     flhndle;
  112.  
  113.    {
  114.      if ((write (flhndle, &tiff_header, sizeof(struct header_tiff_struc)))
  115.       != sizeof(struct header_tiff_struc))
  116.     return (-1);
  117.  
  118.      return (0);
  119.    }
  120.  
  121.  
  122.  
  123.  
  124. /* Gives current position in the file */
  125.  
  126.    long get_cpos(fhndl)
  127.    int    fhndl;
  128.  
  129.    {
  130.      long   lseek();
  131.      long current_pos;
  132.  
  133.      current_pos = lseek(fhndl, 0L, 1);
  134.      return(current_pos);
  135.    }
  136.  
  137.  
  138.  
  139. /* Build tags */
  140.  
  141.    int build_tags(bfpointer, filetype, size)
  142.  
  143.    short far *bfpointer;
  144.    short filetype;
  145.    long size;
  146.  
  147.    {
  148.      short del_bytes;    /*9/24, 5.15pm */
  149.      short tag_num;
  150.      short count;
  151.      short bcount;
  152.      short data_len;
  153.      int   field_type;
  154.      long  *ptr, field_len;
  155.      char  *cptr;
  156.      char  tmp;
  157.      char  far *bptr;
  158.      long  val_fil_pos;
  159.      int   j;
  160.      long  next_ifd_ptr;
  161.      void  build_sbfile_tag();
  162.      int write_data(), find_type();
  163.  
  164.      field_mem_ptr = (short *) field_mem_tab;
  165.      build_sbfile_tag(filetype);
  166.      tot_tag_num++;
  167.      memcpy( &(field_mem_tab[1]), &subfile, sizeof(ifdstrc));
  168.      field_mem_ptr += 7;
  169.  
  170.      while (size > 0)
  171.  
  172.      {
  173.     tag_num = *bfpointer++;
  174.  
  175. /* 9/24, 5.17pm -------------------------------------*/
  176.  
  177.     del_bytes = check_strp_tags(tag_num, bfpointer);
  178.     if(del_tag_flag)
  179.       {
  180.       size -= (del_bytes +4);
  181.       bfpointer += ((del_bytes + 2)/2);
  182.       tag_num = *bfpointer++;
  183.       }
  184. /* --------------------------------------------------*/
  185.  
  186.  
  187.     check_tag(tag_num, field_mem_ptr);
  188.     no_of_tags++;
  189.     tot_tag_num++;
  190.     if ((field_type = find_type(tag_num)) < 0)
  191.        return (-1);
  192.     count = *bfpointer++;
  193.     bcount = count;
  194.     *field_mem_ptr++ = tag_num;
  195.     *field_mem_ptr++ = (short) field_type;
  196.  
  197.     switch (field_type) {
  198.       case 1:
  199.           data_len = 1;
  200.           break;
  201.  
  202.       case 2:
  203.           data_len = 1;
  204.           break;
  205.  
  206.       case 3:
  207.           data_len = 2;
  208.           break;
  209.  
  210.       case 4:
  211.           data_len = 4;
  212.           break;
  213.  
  214.       case 5:
  215.           data_len = 8;
  216.           break;
  217.  
  218.       default:
  219.           data_len = 0;
  220.  
  221.     }
  222.  
  223.     if (data_len == 0)
  224.        return (-1);
  225.  
  226.     field_len = (long) (count/data_len);
  227.     ptr = (long *) field_mem_ptr;
  228.     *ptr++ = field_len;
  229.     field_mem_ptr = (short *) ptr;
  230.  
  231.     if (data_len <= 4)
  232.        {
  233.        cptr = (char *) field_mem_ptr;
  234.        bptr = (char far *) bfpointer;
  235.        while(count-- > 0)
  236.           {
  237.           tmp = *bptr++;
  238.           *cptr++ = tmp;
  239.           }
  240.         for (j = 4-bcount; j > 0; j--)
  241.         *cptr++ = 0;
  242.  
  243.         field_mem_ptr = (short *) cptr;
  244.         bfpointer = (short far *) bptr;
  245.  
  246.        }
  247.  
  248.     else
  249.        {
  250.        val_fil_pos = get_cpos(filehandle);
  251.        if (write_data(filehandle, bfpointer, count) < 0)
  252.           return (-1);
  253.        bfpointer += (count/2);
  254.        ptr = (long *) field_mem_ptr;
  255.        *ptr = val_fil_pos;
  256.        *field_mem_ptr++;
  257.        *field_mem_ptr++;
  258.        next_val_pos = get_cpos(filehandle);
  259.        }
  260.  
  261.  
  262.  
  263. /*    check_tag(tag_num, field_mem_ptr);        */
  264.     size -= (bcount+4);
  265.  
  266.  
  267.      }
  268.  
  269.      field_mem_tab[0] = (short) tot_tag_num;
  270.      ifdsize = (2+(tot_tag_num * 12));
  271.      field_mem_ptr = field_mem_tab;
  272.      field_mem_ptr += (ifdsize/2);
  273.      next_ifd_ptr = 0;
  274.      ptr = (long *) field_mem_ptr;
  275.      *ptr = next_ifd_ptr;
  276.      ifdsize += 4;
  277.      del_tag_flag = 0;
  278.      return (0);
  279.  
  280.    }
  281.  
  282.  
  283.  
  284. /* Build subfile tag data */
  285.  
  286. void build_sbfile_tag(ftype)
  287.  
  288.    short ftype;
  289.    {
  290.      subfile.tagnum = TAG255;
  291.      subfile.fieldtype = TSHORT;
  292.      subfile.fieldlen = 1;
  293. /***********************************??????? ask vj about this ????**********/
  294.      subfile.offset_rvalue = (long) ftype;
  295.    }
  296.  
  297.  
  298.  
  299. /* Write ifd data into the file */
  300.  
  301. int field_data_write(hndle, ifdsize)
  302.    int     hndle;
  303.    long  ifdsize;
  304.  
  305.    {
  306.      int smallifdsize;
  307.  
  308.      smallifdsize = (int) ifdsize;
  309.      if ((write(hndle, field_mem_tab, smallifdsize)) != smallifdsize)
  310.     return (-1);
  311.  
  312.      return (0);
  313.    }
  314.  
  315.  
  316.  
  317. /*  Write any kind of data onto the file */
  318.  
  319. int write_data(fhndle, bufptr, bytsize)
  320.    int    fhndle;
  321.    char far *bufptr;
  322.    short bytsize;
  323.  
  324.    {
  325.  
  326.    if ((tlpWrite (fhndle, bufptr, bytsize)) != bytsize)
  327.       return (-1);
  328.  
  329.    return (0);
  330.    }
  331.  
  332.  
  333.  
  334. /*  Check the tag if stripoffset / stripbytecount tags are to be attached */
  335.  
  336. void check_tag(tag_num, field_ptr)
  337. short tag_num;
  338. short *field_ptr;
  339.  
  340. {
  341.    void build_strpofst_tag(), build_strpbytcnt_tag();
  342.  
  343.    if (tag_num == TAG273)
  344.       tag_273 = 1;
  345.  
  346.    if (tag_num == TAG279)
  347.       tag_279 = 1;
  348.  
  349.    if (tag_num > TAG273) {
  350.     if (tag_273 == 0) {
  351.         tag_273 = 1;
  352.         build_strpofst_tag(field_ptr);
  353.     }
  354.  
  355.     if (tag_num > TAG279) {
  356.         if (tag_279 == 0) {
  357.             tag_279 = 1;
  358.             build_strpbytcnt_tag(field_mem_ptr);
  359.         }
  360.     }
  361.    }
  362.  
  363. }
  364.  
  365.  
  366. /*  Build stripoffset tag */
  367.  
  368. void build_strpofst_tag(field_ptr)
  369.   short *field_ptr;
  370.  
  371.    {
  372.  
  373.      strpofst.tagnum = TAG273;
  374.      strpofst.fieldtype = TLONG;
  375.      strpofst.fieldlen = 0;
  376.      strpofst.offset_rvalue = 0L;
  377.  
  378.      memcpy ( field_ptr, &strpofst, sizeof(ifdstrc));
  379.      field_mem_ptr += 6;
  380.      tot_tag_num++;
  381.    }
  382.  
  383.  
  384.  
  385. /*  Build stripbytecount tag */
  386.  
  387. void build_strpbytcnt_tag(field_ptr)
  388.    short *field_ptr;
  389.  
  390.  
  391.    {
  392.  
  393.      strpbtcnt.tagnum = TAG279;
  394.      strpbtcnt.fieldtype = TLONG;
  395.      strpbtcnt.fieldlen = 0;
  396.      strpbtcnt.offset_rvalue = 0L;
  397.  
  398.      memcpy ( field_ptr, &strpbtcnt, sizeof(ifdstrc));
  399.      field_mem_ptr += 6;
  400.      tot_tag_num++;
  401.    }
  402.  
  403. /*  Find field type for the specified tag number */
  404.  
  405.  
  406.    int find_type(tag_no)
  407.  
  408.    short tag_no;
  409.    {
  410.  
  411.     /* type table for the various tags.  The table begins at tag 255 */
  412.     /* and runs to tag number 301.  If you add tags that have a numeric */
  413.     /* value greater than 301, be sure to change the maxtagno manifest */
  414.     /* to reflect this change */
  415.  
  416.    static int tagfield[] = {3, 3, 3, 3, 3,
  417.                 0, 0, 3, 3, 3,
  418.                 3, 3, 0, 0, 2,
  419.                 2, 2, 2, 4, 3,
  420.                 0, 0, 3, 4, 4,
  421.                 3, 3, 5, 5, 3,
  422.                 2, 5, 5, 4, 4,
  423.                 3, 3, 4, 4, 0,
  424.                 0, 3, 3, 0, 0,
  425.                 3, 3};
  426.  
  427.    if (tag_no > MAX_TAG)
  428.       return (-1);    /* table length exceeded */
  429.  
  430.    return (tagfield[tag_no - 255]);
  431.    }
  432.  
  433.  
  434.  
  435.  
  436. /*  Rewrite the file header */
  437.  
  438. int header_rewrite(fhandle, file_pos)
  439.    int fhandle;
  440.    long file_pos;
  441.  
  442.    {
  443.    long lseek();
  444.    int header_write();
  445.  
  446.    if (lseek (fhandle, file_pos, 0) < 0)
  447.       return (-1);
  448.  
  449.    if (header_write(fhandle) < 0)
  450.       return (-1);
  451.  
  452.    return (0);
  453.    }
  454.  
  455.  
  456. /* Write Tag function  9/16 */
  457.  
  458. int write_tag_val(fil_handle, fdtype, tagnum, dataptr, length)
  459.  
  460. int    fil_handle;
  461. short    fdtype;
  462. short    tagnum;
  463. short far  *dataptr;
  464. short    length;     /* length in bytes */
  465.  
  466.    {
  467.    char  *cptr;
  468.    char far *bptr;
  469.    short *field_ptr;
  470.    short i, data_type;
  471.    long  *ptr;
  472.    long data_pos;
  473.  
  474.    field_ptr = field_mem_tab+1;
  475.    i = field_mem_tab[0];
  476.    while (i-- > 0)
  477.        {
  478.        if(tagnum != *field_ptr)
  479.      {
  480.      field_ptr += 6;
  481.      }
  482.  
  483.        else
  484.     {
  485.     field_ptr += 1;
  486.     data_type = *field_ptr;
  487.     field_ptr +=3;
  488.  
  489.          if (data_type <= 4 && length <=4) {    /* be able to write */
  490.         cptr = (char *) field_ptr;        /* arrays */
  491.         bptr = (char far *) dataptr;
  492.         while(length-- > 0)
  493.              {
  494.              *cptr++ = *bptr++;
  495.              }
  496.          }
  497.          else
  498.          {
  499.            ptr = (long *) field_ptr;
  500.            data_pos = *ptr;
  501.            if(set_position(fil_handle, data_pos) < 0)
  502.          return(0);
  503.            if(write_data(fil_handle, dataptr, length) < 0)
  504.          return(-1);
  505.            }
  506.  
  507.     return(tagnum);
  508.  
  509.     }
  510.  
  511.        }
  512.  
  513.       return(0);
  514.    }
  515.  
  516.  
  517.  
  518.  
  519. /* Check if stripbytcount and stripoffset tags already exists */
  520. /* if so, delete them */
  521.  
  522. short    check_strp_tags(tag_no, buf_pontr)
  523. short    tag_no;
  524. short    far *buf_pontr;
  525.  
  526.    {
  527.    short tag_byte_count;
  528.  
  529.  
  530.    if (!no_more_strp_del)
  531.       {
  532.       if (tag_no == TAG273)
  533.      {
  534.      tag_273 = 0;
  535.      tag_byte_count = *buf_pontr++;
  536.      del_tag_flag = 1;
  537.      return (tag_byte_count);
  538.      }
  539.  
  540.       if (tag_no == TAG279)
  541.      {
  542.      tag_279 = 0;
  543.      tag_byte_count = *buf_pontr++;
  544.      del_tag_flag = 1;
  545.      no_more_strp_del = 1;
  546.      return (tag_byte_count);
  547.      }
  548.       }
  549.    del_tag_flag = 0;
  550.    return(0);
  551.  
  552.    }
  553.  
  554.