13700616263

Committed 06 Mar 2025 02:10PM UTC coverage: 70.331% (-0.02%) from 70.35%

Build # 13700616263

Build Type

Pull #11923

github

Committed by

web-flow

Commit Message

Merge 6a40f0624 into 6d20ab96f

Pull Request Pull Request #11923: [cli][gdal_contour] Port gdal_contour to cli

Run Details

355 of 433 new or added lines in 7 files covered. (81.99%)

20395 existing lines in 43 files now uncovered.

553123 of 786461 relevant lines covered (70.33%)

221121.31 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)	27,379✔
35	{
36	if (!method) return;	27,379✔
37
38	method->get = _GTIFGetField;	27,379✔
39	method->set = _GTIFSetField;	27,379✔
40	method->type = _GTIFTagType;	27,379✔
41	}
42
43	gdata_t _GTIFcalloc(gsize_t size)	179,682✔
44	{
45	gdata_t data=(gdata_t)_TIFFmalloc((tsize_t)size);	179,682✔
46	if (data) _TIFFmemset((tdata_t)data,0,(tsize_t)size);	179,682✔
47	return data;	179,680✔
48	}
49
50	gdata_t _GTIFrealloc(gdata_t ptr, gsize_t size)	24,939✔
51	{
52	return _TIFFrealloc((tdata_t)ptr, (tsize_t) size);	24,939✔
53	}
54
55	void _GTIFmemcpy(gdata_t out,gdata_t in,gsize_t size)	98,272✔
56	{
57	_TIFFmemcpy((tdata_t)out,(tdata_t)in,(tsize_t)size);	98,272✔
58	}	98,271✔
59
60	void _GTIFFree(gdata_t data)	179,681✔
61	{
62	if (data) _TIFFfree((tdata_t)data);	179,681✔
63	}	179,683✔
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 )	82,137✔
73	{
74	int status;
75	unsigned short scount=0;	82,137✔
76	char *tmp;
77	const gsize_t size = _gtiff_size[_GTIFTagType (tif,tag)];	82,137✔
78
79	if (_GTIFTagType(tif, tag) == TYPE_ASCII)	82,136✔
80	{
81	status = TIFFGetField((TIFF *)tif,tag,&tmp);	27,379✔
82	if (!status) return status;	27,379✔
83	scount = (unsigned short) (strlen(tmp)+1);	16,412✔
84	}
85	else status = TIFFGetField((TIFF *)tif,tag,&scount,&tmp);	54,758✔
86	if (!status) return status;	71,169✔
87
88	*count = scount;	41,350✔
89
90	char value = (char )_GTIFcalloc( (scount+MAX_VALUES)*size);	41,350✔
91	if (!value) return 0;	41,351✔
92
93	_TIFFmemcpy( value, tmp, size * scount);	41,351✔
94
95	(char *)val = value;	41,350✔
96	return status;	41,350✔
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,052✔
103	{
104	const unsigned short scount = (unsigned short) count;	8,052✔
105
106	int status;
107	/* libtiff ASCII uses null-delimiter */
108	if (_GTIFTagType(tif, tag) == TYPE_ASCII)	8,052✔
109	status = TIFFSetField((TIFF *)tif,tag,value);	2,917✔
110	else
111	status = TIFFSetField((TIFF *)tif,tag,scount,value);	5,135✔
112	return status;	8,052✔
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)	280,005✔
126	{
127	(void) tif; /* dummy reference */
128
129	tagtype_t ttype;
130	switch (tag)	280,005✔
131	{
132	case GTIFF_ASCIIPARAMS: ttype=TYPE_ASCII; break;	77,312✔
133	case GTIFF_PIXELSCALE:	74,062✔
134	case GTIFF_TRANSMATRIX:
135	case GTIFF_TIEPOINTS:
136	case GTIFF_DOUBLEPARAMS: ttype=TYPE_DOUBLE; break;	74,062✔
137	case GTIFF_GEOKEYDIRECTORY: ttype=TYPE_SHORT; break;	128,632✔
UNCOV 138	default: ttype = TYPE_UNKNOWN;	×
139	}
140
141	return ttype;	280,005✔
142	}

OSGeo / gdal / 13700616263

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