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

40.19

/frmts/gtiff/libtiff/tif_aux.c

/*
 * Copyright (c) 1991-1997 Sam Leffler
 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software and
 * its documentation for any purpose is hereby granted without fee, provided
 * that (i) the above copyright notices and this permission notice appear in
 * all copies of the software and related documentation, and (ii) the names of
 * Sam Leffler and Silicon Graphics may not be used in any advertising or
 * publicity relating to the software without the specific, prior written
 * permission of Sam Leffler and Silicon Graphics.
 *
 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */

/*
 * TIFF Library.
 *
 * Auxiliary Support Routines.
 */
#include "tif_predict.h"
#include "tiffiop.h"
#include <float.h>
#include <math.h>

uint32_t _TIFFMultiply32(TIFF *tif, uint32_t first, uint32_t second,
                         const char *where)
{
    if (second && first > UINT32_MAX / second)
    {
        TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
        return 0;
    }

    return first * second;
}

uint64_t _TIFFMultiply64(TIFF *tif, uint64_t first, uint64_t second,
                         const char *where)
{
    if (second && first > UINT64_MAX / second)
    {
        TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
        return 0;
    }

    return first * second;
}

tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second,
                            const char *where)
{
    if (first <= 0 || second <= 0)
    {
        if (tif != NULL && where != NULL)
        {
            TIFFErrorExtR(tif, where,
                          "Invalid argument to _TIFFMultiplySSize() in %s",
                          where);
        }
        return 0;
    }

    if (first > TIFF_TMSIZE_T_MAX / second)
    {
        if (tif != NULL && where != NULL)
        {
            TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
        }
        return 0;
    }
    return first * second;
}

tmsize_t _TIFFCastUInt64ToSSize(TIFF *tif, uint64_t val, const char *module)
{
    if (val > (uint64_t)TIFF_TMSIZE_T_MAX)
    {
        if (tif != NULL && module != NULL)
        {
            TIFFErrorExtR(tif, module, "Integer overflow");
        }
        return 0;
    }
    return (tmsize_t)val;
}

void *_TIFFCheckRealloc(TIFF *tif, void *buffer, tmsize_t nmemb,
                        tmsize_t elem_size, const char *what)
{
    void *cp = NULL;
    tmsize_t count = _TIFFMultiplySSize(tif, nmemb, elem_size, NULL);
    /*
     * Check for integer overflow.
     */
    if (count != 0)
    {
        cp = _TIFFreallocExt(tif, buffer, count);
    }

    if (cp == NULL)
    {
        TIFFErrorExtR(tif, tif->tif_name,
                      "Failed to allocate memory for %s "
                      "(%" TIFF_SSIZE_FORMAT " elements of %" TIFF_SSIZE_FORMAT
                      " bytes each)",
                      what, nmemb, elem_size);
    }

    return cp;
}

void *_TIFFCheckMalloc(TIFF *tif, tmsize_t nmemb, tmsize_t elem_size,
                       const char *what)
{
    return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);
}

static int TIFFDefaultTransferFunction(TIFF *tif, TIFFDirectory *td)
{
    uint16_t **tf = td->td_transferfunction;
    tmsize_t i, n, nbytes;

    tf[0] = tf[1] = tf[2] = 0;
    // Do not try to generate a default TransferFunction beyond 24 bits.
    // This otherwise leads to insane amounts, resulting in denial of service
    // See https://github.com/OSGeo/gdal/issues/10875
    if (td->td_bitspersample > 24)
        return 0;

    n = ((tmsize_t)1) << td->td_bitspersample;
    nbytes = n * sizeof(uint16_t);
    tf[0] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
    if (tf[0] == NULL)
        return 0;
    tf[0][0] = 0;
    for (i = 1; i < n; i++)
    {
        double t = (double)i / ((double)n - 1.);
        tf[0][i] = (uint16_t)floor(65535. * pow(t, 2.2) + .5);
    }

    if (td->td_samplesperpixel - td->td_extrasamples > 1)
    {
        tf[1] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
        if (tf[1] == NULL)
            goto bad;
        _TIFFmemcpy(tf[1], tf[0], nbytes);
        tf[2] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
        if (tf[2] == NULL)
            goto bad;
        _TIFFmemcpy(tf[2], tf[0], nbytes);
    }
    return 1;

bad:
    if (tf[0])
        _TIFFfreeExt(tif, tf[0]);
    if (tf[1])
        _TIFFfreeExt(tif, tf[1]);
    if (tf[2])
        _TIFFfreeExt(tif, tf[2]);
    tf[0] = tf[1] = tf[2] = 0;
    return 0;
}

