15797738239

Committed 21 Jun 2025 04:51PM UTC coverage: 71.076% (+0.001%) from 71.075%

Build # 15797738239

Build Type

Pull #12622

github

Committed by

web-flow

Commit Message

Merge 19559fd15 into 645a00347

Pull Request Pull Request #12622: VSI Win32: implement OpenDir()

Run Details

574181 of 807840 relevant lines covered (71.08%)

249831.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.83

/frmts/gtiff/libgeotiff/geo_tiffp.c

/**********************************************************************
 *
 *  geo_tiffp.c  Private TIFF interface module for GEOTIFF
 *
 *    This module implements the interface between the GEOTIFF
 *    tag parser and the TIFF i/o module. The current setup
 *    relies on the "libtiff" code, but if you use your own
 *    TIFF reader software, you may replace the module implementations
 *    here with your own calls. No "libtiff" dependencies occur
 *    anywhere else in this code.
 *
 * copyright (c) 1995   Niles D. Ritter
 *
 * Permission granted to use this software, so long as this copyright
 * notice accompanies any products derived therefrom.
 *
 **********************************************************************/

#include "geotiff.h"    /* public GTIFF interface */

#include "geo_tiffp.h"  /* Private TIFF interface */
#include "geo_keyp.h"   /* Private GTIFF interface */

/* tiff size array global */
gsize_t _gtiff_size[] = { 0, 1, 2, 4, 8, 1, 4, 8, 1, 2, 4, 1 };

static int        _GTIFGetField (tiff_t *tif, pinfo_t tag, int *count, void *value );
static int        _GTIFSetField (tiff_t *tif, pinfo_t tag, int  count, void *value );
static tagtype_t  _GTIFTagType  (tiff_t *tif, pinfo_t tag);

/*
 * Set up default TIFF handlers.
 */
void _GTIFSetDefaultTIFF(TIFFMethod *method)
{
        if (!method) return;

        method->get = _GTIFGetField;
        method->set = _GTIFSetField;
        method->type = _GTIFTagType;
}

gdata_t _GTIFcalloc(gsize_t size)
{
    gdata_t data=(gdata_t)_TIFFmalloc((tsize_t)size);
        if (data) _TIFFmemset((tdata_t)data,0,(tsize_t)size);
        return data;
}

gdata_t _GTIFrealloc(gdata_t ptr, gsize_t size)
{
    return _TIFFrealloc((tdata_t)ptr, (tsize_t) size);
}

void _GTIFmemcpy(gdata_t out,gdata_t in,gsize_t size)
{
        _TIFFmemcpy((tdata_t)out,(tdata_t)in,(tsize_t)size);
}

void _GTIFFree(gdata_t data)
{
        if (data) _TIFFfree((tdata_t)data);
}



/* returns the value of TIFF tag <tag>, or if
 * the value is an array, returns an allocated buffer
 * containing the values. Allocate a copy of the actual
 * buffer, sized up for updating.
 */
static int _GTIFGetField (tiff_t *tif, pinfo_t tag, int *count, void *val )
{
        int status;
        unsigned short scount=0;
        char *tmp;
        const gsize_t size = _gtiff_size[_GTIFTagType (tif,tag)];

        if (_GTIFTagType(tif,  tag) == TYPE_ASCII)
        {
                status = TIFFGetField((TIFF *)tif,tag,&tmp);
                if (!status) return status;
                scount = (unsigned short) (strlen(tmp)+1);
        }
        else status = TIFFGetField((TIFF *)tif,tag,&scount,&tmp);
        if (!status) return status;

        *count = scount;

        char *value = (char *)_GTIFcalloc( (scount+MAX_VALUES)*size);
        if (!value) return 0;

        _TIFFmemcpy( value, tmp,  size * scount);

        *(char **)val = value;
        return status;
}

/*
 * Set a GeoTIFF TIFF field.
 */
static int _GTIFSetField (tiff_t *tif, pinfo_t tag, int count, void *value )
{
        const unsigned short scount = (unsigned short) count;

        int status;
        /* libtiff ASCII uses null-delimiter */
        if (_GTIFTagType(tif,  tag) == TYPE_ASCII)
                status = TIFFSetField((TIFF *)tif,tag,value);
        else
                status = TIFFSetField((TIFF *)tif,tag,scount,value);
        return status;
}


/*
 *  This routine is supposed to return the TagType of the <tag>
 *  TIFF tag. Unfortunately, "libtiff" does not provide this
 *  service by default, so we just have to "know" what type of tags
 *  we've got, and how many. We only define the ones Geotiff
 *  uses here, and others return UNKNOWN. The "tif" parameter
 *  is provided for those TIFF implementations that provide
 *  for tag-type queries.
 */
