home *** CD-ROM | disk | FTP | other *** search
/ FreeWare Collection 2 / FreeSoftwareCollection2pd199x-jp.img / fmge / tiff.c < prev    next >
Text File  |  1990-06-14  |  5KB  |  224 lines
  1. /*
  2.     TIFF image file support routines
  3.  
  4.         1989/04/26  Version 0.0 by Waku
  5. */
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <EGB.h>
  10.  
  11. #define TIFF 
  12. #include "tiff.h"
  13.  
  14. short tiff_IFDsize = 15 ;
  15. long tiff_width = 640 ;
  16. long tiff_length = 480 ;
  17. long tiff_bpp = 4 ;
  18. long tiff_fill = 2 ;
  19. long tiff_maxv = 0xF ;
  20. long tiff_iofs = 0 ;
  21. long tiff_xrofs = 0 ;
  22. long tiff_yrofs = 0 ;
  23. int tiff_err = 0 ;
  24.  
  25. struct {
  26.     long x_c ;
  27.     long x_m ;
  28.     long y_c ;
  29.     long y_m ;
  30. } tiff_resolution  = { 75,1,75,1 } ;
  31.  
  32. IFD_E *ifd ;
  33.  
  34. IFD_E *allocIFD( count ) 
  35. int count ;
  36. {
  37.     return( (IFD_E *)malloc( sizeof(IFD_E)*count ) ) ;
  38. }
  39.  
  40. _freeIFD( ptr )
  41. IFD_E *ptr ;
  42. {
  43.     free( ptr ) ;
  44. }
  45.  
  46. freeIFD()
  47. {
  48.     free( ifd ) ;
  49. }
  50.  
  51. storeIFD( p,tag,type,size,value)
  52. IFD_E *p ;
  53. short tag,type ;
  54. long size,value ;
  55. {
  56.     p->tag = tag ;
  57.     p->type = type ;
  58.     p->count = size ;
  59.     p->value = value ;
  60. }
  61.  
  62. /* make defalut format of IFD */
  63. mkIFD()
  64. {
  65.     int c = 0 ;
  66.  
  67.     IFD_E *ifdp ;
  68.     if( (ifd = allocIFD(15)) == 0 ) 
  69.         { tiff_err = TIF_ERR_MEM ;return -1 ; }
  70.     ifdp = ifd ;
  71.     tiff_xrofs = 8 + 2 + tiff_IFDsize * sizeof(IFD_E) + 4 ;
  72.     tiff_yrofs = tiff_xrofs + 8 ;
  73.     tiff_iofs = 0x100 ;
  74.     storeIFD(ifdp++,GeneralDescription,ShortType,1,1) ;
  75.     storeIFD(ifdp++,ImageWidth,ShortType,1,tiff_width) ;
  76.     storeIFD(ifdp++,ImageLength,ShortType,1,tiff_length) ;
  77.     storeIFD(ifdp++,BitsPerSample,ShortType,1,tiff_bpp) ;
  78.     storeIFD(ifdp++,Compression,ShortType,1,1) ;
  79.     storeIFD(ifdp++,PhotometricInterpretation,ShortType,1,1) ;
  80.     storeIFD(ifdp++,FillOrder,ShortType,1,tiff_fill) ;
  81.     storeIFD(ifdp++,StripOffset,LongType,1,tiff_iofs) ;
  82.     storeIFD(ifdp++,Orientation,ShortType,1,1) ;
  83.     storeIFD(ifdp++,SamplesPerPixel,ShortType,1,1) ;
  84.     storeIFD(ifdp++,MinSampleValue,ShortType,1,0 ) ;
  85.     storeIFD(ifdp++,MaxSampleValue,ShortType,1,tiff_maxv ) ;
  86.     storeIFD(ifdp++,XResolution,RationalType,1,tiff_xrofs) ;
  87.     storeIFD(ifdp++,YResolution,RationalType,1,tiff_yrofs) ;
  88.     storeIFD(ifdp  ,PlanarConfigration,ShortType,1,1) ;
  89.     return(0) ;
  90. }
  91.  
  92. putIFD( fp ) 
  93. FILE *fp ;
  94. {
  95.     long idv,ifdofs,term ;
  96.     idv = ID_VERSION ;
  97.     ifdofs = sizeof(idv) + sizeof(ifdofs) ;
  98.  
  99.     term = 0 ;
  100.  
  101.     if( fwrite(&idv,sizeof(idv),1,fp ) == 0 ) return -1 ;
  102.     if( fwrite(&ifdofs,sizeof(ifdofs),1,fp) == 0 ) return -1 ;
  103.     if( fwrite(&tiff_IFDsize,sizeof(tiff_IFDsize),1,fp) == 0 ) return -1;
  104.     if( fwrite(ifd,sizeof(IFD_E),tiff_IFDsize,fp) == 0 ) return -1 ;
  105.     if( fwrite(&term,sizeof(term),1,fp) == 0 ) return -1 ;
  106.     if( fwrite(&tiff_resolution,sizeof(tiff_resolution),1,fp) == 0) return -1 ;
  107.     fseek(fp, tiff_iofs, SEEK_SET ) ;
  108.     return 0 ;
  109. }
  110.  
  111. setTIFFmode( mode )
  112. int mode ;
  113. {
  114.     switch( mode ) {
  115.     case TIFF_16:
  116.         tiff_width = 640 ;
  117.         tiff_length = 480 ;
  118.         tiff_bpp = 4 ;
  119.         tiff_fill = 2 ;
  120.         tiff_maxv = 0xF ;
  121.         break ;
  122.     case TIFF_32K:
  123.         tiff_width = 320 ;
  124.         tiff_length = 240 ;
  125.         tiff_bpp = 16 ;
  126.         tiff_fill = 1 ;
  127.         tiff_maxv = 0x7FFF ;
  128.         break ;
  129.     case TIFF_256:
  130.         tiff_width = 640 ;
  131.         tiff_length = 480 ;
  132.         tiff_bpp = 8 ;
  133.         tiff_fill = 1 ;
  134.         tiff_maxv = 0xFF ;
  135.         break ;
  136.     }
  137. }
  138.  
  139.  
  140. /* tiff head load */
  141.  
  142. getIFD( fp )
  143. FILE *fp ;
  144. {
  145.     IFD_E *ifdp ;
  146.     long idv,ifdofs ;
  147.     int i ;
  148.     
  149.     if( fread( &idv, 4, 1, fp ) == 0 ) 
  150.         { tiff_err = TIF_ERR_FR ; return -1 ;}
  151.     if( idv != ID_VERSION ) { tiff_err = TIF_ERR_ID ; return -1 ;}
  152. #ifdef DEBUG
  153. printf( "get header\n" ) ;
  154. #endif
  155.     if( fread( &ifdofs, 4, 1, fp) == 0 )
  156.         { tiff_err = TIF_ERR_FR ; return -1 ;}
  157.     fseek(fp, ifdofs, SEEK_SET ) ;
  158. #ifdef DEBUG
  159. printf( "seek to IFD header \n" ) ;
  160. #endif
  161.     if( fread( &tiff_IFDsize, 2, 1, fp) == 0  )
  162.         { tiff_err = TIF_ERR_FR ; return -1 ;}
  163. #ifdef DEBUG
  164. printf( "number of tags = %d \n",tiff_IFDsize ) ;
  165. #endif
  166.     if(( ifd = allocIFD( tiff_IFDsize ) ) == 0 )
  167.         { tiff_err = TIF_ERR_MEM ; return -1 ;}
  168.     ifdp = ifd ;
  169.     for( i = 0 ; i < tiff_IFDsize ; i++ ) {
  170.         if( fread( ifdp++, sizeof(IFD_E),1, fp ) == 0 )
  171.             { tiff_err = TIF_ERR_FR ; return -1; } 
  172. #ifdef DEBUG
  173. printf( "get tag #%d\n",(ifdp-1)->tag ) ;
  174. #endif 
  175.     }
  176.     ifdp = ifd ;
  177.     for( i = 0 ; i < tiff_IFDsize ; i++ ) {
  178.         switch( ifdp->tag ) {
  179.         case ImageWidth:
  180.             tiff_width = ifdp->value ;
  181.             break ;
  182.         case ImageLength:
  183.             tiff_length = ifdp->value ;
  184.             break ;
  185.         case BitsPerSample:
  186.             tiff_bpp = ifdp->value ;
  187.             break ;
  188.         case StripOffset:
  189.             tiff_iofs = ifdp->value ;
  190.             break ;
  191.         default: ;
  192.         }
  193.         ifdp++ ;
  194.     }
  195.     return 0 ;        
  196. }
  197.  
  198. svram(fp,work,sx,sy,wx,wy,mode,n)
  199.  
  200. FILE *fp;
  201. char *work;
  202. int sx,sy,wx,wy;
  203. int mode,n;
  204. {
  205.     char *bp;
  206.     int size;
  207.     char para[16];
  208.     
  209.     size=(wx*wy*mode+7)/8;
  210.     if (wx & 1) wx++;
  211.     if ((bp=(char *)malloc(size))==0) return(-1);
  212.     
  213.     DWORD(para+0 )=(unsigned int)bp;
  214.     WORD (para+4 )=0x14;
  215.     WORD (para+6 )=sx;
  216.     WORD (para+8 )=sy;
  217.     WORD (para+10)=sx+wx-1;
  218.     WORD (para+12)=sy+wy-1;
  219.     EGB_getBlock(work,para);
  220.  
  221.     fwrite(bp,1,size,fp);
  222.     free(bp);
  223. }
  224.