static int TIFFDefaultRefBlackWhite(TIFF *tif, TIFFDirectory *td)
{
    int i;

    td->td_refblackwhite = (float *)_TIFFmallocExt(tif, 6 * sizeof(float));
    if (td->td_refblackwhite == NULL)
        return 0;
    if (td->td_photometric == PHOTOMETRIC_YCBCR)
    {
        /*
         * YCbCr (Class Y) images must have the ReferenceBlackWhite
         * tag set. Fix the broken images, which lacks that tag.
         */
        td->td_refblackwhite[0] = 0.0F;
        td->td_refblackwhite[1] = td->td_refblackwhite[3] =
            td->td_refblackwhite[5] = 255.0F;
        td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F;
    }
    else
    {
        /*
         * Assume RGB (Class R)
         */
        for (i = 0; i < 3; i++)
        {
            td->td_refblackwhite[2 * i + 0] = 0;
            td->td_refblackwhite[2 * i + 1] =
                (float)((1L << td->td_bitspersample) - 1L);
        }
    }
    return 1;
}

/*
 * Like TIFFGetField, but return any default
 * value if the tag is not present in the directory.
 *
 * NB:        We use the value in the directory, rather than
 *        explicit values so that defaults exist only one
 *        place in the library -- in TIFFDefaultDirectory.
 */
int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap)
{
    TIFFDirectory *td = &tif->tif_dir;

    if (TIFFVGetField(tif, tag, ap))
        return (1);
    switch (tag)
    {
        case TIFFTAG_SUBFILETYPE:
            *va_arg(ap, uint32_t *) = td->td_subfiletype;
            return (1);
        case TIFFTAG_BITSPERSAMPLE:
            *va_arg(ap, uint16_t *) = td->td_bitspersample;
            return (1);
        case TIFFTAG_THRESHHOLDING:
            *va_arg(ap, uint16_t *) = td->td_threshholding;
            return (1);
        case TIFFTAG_FILLORDER:
            *va_arg(ap, uint16_t *) = td->td_fillorder;
            return (1);
        case TIFFTAG_ORIENTATION:
            *va_arg(ap, uint16_t *) = td->td_orientation;
            return (1);
        case TIFFTAG_SAMPLESPERPIXEL:
            *va_arg(ap, uint16_t *) = td->td_samplesperpixel;
            return (1);
        case TIFFTAG_ROWSPERSTRIP:
            *va_arg(ap, uint32_t *) = td->td_rowsperstrip;
            return (1);
        case TIFFTAG_MINSAMPLEVALUE:
            *va_arg(ap, uint16_t *) = td->td_minsamplevalue;
            return (1);
        case TIFFTAG_MAXSAMPLEVALUE:
        {
            uint16_t maxsamplevalue;
            /* td_bitspersample=1 is always set in TIFFDefaultDirectory().
             * Therefore, td_maxsamplevalue has to be re-calculated in
             * TIFFGetFieldDefaulted(). */
            if (td->td_bitspersample > 0)
            {
                /* This shift operation into a uint16_t limits the value to
                 * 65535 even if td_bitspersamle is > 16 */
                if (td->td_bitspersample <= 16)
                {
                    maxsamplevalue = (1 << td->td_bitspersample) -
                                     1; /* 2**(BitsPerSample) - 1 */
                }
                else
                {
                    maxsamplevalue = 65535;
                }
            }
            else
            {
                maxsamplevalue = 0;
            }
            *va_arg(ap, uint16_t *) = maxsamplevalue;
            return (1);
        }
        case TIFFTAG_PLANARCONFIG:
            *va_arg(ap, uint16_t *) = td->td_planarconfig;
            return (1);
        case TIFFTAG_RESOLUTIONUNIT:
            *va_arg(ap, uint16_t *) = td->td_resolutionunit;
            return (1);
        case TIFFTAG_PREDICTOR:
        {
            TIFFPredictorState *sp = (TIFFPredictorState *)tif->tif_data;
            if (sp == NULL)
            {
                TIFFErrorExtR(
                    tif, tif->tif_name,
                    "Cannot get \"Predictor\" tag as plugin is not configured");
                *va_arg(ap, uint16_t *) = 0;
                return 0;
            }
            *va_arg(ap, uint16_t *) = (uint16_t)sp->predictor;
            return 1;
        }
        case TIFFTAG_DOTRANGE:
            *va_arg(ap, uint16_t *) = 0;
            *va_arg(ap, uint16_t *) = (1 << td->td_bitspersample) - 1;
            return (1);
        case TIFFTAG_INKSET:
            *va_arg(ap, uint16_t *) = INKSET_CMYK;
            return 1;
        case TIFFTAG_NUMBEROFINKS:
            *va_arg(ap, uint16_t *) = 4;
            return (1);
        case TIFFTAG_EXTRASAMPLES:
            *va_arg(ap, uint16_t *) = td->td_extrasamples;
            *va_arg(ap, const uint16_t **) = td->td_sampleinfo;
            return (1);
        case TIFFTAG_MATTEING:
            *va_arg(ap, uint16_t *) =
                (td->td_extrasamples == 1 &&
                 td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
            return (1);
        case TIFFTAG_TILEDEPTH:
            *va_arg(ap, uint32_t *) = td->td_tiledepth;
            return (1);
        case TIFFTAG_DATATYPE:
            *va_arg(ap, uint16_t *) = td->td_sampleformat - 1;
            return (1);
        case TIFFTAG_SAMPLEFORMAT:
            *va_arg(ap, uint16_t *) = td->td_sampleformat;
            return (1);
        case TIFFTAG_IMAGEDEPTH:
            *va_arg(ap, uint32_t *) = td->td_imagedepth;
            return (1);
        case TIFFTAG_YCBCRCOEFFICIENTS:
        {
            /* defaults are from CCIR Recommendation 601-1 */
            static const float ycbcrcoeffs[] = {0.299f, 0.587f, 0.114f};
            *va_arg(ap, const float **) = ycbcrcoeffs;
            return 1;
        }
        case TIFFTAG_YCBCRSUBSAMPLING:
            *va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[0];
            *va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[1];
            return (1);
        case TIFFTAG_YCBCRPOSITIONING:
            *va_arg(ap, uint16_t *) = td->td_ycbcrpositioning;
            return (1);
        case TIFFTAG_WHITEPOINT:
        {
            /* TIFF 6.0 specification tells that it is no default
               value for the WhitePoint, but AdobePhotoshop TIFF
               Technical Note tells that it should be CIE D50. */
            static const float whitepoint[] = {
                D50_X0 / (D50_X0 + D50_Y0 + D50_Z0),
                D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0)};
            *va_arg(ap, const float **) = whitepoint;
            return 1;
        }
        case TIFFTAG_TRANSFERFUNCTION:
            if (!td->td_transferfunction[0] &&
                !TIFFDefaultTransferFunction(tif, td))
            {
                TIFFErrorExtR(tif, tif->tif_name,
                              "No space for \"TransferFunction\" tag");
                return (0);
            }
            *va_arg(ap, const uint16_t **) = td->td_transferfunction[0];
            if (td->td_samplesperpixel - td->td_extrasamples > 1)
            {
                *va_arg(ap, const uint16_t **) = td->td_transferfunction[1];
                *va_arg(ap, const uint16_t **) = td->td_transferfunction[2];
            }
            return (1);
        case TIFFTAG_REFERENCEBLACKWHITE:
            if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(tif, td))
                return (0);
            *va_arg(ap, const float **) = td->td_refblackwhite;
            return (1);
    }
    return 0;
}

/*
 * Like TIFFGetField, but return any default
 * value if the tag is not present in the directory.
 */
int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag, ...)
{
    int ok;
    va_list ap;

    va_start(ap, tag);
    ok = TIFFVGetFieldDefaulted(tif, tag, ap);
    va_end(ap);
    return (ok);
}

float _TIFFClampDoubleToFloat(double val)
{
    if (val > FLT_MAX)
        return FLT_MAX;
    if (val < -FLT_MAX)
        return -FLT_MAX;
    return (float)val;
}

uint32_t _TIFFClampDoubleToUInt32(double val)
{
    if (val < 0)
        return 0;
    if (val > 0xFFFFFFFFU || val != val)
        return 0xFFFFFFFFU;
    return (uint32_t)val;
}