static tagtype_t  _GTIFTagType  (tiff_t *tif, pinfo_t tag)
{
        (void) tif; /* dummy reference */

        tagtype_t ttype;
        switch (tag)
        {
                case GTIFF_ASCIIPARAMS:    ttype=TYPE_ASCII; break;
                case GTIFF_PIXELSCALE:
                case GTIFF_TRANSMATRIX:
                case GTIFF_TIEPOINTS:
                case GTIFF_DOUBLEPARAMS:   ttype=TYPE_DOUBLE; break;
                case GTIFF_GEOKEYDIRECTORY: ttype=TYPE_SHORT; break;
                default: ttype = TYPE_UNKNOWN;
        }

        return ttype;
}

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	void _GTIFSetDefaultTIFF(TIFFMethod *method)	33,414✔
35	{
36	if (!method) return;	33,414✔
37
38	method->get = _GTIFGetField;	33,414✔
39	method->set = _GTIFSetField;	33,414✔
40	method->type = _GTIFTagType;	33,414✔
41	}
42
43	gdata_t _GTIFcalloc(gsize_t size)	213,718✔
44	{
45	gdata_t data=(gdata_t)_TIFFmalloc((tsize_t)size);	213,718✔
46	if (data) _TIFFmemset((tdata_t)data,0,(tsize_t)size);	213,720✔
47	return data;	213,718✔
48	}
49
50	gdata_t _GTIFrealloc(gdata_t ptr, gsize_t size)	26,838✔
51	{
52	return _TIFFrealloc((tdata_t)ptr, (tsize_t) size);	26,838✔
53	}
54
55	void _GTIFmemcpy(gdata_t out,gdata_t in,gsize_t size)	105,773✔
56	{
57	_TIFFmemcpy((tdata_t)out,(tdata_t)in,(tsize_t)size);	105,773✔
58	}	105,773✔
59
60	void _GTIFFree(gdata_t data)	213,718✔
61	{
62	if (data) _TIFFfree((tdata_t)data);	213,718✔
63	}	213,718✔
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	static int _GTIFGetField (tiff_t tif, pinfo_t tag, int count, void *val )	100,241✔
73	{
74	int status;
75	unsigned short scount=0;	100,241✔
76	char *tmp;
77	const gsize_t size = _gtiff_size[_GTIFTagType (tif,tag)];	100,241✔
78
79	if (_GTIFTagType(tif, tag) == TYPE_ASCII)	100,241✔
80	{
81	status = TIFFGetField((TIFF *)tif,tag,&tmp);	33,414✔
82	if (!status) return status;	33,414✔
83	scount = (unsigned short) (strlen(tmp)+1);	17,991✔
84	}
85	else status = TIFFGetField((TIFF *)tif,tag,&scount,&tmp);	66,828✔
86	if (!status) return status;	84,819✔
87
88	*count = scount;	44,829✔
89
90	char value = (char )_GTIFcalloc( (scount+MAX_VALUES)*size);	44,829✔
91	if (!value) return 0;	44,829✔
92
93	_TIFFmemcpy( value, tmp, size * scount);	44,829✔
94
95	(char *)val = value;	44,829✔
96	return status;	44,829✔
97	}
98
99	/*
100	* Set a GeoTIFF TIFF field.
101	*/
102	static int _GTIFSetField (tiff_t tif, pinfo_t tag, int count, void value )	8,355✔
103	{
104	const unsigned short scount = (unsigned short) count;	8,355✔
105
106	int status;
107	/* libtiff ASCII uses null-delimiter */
108	if (_GTIFTagType(tif, tag) == TYPE_ASCII)	8,355✔
109	status = TIFFSetField((TIFF *)tif,tag,value);	3,049✔
110	else
111	status = TIFFSetField((TIFF *)tif,tag,scount,value);	5,306✔
112	return status;	8,355✔
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	static tagtype_t _GTIFTagType (tiff_t *tif, pinfo_t tag)	325,596✔
126	{
127	(void) tif; /* dummy reference */
128
129	tagtype_t ttype;
130	switch (tag)	325,596✔
131	{
132	case GTIFF_ASCIIPARAMS: ttype=TYPE_ASCII; break;	91,439✔
133	case GTIFF_PIXELSCALE:	86,809✔
134	case GTIFF_TRANSMATRIX:
135	case GTIFF_TIEPOINTS:
136	case GTIFF_DOUBLEPARAMS: ttype=TYPE_DOUBLE; break;	86,809✔
137	case GTIFF_GEOKEYDIRECTORY: ttype=TYPE_SHORT; break;	147,348✔
138	default: ttype = TYPE_UNKNOWN;	×
139	}
140
141	return ttype;	325,596✔
142	}

OSGeo / gdal / 15797738239

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous