Line data    Source code

       1             : /**********************************************************************
       2             :  *
       3             :  *  geo_tiffp.c  Private TIFF interface module for GEOTIFF
       4             :  *
       5             :  *    This module implements the interface between the GEOTIFF
       6             :  *    tag parser and the TIFF i/o module. The current setup
       7             :  *    relies on the "libtiff" code, but if you use your own
       8             :  *    TIFF reader software, you may replace the module implementations
       9             :  *    here with your own calls. No "libtiff" dependencies occur
      10             :  *    anywhere else in this code.
      11             :  *
      12             :  * copyright (c) 1995   Niles D. Ritter
      13             :  *
      14             :  * Permission granted to use this software, so long as this copyright
      15             :  * notice accompanies any products derived therefrom.
      16             :  *
      17             :  **********************************************************************/
      18             : 
      19             : #include "geotiff.h"    /* public GTIFF interface */
      20             : 
      21             : #include "geo_tiffp.h"  /* Private TIFF interface */
      22             : #include "geo_keyp.h"   /* Private GTIFF interface */
      23             : 
      24             : /* tiff size array global */
      25             : gsize_t _gtiff_size[] = { 0, 1, 2, 4, 8, 1, 4, 8, 1, 2, 4, 1 };
      26             : 
      27             : static int        _GTIFGetField (tiff_t *tif, pinfo_t tag, int *count, void *value );
      28             : static int        _GTIFSetField (tiff_t *tif, pinfo_t tag, int  count, void *value );
      29             : static tagtype_t  _GTIFTagType  (tiff_t *tif, pinfo_t tag);
      30             : 
      31             : /*
      32             :  * Set up default TIFF handlers.
      33             :  */
      34       27574 : void _GTIFSetDefaultTIFF(TIFFMethod *method)
      35             : {
      36       27574 :   if (!method) return;
      37             : 
      38       27574 :   method->get = _GTIFGetField;
      39       27574 :   method->set = _GTIFSetField;
      40       27574 :   method->type = _GTIFTagType;
      41             : }
      42             : 
      43      180872 : gdata_t _GTIFcalloc(gsize_t size)
      44             : {
      45      180872 :     gdata_t data=(gdata_t)_TIFFmalloc((tsize_t)size);
      46      180873 :   if (data) _TIFFmemset((tdata_t)data,0,(tsize_t)size);
      47      180871 :   return data;
      48             : }
      49             : 
      50       25031 : gdata_t _GTIFrealloc(gdata_t ptr, gsize_t size)
      51             : {
      52       25031 :     return _TIFFrealloc((tdata_t)ptr, (tsize_t) size);
      53             : }
      54             : 
      55       98797 : void _GTIFmemcpy(gdata_t out,gdata_t in,gsize_t size)
      56             : {
      57       98797 :   _TIFFmemcpy((tdata_t)out,(tdata_t)in,(tsize_t)size);
      58       98797 : }
      59             : 
      60      180874 : void _GTIFFree(gdata_t data)
      61             : {
      62      180874 :   if (data) _TIFFfree((tdata_t)data);
      63      180874 : }
      64             : 
      65             : 
      66             : 
      67             : /* returns the value of TIFF tag <tag>, or if
      68             :  * the value is an array, returns an allocated buffer
      69             :  * containing the values. Allocate a copy of the actual
      70             :  * buffer, sized up for updating.
      71             :  */
      72       82723 : static int _GTIFGetField (tiff_t *tif, pinfo_t tag, int *count, void *val )
      73             : {
      74             :   int status;
      75       82723 :   unsigned short scount=0;
      76             :   char *tmp;
      77       82723 :   const gsize_t size = _gtiff_size[_GTIFTagType (tif,tag)];
      78             : 
      79       82721 :   if (_GTIFTagType(tif,  tag) == TYPE_ASCII)
      80             :   {
      81       27574 :     status = TIFFGetField((TIFF *)tif,tag,&tmp);
      82       27574 :     if (!status) return status;
      83       16482 :     scount = (unsigned short) (strlen(tmp)+1);
      84             :   }
      85       55149 :   else status = TIFFGetField((TIFF *)tif,tag,&scount,&tmp);
      86       71631 :   if (!status) return status;
      87             : 
      88       41513 :   *count = scount;
      89             : 
      90       41513 :   char *value = (char *)_GTIFcalloc( (scount+MAX_VALUES)*size);
      91       41513 :   if (!value) return 0;
      92             : 
      93       41513 :   _TIFFmemcpy( value, tmp,  size * scount);
      94             : 
      95       41514 :   *(char **)val = value;
      96       41514 :   return status;
      97             : }
      98             : 
      99             : /*
     100             :  * Set a GeoTIFF TIFF field.
     101             :  */
     102        8090 : static int _GTIFSetField (tiff_t *tif, pinfo_t tag, int count, void *value )
     103             : {
     104        8090 :   const unsigned short scount = (unsigned short) count;
     105             : 
     106             :   int status;
     107             :   /* libtiff ASCII uses null-delimiter */
     108        8090 :   if (_GTIFTagType(tif,  tag) == TYPE_ASCII)
     109        2932 :     status = TIFFSetField((TIFF *)tif,tag,value);
     110             :   else
     111        5158 :     status = TIFFSetField((TIFF *)tif,tag,scount,value);
     112        8090 :   return status;
     113             : }
     114             : 
     115             : 
     116             : /*
     117             :  *  This routine is supposed to return the TagType of the <tag>
     118             :  *  TIFF tag. Unfortunately, "libtiff" does not provide this
     119             :  *  service by default, so we just have to "know" what type of tags
     120             :  *  we've got, and how many. We only define the ones Geotiff
     121             :  *  uses here, and others return UNKNOWN. The "tif" parameter
     122             :  *  is provided for those TIFF implementations that provide
     123             :  *  for tag-type queries.
     124             :  */
     125      281703 : static tagtype_t  _GTIFTagType  (tiff_t *tif, pinfo_t tag)
     126             : {
     127             :   (void) tif; /* dummy reference */
     128             : 
     129             :   tagtype_t ttype;
     130      281703 :   switch (tag)
     131             :   {
     132       77816 :     case GTIFF_ASCIIPARAMS:    ttype=TYPE_ASCII; break;
     133       74515 :     case GTIFF_PIXELSCALE:
     134             :     case GTIFF_TRANSMATRIX:
     135             :     case GTIFF_TIEPOINTS:
     136       74515 :     case GTIFF_DOUBLEPARAMS:   ttype=TYPE_DOUBLE; break;
     137      129369 :     case GTIFF_GEOKEYDIRECTORY: ttype=TYPE_SHORT; break;
     138           3 :     default: ttype = TYPE_UNKNOWN;
     139             :   }
     140             : 
     141      281703 :   return ttype;
     142             : }