int _TIFFSeekOK(TIFF *tif, toff_t off)
{
    /* Huge offsets, especially -1 / UINT64_MAX, can cause issues */
    /* See http://bugzilla.maptools.org/show_bug.cgi?id=2726 */
    return off <= (~(uint64_t)0) / 2 && TIFFSeekFile(tif, off, SEEK_SET) == off;
}

1	/*
2	* Copyright (c) 1991-1997 Sam Leffler
3	* Copyright (c) 1991-1997 Silicon Graphics, Inc.
4	*
5	* Permission to use, copy, modify, distribute, and sell this software and
6	* its documentation for any purpose is hereby granted without fee, provided
7	* that (i) the above copyright notices and this permission notice appear in
8	* all copies of the software and related documentation, and (ii) the names of
9	* Sam Leffler and Silicon Graphics may not be used in any advertising or
10	* publicity relating to the software without the specific, prior written
11	* permission of Sam Leffler and Silicon Graphics.
12	*
13	* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
14	* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
15	* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
16	*
17	* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
18	* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
19	* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
21	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
22	* OF THIS SOFTWARE.
23	*/
24
25	/*
26	* TIFF Library.
27	*
28	* Auxiliary Support Routines.
29	*/
30	#include "tif_predict.h"
31	#include "tiffiop.h"
32	#include <float.h>
33	#include <math.h>
34
35	uint32_t _TIFFMultiply32(TIFF *tif, uint32_t first, uint32_t second,	110,934✔
36	const char *where)
37	{
38	if (second && first > UINT32_MAX / second)	110,934✔
39	{
40	TIFFErrorExtR(tif, where, "Integer overflow in %s", where);	×
41	return 0;	×
42	}
43
44	return first * second;	110,934✔
45	}
46
47	uint64_t _TIFFMultiply64(TIFF *tif, uint64_t first, uint64_t second,	14,826,400✔
48	const char *where)
49	{
50	if (second && first > UINT64_MAX / second)	14,826,400✔
51	{
52	TIFFErrorExtR(tif, where, "Integer overflow in %s", where);	×
53	return 0;	×
54	}
55
56	return first * second;	14,826,400✔
57	}
58
59	tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second,	1,426,110✔
60	const char *where)
61	{
62	if (first <= 0 \|\| second <= 0)	1,426,110✔
63	{
64	if (tif != NULL && where != NULL)	×
65	{
66	TIFFErrorExtR(tif, where,	×
67	"Invalid argument to _TIFFMultiplySSize() in %s",
68	where);
69	}
70	return 0;	4✔
71	}
72
73	if (first > TIFF_TMSIZE_T_MAX / second)	1,426,120✔
74	{
75	if (tif != NULL && where != NULL)	×
76	{
77	TIFFErrorExtR(tif, where, "Integer overflow in %s", where);	×
78	}
79	return 0;	×
80	}
81	return first * second;	1,426,120✔
82	}
83
84	tmsize_t _TIFFCastUInt64ToSSize(TIFF tif, uint64_t val, const char module)	4,956,370✔
85	{
86	if (val > (uint64_t)TIFF_TMSIZE_T_MAX)	4,956,370✔
87	{
88	if (tif != NULL && module != NULL)	×
89	{
90	TIFFErrorExtR(tif, module, "Integer overflow");	×
91	}
92	return 0;	×
93	}
94	return (tmsize_t)val;	4,956,370✔
95	}
96
97	void _TIFFCheckRealloc(TIFF tif, void *buffer, tmsize_t nmemb,	1,370,860✔
98	tmsize_t elem_size, const char *what)
99	{
100	void *cp = NULL;	1,370,860✔
101	tmsize_t count = _TIFFMultiplySSize(tif, nmemb, elem_size, NULL);	1,370,860✔
102	/*
103	* Check for integer overflow.
104	*/
105	if (count != 0)	1,370,870✔
106	{
107	cp = _TIFFreallocExt(tif, buffer, count);	1,370,870✔
108	}
109
110	if (cp == NULL)	1,370,940✔
111	{
112	TIFFErrorExtR(tif, tif->tif_name,	4✔
113	"Failed to allocate memory for %s "
114	"(%" TIFF_SSIZE_FORMAT " elements of %" TIFF_SSIZE_FORMAT
115	" bytes each)",
116	what, nmemb, elem_size);
117	}
118
119	return cp;	1,370,910✔
120	}
121
122	void _TIFFCheckMalloc(TIFF tif, tmsize_t nmemb, tmsize_t elem_size,	927,277✔
123	const char *what)
124	{
125	return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);	927,277✔
126	}
127
128	static int TIFFDefaultTransferFunction(TIFF tif, TIFFDirectory td)	2✔
129	{
130	uint16_t **tf = td->td_transferfunction;	2✔
131	tmsize_t i, n, nbytes;
132
133	tf[0] = tf[1] = tf[2] = 0;	2✔
134	// Do not try to generate a default TransferFunction beyond 24 bits.
135	// This otherwise leads to insane amounts, resulting in denial of service
136	// See https://github.com/OSGeo/gdal/issues/10875
137	if (td->td_bitspersample > 24)	2✔
138	return 0;	×
139
140	n = ((tmsize_t)1) << td->td_bitspersample;	2✔
141	nbytes = n * sizeof(uint16_t);	2✔
142	tf[0] = (uint16_t *)_TIFFmallocExt(tif, nbytes);	2✔
143	if (tf[0] == NULL)	2✔
144	return 0;	×
145	tf[0][0] = 0;	2✔
146	for (i = 1; i < n; i++)	512✔
147	{
148	double t = (double)i / ((double)n - 1.);	510✔
149	tf[0][i] = (uint16_t)floor(65535. * pow(t, 2.2) + .5);	510✔
150	}
151
152	if (td->td_samplesperpixel - td->td_extrasamples > 1)	2✔
153	{
154	tf[1] = (uint16_t *)_TIFFmallocExt(tif, nbytes);	1✔
155	if (tf[1] == NULL)	1✔
156	goto bad;	×
157	_TIFFmemcpy(tf[1], tf[0], nbytes);	1✔
158	tf[2] = (uint16_t *)_TIFFmallocExt(tif, nbytes);	1✔
159	if (tf[2] == NULL)	1✔
160	goto bad;	×
161	_TIFFmemcpy(tf[2], tf[0], nbytes);	1✔
162	}
163	return 1;	2✔
164
165	bad:	×
166	if (tf[0])	×
167	_TIFFfreeExt(tif, tf[0]);	×
168	if (tf[1])	×
169	_TIFFfreeExt(tif, tf[1]);	×
170	if (tf[2])	×
171	_TIFFfreeExt(tif, tf[2]);	×
172	tf[0] = tf[1] = tf[2] = 0;	×
173	return 0;	×
174	}
175
176	static int TIFFDefaultRefBlackWhite(TIFF tif, TIFFDirectory td)	×
177	{
178	int i;
179
180	td->td_refblackwhite = (float )_TIFFmallocExt(tif, 6 sizeof(float));	×
181	if (td->td_refblackwhite == NULL)	×
182	return 0;	×
183	if (td->td_photometric == PHOTOMETRIC_YCBCR)	×
184	{
185	/*
186	* YCbCr (Class Y) images must have the ReferenceBlackWhite
187	* tag set. Fix the broken images, which lacks that tag.
188	*/
189	td->td_refblackwhite[0] = 0.0F;	×
190	td->td_refblackwhite[1] = td->td_refblackwhite[3] =	×
191	td->td_refblackwhite[5] = 255.0F;	×
192	td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F;	×
193	}
194	else
195	{
196	/*
197	* Assume RGB (Class R)
198	*/
199	for (i = 0; i < 3; i++)	×
200	{
201	td->td_refblackwhite[2 * i + 0] = 0;	×
202	td->td_refblackwhite[2 * i + 1] =	×
203	(float)((1L << td->td_bitspersample) - 1L);	×
204	}
205	}
206	return 1;	×
207	}
208
209	/*
210	* Like TIFFGetField, but return any default
211	* value if the tag is not present in the directory.
212	*
213	* NB: We use the value in the directory, rather than
214	* explicit values so that defaults exist only one
215	* place in the library -- in TIFFDefaultDirectory.
216	*/
217	int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap)	12,381✔
218	{
219	TIFFDirectory *td = &tif->tif_dir;	12,381✔
220
221	if (TIFFVGetField(tif, tag, ap))	12,381✔
222	return (1);	10,670✔
223	switch (tag)	1,711✔
224	{
225	case TIFFTAG_SUBFILETYPE:	×
226	va_arg(ap, uint32_t ) = td->td_subfiletype;	×
227	return (1);	×
228	case TIFFTAG_BITSPERSAMPLE:	×
229	va_arg(ap, uint16_t ) = td->td_bitspersample;	×
230	return (1);	×
231	case TIFFTAG_THRESHHOLDING:	×
232	va_arg(ap, uint16_t ) = td->td_threshholding;	×
233	return (1);	×
234	case TIFFTAG_FILLORDER:	×
235	va_arg(ap, uint16_t ) = td->td_fillorder;	×
236	return (1);	×
237	case TIFFTAG_ORIENTATION:	47✔
238	va_arg(ap, uint16_t ) = td->td_orientation;	47✔
239	return (1);	47✔
240	case TIFFTAG_SAMPLESPERPIXEL:	×
241	va_arg(ap, uint16_t ) = td->td_samplesperpixel;	×
242	return (1);	×
243	case TIFFTAG_ROWSPERSTRIP:	×
244	va_arg(ap, uint32_t ) = td->td_rowsperstrip;	×
245	return (1);	×
246	case TIFFTAG_MINSAMPLEVALUE:	×
247	va_arg(ap, uint16_t ) = td->td_minsamplevalue;	×
248	return (1);	×
249	case TIFFTAG_MAXSAMPLEVALUE:	×
250	{
251	uint16_t maxsamplevalue;
252	/* td_bitspersample=1 is always set in TIFFDefaultDirectory().
253	* Therefore, td_maxsamplevalue has to be re-calculated in
254	* TIFFGetFieldDefaulted(). */
255	if (td->td_bitspersample > 0)	×
256	{
257	/* This shift operation into a uint16_t limits the value to
258	* 65535 even if td_bitspersamle is > 16 */
259	if (td->td_bitspersample <= 16)	×
260	{
261	maxsamplevalue = (1 << td->td_bitspersample) -	×
262	1; /* 2*(BitsPerSample) - 1 /
263	}
264	else
265	{
266	maxsamplevalue = 65535;	×
267	}
268	}
269	else
270	{
271	maxsamplevalue = 0;	×
272	}
273	va_arg(ap, uint16_t ) = maxsamplevalue;	×
274	return (1);	×
275	}
276	case TIFFTAG_PLANARCONFIG:	×
277	va_arg(ap, uint16_t ) = td->td_planarconfig;	×
278	return (1);	×
279	case TIFFTAG_RESOLUTIONUNIT:	×
280	va_arg(ap, uint16_t ) = td->td_resolutionunit;	×
281	return (1);	×
282	case TIFFTAG_PREDICTOR:	×
283	{
284	TIFFPredictorState sp = (TIFFPredictorState )tif->tif_data;	×
285	if (sp == NULL)	×
286	{
287	TIFFErrorExtR(	×
288	tif, tif->tif_name,	×
289	"Cannot get \"Predictor\" tag as plugin is not configured");
290	va_arg(ap, uint16_t ) = 0;	×
291	return 0;	×
292	}
293	va_arg(ap, uint16_t ) = (uint16_t)sp->predictor;	×
294	return 1;	×
295	}
296	case TIFFTAG_DOTRANGE:	×
297	va_arg(ap, uint16_t ) = 0;	×
298	va_arg(ap, uint16_t ) = (1 << td->td_bitspersample) - 1;	×
299	return (1);	×
300	case TIFFTAG_INKSET:	22✔
301	va_arg(ap, uint16_t ) = INKSET_CMYK;	22✔
302	return 1;	22✔
303	case TIFFTAG_NUMBEROFINKS:	×
304	va_arg(ap, uint16_t ) = 4;	×
305	return (1);	×
306	case TIFFTAG_EXTRASAMPLES:	30✔
307	va_arg(ap, uint16_t ) = td->td_extrasamples;	30✔
308	va_arg(ap, const uint16_t *) = td->td_sampleinfo;	30✔
309	return (1);	30✔
310	case TIFFTAG_MATTEING:	×
311	va_arg(ap, uint16_t ) =	×
312	(td->td_extrasamples == 1 &&	×
313	td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);	×
314	return (1);	×
315	case TIFFTAG_TILEDEPTH:	×
316	va_arg(ap, uint32_t ) = td->td_tiledepth;	×
317	return (1);	×
318	case TIFFTAG_DATATYPE:	×
319	va_arg(ap, uint16_t ) = td->td_sampleformat - 1;	×
320	return (1);	×
321	case TIFFTAG_SAMPLEFORMAT:	×
322	va_arg(ap, uint16_t ) = td->td_sampleformat;	×
323	return (1);	×
324	case TIFFTAG_IMAGEDEPTH:	×
325	va_arg(ap, uint32_t ) = td->td_imagedepth;	×
326	return (1);	×
327	case TIFFTAG_YCBCRCOEFFICIENTS:	×
328	{
329	/* defaults are from CCIR Recommendation 601-1 */
330	static const float ycbcrcoeffs[] = {0.299f, 0.587f, 0.114f};
331	va_arg(ap, const float *) = ycbcrcoeffs;	×
332	return 1;	×
333	}
334	case TIFFTAG_YCBCRSUBSAMPLING:	1,602✔
335	va_arg(ap, uint16_t ) = td->td_ycbcrsubsampling[0];	1,602✔
336	va_arg(ap, uint16_t ) = td->td_ycbcrsubsampling[1];	1,602✔
337	return (1);	1,602✔
338	case TIFFTAG_YCBCRPOSITIONING:	×
339	va_arg(ap, uint16_t ) = td->td_ycbcrpositioning;	×
340	return (1);	×
341	case TIFFTAG_WHITEPOINT:	1✔
342	{
343	/* TIFF 6.0 specification tells that it is no default
344	value for the WhitePoint, but AdobePhotoshop TIFF
345	Technical Note tells that it should be CIE D50. */
346	static const float whitepoint[] = {
347	D50_X0 / (D50_X0 + D50_Y0 + D50_Z0),
348	D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0)};
349	va_arg(ap, const float *) = whitepoint;	1✔
350	return 1;	1✔
351	}
352	case TIFFTAG_TRANSFERFUNCTION:	2✔
353	if (!td->td_transferfunction[0] &&	4✔
354	!TIFFDefaultTransferFunction(tif, td))	2✔
355	{
356	TIFFErrorExtR(tif, tif->tif_name,	×
357	"No space for \"TransferFunction\" tag");
358	return (0);	×
359	}
360	va_arg(ap, const uint16_t *) = td->td_transferfunction[0];	2✔
361	if (td->td_samplesperpixel - td->td_extrasamples > 1)	2✔
362	{
363	va_arg(ap, const uint16_t *) = td->td_transferfunction[1];	1✔
364	va_arg(ap, const uint16_t *) = td->td_transferfunction[2];	1✔
365	}
366	return (1);	2✔
367	case TIFFTAG_REFERENCEBLACKWHITE:	×
368	if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(tif, td))	×
369	return (0);	×
370	va_arg(ap, const float *) = td->td_refblackwhite;	×
371	return (1);	×
372	}
373	return 0;	7✔
374	}
375
376	/*
377	* Like TIFFGetField, but return any default
378	* value if the tag is not present in the directory.
379	*/
380	int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag, ...)	12,381✔
381	{
382	int ok;
383	va_list ap;
384
385	va_start(ap, tag);	12,381✔
386	ok = TIFFVGetFieldDefaulted(tif, tag, ap);	12,381✔
387	va_end(ap);	12,381✔
388	return (ok);	12,381✔
389	}
390
391	float _TIFFClampDoubleToFloat(double val)	264✔
392	{
393	if (val > FLT_MAX)	264✔
394	return FLT_MAX;	×
395	if (val < -FLT_MAX)	264✔
396	return -FLT_MAX;	×
397	return (float)val;	264✔
398	}
399
400	uint32_t _TIFFClampDoubleToUInt32(double val)	×
401	{
402	if (val < 0)	×
403	return 0;	×
404	if (val > 0xFFFFFFFFU \|\| val != val)	×
405	return 0xFFFFFFFFU;	×
406	return (uint32_t)val;	×
407	}
408
409	int _TIFFSeekOK(TIFF *tif, toff_t off)	2,536,210✔
410	{
411	/* Huge offsets, especially -1 / UINT64_MAX, can cause issues */
412	/* See http://bugzilla.maptools.org/show_bug.cgi?id=2726 */
413	return off <= (~(uint64_t)0) / 2 && TIFFSeekFile(tif, off, SEEK_SET) == off;	2,536,210✔
414	}

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