tif_dirinfo.c File Reference

#include "tiffiop.h"
#include <stdlib.h>

Include dependency graph for tif_dirinfo.c:

Go to the source code of this file.

Functions
static void *	td_lfind (const void *key, const void *base, size_t *nmemb, size_t size, int(*compar)(const void *, const void *))
const TIFFFieldArray *	_TIFFGetFields (void)
const TIFFFieldArray *	_TIFFGetExifFields (void)
const TIFFFieldArray *	_TIFFGetGpsFields (void)
void	_TIFFSetupFields (TIFF *tif, const TIFFFieldArray *fieldarray)
static int	tagCompare (const void *a, const void *b)
static int	tagNameCompare (const void *a, const void *b)
int	_TIFFMergeFields (TIFF *tif, const TIFFField info[], uint32_t n)
void	_TIFFPrintFieldInfo (TIFF *tif, FILE *fd)
int	TIFFDataWidth (TIFFDataType type)
int	TIFFFieldSetGetSize (const TIFFField *fip)
int	TIFFFieldSetGetCountSize (const TIFFField *fip)
const TIFFField *	TIFFFindField (TIFF *tif, uint32_t tag, TIFFDataType dt)
static const TIFFField *	_TIFFFindFieldByName (TIFF *tif, const char *field_name, TIFFDataType dt)
const TIFFField *	TIFFFieldWithTag (TIFF *tif, uint32_t tag)
const TIFFField *	TIFFFieldWithName (TIFF *tif, const char *field_name)
uint32_t	TIFFFieldTag (const TIFFField *fip)
const char *	TIFFFieldName (const TIFFField *fip)
TIFFDataType	TIFFFieldDataType (const TIFFField *fip)
int	TIFFFieldPassCount (const TIFFField *fip)
int	TIFFFieldReadCount (const TIFFField *fip)
int	TIFFFieldWriteCount (const TIFFField *fip)
int	TIFFFieldIsAnonymous (const TIFFField *fip)
const TIFFField *	_TIFFFindOrRegisterField (TIFF *tif, uint32_t tag, TIFFDataType dt)
TIFFField *	_TIFFCreateAnonField (TIFF *tif, uint32_t tag, TIFFDataType field_type)
static TIFFSetGetFieldType	_TIFFSetGetType (TIFFDataType type, short count, unsigned char passcount)
int	TIFFMergeFieldInfo (TIFF *tif, const TIFFFieldInfo info[], uint32_t n)
int	_TIFFCheckFieldIsValidForCodec (TIFF *tif, ttag_t tag)

Variables
static const TIFFFieldArray	tiffFieldArray
static const TIFFFieldArray	exifFieldArray
static const TIFFFieldArray	gpsFieldArray
static const TIFFField	tiffFields []
static const TIFFField	exifFields []
static const TIFFField	gpsFields []

Function Documentation

_TIFFCheckFieldIsValidForCodec()

int _TIFFCheckFieldIsValidForCodec	(	TIFF *	tif,
		ttag_t	tag
	)

Definition at line 1247 of file tif_dirinfo.c.

{
    /* Filter out non-codec specific tags */
    switch (tag)
    {
        /* Shared tags */
        case TIFFTAG_PREDICTOR:
        /* JPEG tags */
        case TIFFTAG_JPEGTABLES:
        /* OJPEG tags */
        case TIFFTAG_JPEGIFOFFSET:
        case TIFFTAG_JPEGIFBYTECOUNT:
        case TIFFTAG_JPEGQTABLES:
        case TIFFTAG_JPEGDCTABLES:
        case TIFFTAG_JPEGACTABLES:
        case TIFFTAG_JPEGPROC:
        case TIFFTAG_JPEGRESTARTINTERVAL:
        /* CCITT* */
        case TIFFTAG_BADFAXLINES:
        case TIFFTAG_CLEANFAXDATA:
        case TIFFTAG_CONSECUTIVEBADFAXLINES:
        case TIFFTAG_GROUP3OPTIONS:
        case TIFFTAG_GROUP4OPTIONS:
        /* LERC */
        case TIFFTAG_LERC_PARAMETERS:
            break;
        default:
            return 1;
    }
    if (!TIFFIsCODECConfigured(tif->tif_dir.td_compression))
    {
        return 0;
    }
    /* Check if codec specific tags are allowed for the current
     * compression scheme (codec) */
    switch (tif->tif_dir.td_compression)
    {
        case COMPRESSION_LZW:
            if (tag == TIFFTAG_PREDICTOR)
                return 1;
            break;
        case COMPRESSION_PACKBITS:
            /* No codec-specific tags */
            break;
        case COMPRESSION_THUNDERSCAN:
            /* No codec-specific tags */
            break;
        case COMPRESSION_NEXT:
            /* No codec-specific tags */
            break;
        case COMPRESSION_JPEG:
            if (tag == TIFFTAG_JPEGTABLES)
                return 1;
            break;
        case COMPRESSION_OJPEG:
            switch (tag)
            {
                case TIFFTAG_JPEGIFOFFSET:
                case TIFFTAG_JPEGIFBYTECOUNT:
                case TIFFTAG_JPEGQTABLES:
                case TIFFTAG_JPEGDCTABLES:
                case TIFFTAG_JPEGACTABLES:
                case TIFFTAG_JPEGPROC:
                case TIFFTAG_JPEGRESTARTINTERVAL:
                    return 1;
            }
            break;
        case COMPRESSION_CCITTRLE:
        case COMPRESSION_CCITTRLEW:
        case COMPRESSION_CCITTFAX3:
        case COMPRESSION_CCITTFAX4:
            switch (tag)
            {
                case TIFFTAG_BADFAXLINES:
                case TIFFTAG_CLEANFAXDATA:
                case TIFFTAG_CONSECUTIVEBADFAXLINES:
                    return 1;
                case TIFFTAG_GROUP3OPTIONS:
                    if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX3)
                        return 1;
                    break;
                case TIFFTAG_GROUP4OPTIONS:
                    if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4)
                        return 1;
                    break;
            }
            break;
        case COMPRESSION_JBIG:
            /* No codec-specific tags */
            break;
        case COMPRESSION_DEFLATE:
        case COMPRESSION_ADOBE_DEFLATE:
            if (tag == TIFFTAG_PREDICTOR)
                return 1;
            break;
        case COMPRESSION_PIXARLOG:
            if (tag == TIFFTAG_PREDICTOR)
                return 1;
            break;
        case COMPRESSION_SGILOG:
        case COMPRESSION_SGILOG24:
            /* No codec-specific tags */
            break;
        case COMPRESSION_LZMA:
            if (tag == TIFFTAG_PREDICTOR)
                return 1;
            break;
        case COMPRESSION_ZSTD:
            if (tag == TIFFTAG_PREDICTOR)
                return 1;
            break;
        case COMPRESSION_LERC:
            if (tag == TIFFTAG_LERC_PARAMETERS)
                return 1;
            break;
    }
    return 0;
}

Referenced by TIFFReadDirectory().

_TIFFCreateAnonField()

TIFFField * _TIFFCreateAnonField	(	TIFF *	tif,
		uint32_t	tag,
		TIFFDataType	field_type
	)

Definition at line 898 of file tif_dirinfo.c.

{
    TIFFField *fld;
    (void)tif;
 
    fld = (TIFFField *)_TIFFmallocExt(tif, sizeof(TIFFField));
    if (fld == NULL)
        return NULL;
    _TIFFmemset(fld, 0, sizeof(TIFFField));
 
    fld->field_tag = tag;
    fld->field_readcount = TIFF_VARIABLE2;
    fld->field_writecount = TIFF_VARIABLE2;
    fld->field_type = field_type;
    fld->field_anonymous =
        1; /* indicate that this is an anonymous / unknown tag */
    switch (field_type)
    {
        case TIFF_BYTE:
        case TIFF_UNDEFINED:
            fld->set_get_field_type = TIFF_SETGET_C32_UINT8;
            break;
        case TIFF_ASCII:
            fld->set_get_field_type = TIFF_SETGET_C32_ASCII;
            break;
        case TIFF_SHORT:
            fld->set_get_field_type = TIFF_SETGET_C32_UINT16;
            break;
        case TIFF_LONG:
            fld->set_get_field_type = TIFF_SETGET_C32_UINT32;
            break;
        case TIFF_RATIONAL:
        case TIFF_SRATIONAL:
        case TIFF_FLOAT:
            fld->set_get_field_type = TIFF_SETGET_C32_FLOAT;
            break;
        case TIFF_SBYTE:
            fld->set_get_field_type = TIFF_SETGET_C32_SINT8;
            break;
        case TIFF_SSHORT:
            fld->set_get_field_type = TIFF_SETGET_C32_SINT16;
            break;
        case TIFF_SLONG:
            fld->set_get_field_type = TIFF_SETGET_C32_SINT32;
            break;
        case TIFF_DOUBLE:
            fld->set_get_field_type = TIFF_SETGET_C32_DOUBLE;
            break;
        case TIFF_IFD:
        case TIFF_IFD8:
            fld->set_get_field_type = TIFF_SETGET_C32_IFD8;
            break;
        case TIFF_LONG8:
            fld->set_get_field_type = TIFF_SETGET_C32_UINT64;
            break;
        case TIFF_SLONG8:
            fld->set_get_field_type = TIFF_SETGET_C32_SINT64;
            break;
        default:
            fld->set_get_field_type = TIFF_SETGET_UNDEFINED;
            break;
    }
    fld->field_bit = FIELD_CUSTOM;
    fld->field_oktochange = TRUE;
    fld->field_passcount = TRUE;
    fld->field_name = (char *)_TIFFmallocExt(tif, 32);
    if (fld->field_name == NULL)
    {
        _TIFFfreeExt(tif, fld);
        return NULL;
    }
    fld->field_subfields = NULL;
 
    /*
     * note that this name is a special sign to TIFFClose() and
     * _TIFFSetupFields() to free the field
     * Update:
     *   This special sign is replaced by fld->field_anonymous  flag.
     */
    (void)snprintf(fld->field_name, 32, "Tag %d", (int)tag);
 
    return fld;
}

Referenced by _TIFFFindOrRegisterField(), TIFFReadCustomDirectory(), and TIFFReadDirectory().

_TIFFFindFieldByName()

static const TIFFField * _TIFFFindFieldByName ( TIFF *  tif, const char *  field_name, TIFFDataType  dt  )

static

Definition at line 818 of file tif_dirinfo.c.

{
    TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0, 0, NULL, NULL};
    TIFFField *pkey = &key;
    const TIFFField **ret;
    if (tif->tif_foundfield &&
        streq(tif->tif_foundfield->field_name, field_name) &&
        (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
        return (tif->tif_foundfield);
 
    /* If we are invoked with no field information, then just return. */
    if (!tif->tif_fields)
        return NULL;
 
    /* NB: use linear search since list is sorted by key#, not name */
 
    key.field_name = (char *)field_name;
    key.field_type = dt;
 
    ret =
        (const TIFFField **)td_lfind(&pkey, tif->tif_fields, &tif->tif_nfields,
                                     sizeof(TIFFField *), tagNameCompare);
 
    return tif->tif_foundfield = (ret ? *ret : NULL);
}

Referenced by TIFFFieldWithName().

_TIFFFindOrRegisterField()

const TIFFField * _TIFFFindOrRegisterField	(	TIFF *	tif,
		uint32_t	tag,
		TIFFDataType	dt
	)

Definition at line 881 of file tif_dirinfo.c.

{
    const TIFFField *fld;
 
    fld = TIFFFindField(tif, tag, dt);
    if (fld == NULL)
    {
        fld = _TIFFCreateAnonField(tif, tag, dt);
        if (fld == NULL || !_TIFFMergeFields(tif, fld, 1))
            return NULL;
    }
 
    return fld;
}

_TIFFGetExifFields()

const TIFFFieldArray * _TIFFGetExifFields

(

void

)

Definition at line 509 of file tif_dirinfo.c.

{ return (&exifFieldArray); }

Referenced by TIFFCreateEXIFDirectory(), and TIFFReadEXIFDirectory().

_TIFFGetFields()

const TIFFFieldArray * _TIFFGetFields

(

void

)

Definition at line 507 of file tif_dirinfo.c.

{ return (&tiffFieldArray); }

Referenced by TIFFDefaultDirectory().

_TIFFGetGpsFields()

const TIFFFieldArray * _TIFFGetGpsFields

(

void

)

Definition at line 511 of file tif_dirinfo.c.

{ return (&gpsFieldArray); }

Referenced by TIFFCreateGPSDirectory(), and TIFFReadGPSDirectory().

_TIFFMergeFields()

int _TIFFMergeFields	(	TIFF *	tif,
		const TIFFField	info[],
		uint32_t	n
	)

Definition at line 573 of file tif_dirinfo.c.

{
    static const char module[] = "_TIFFMergeFields";
    static const char reason[] = "for fields array";
    /* TIFFField** tp; */
    uint32_t i;
 
    tif->tif_foundfield = NULL;
 
    if (tif->tif_fields && tif->tif_nfields > 0)
    {
        tif->tif_fields = (TIFFField **)_TIFFCheckRealloc(
            tif, tif->tif_fields, (tif->tif_nfields + n), sizeof(TIFFField *),
            reason);
    }
    else
    {
        tif->tif_fields =
            (TIFFField **)_TIFFCheckMalloc(tif, n, sizeof(TIFFField *), reason);
    }
    if (!tif->tif_fields)
    {
        TIFFErrorExtR(tif, module, "Failed to allocate fields array");
        return 0;
    }
 
    /* tp = tif->tif_fields + tif->tif_nfields; */
    for (i = 0; i < n; i++)
    {
        const TIFFField *fip = TIFFFindField(tif, info[i].field_tag, TIFF_ANY);
 
        /* only add definitions that aren't already present */
        if (!fip)
        {
            tif->tif_fields[tif->tif_nfields] = (TIFFField *)(info + i);
            tif->tif_nfields++;
        }
    }
 
    /* Sort the field info by tag number */
    qsort(tif->tif_fields, tif->tif_nfields, sizeof(TIFFField *), tagCompare);
 
    return n;
}

Referenced by _TIFFFindOrRegisterField(), _TIFFSetupFields(), TIFFMergeFieldInfo(), TIFFPredictorInit(), TIFFReadCustomDirectory(), and TIFFReadDirectory().

_TIFFPrintFieldInfo()

void _TIFFPrintFieldInfo	(	TIFF *	tif,
		FILE *	fd
	)

Definition at line 618 of file tif_dirinfo.c.

{
    uint32_t i;
 
    fprintf(fd, "%s: \n", tif->tif_name);
    for (i = 0; i < tif->tif_nfields; i++)
    {
        const TIFFField *fip = tif->tif_fields[i];
        fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n",
                (int)i, (unsigned long)fip->field_tag, fip->field_readcount,
                fip->field_writecount, fip->field_type, fip->field_bit,
                fip->field_oktochange ? "TRUE" : "FALSE",
                fip->field_passcount ? "TRUE" : "FALSE", fip->field_name);
    }
}

_TIFFSetGetType()

static TIFFSetGetFieldType _TIFFSetGetType ( TIFFDataType  type, short  count, unsigned char  passcount  )

static

Definition at line 990 of file tif_dirinfo.c.

{
    if (type == TIFF_ASCII && count == TIFF_VARIABLE && passcount == 0)
        return TIFF_SETGET_ASCII;
 
    else if (count == 1 && passcount == 0)
    {
        switch (type)
        {
            case TIFF_BYTE:
            case TIFF_UNDEFINED:
                return TIFF_SETGET_UINT8;
            case TIFF_ASCII:
                return TIFF_SETGET_ASCII;
            case TIFF_SHORT:
                return TIFF_SETGET_UINT16;
            case TIFF_LONG:
                return TIFF_SETGET_UINT32;
            case TIFF_RATIONAL:
            case TIFF_SRATIONAL:
            case TIFF_FLOAT:
                return TIFF_SETGET_FLOAT;
            case TIFF_SBYTE:
                return TIFF_SETGET_SINT8;
            case TIFF_SSHORT:
                return TIFF_SETGET_SINT16;
            case TIFF_SLONG:
                return TIFF_SETGET_SINT32;
            case TIFF_DOUBLE:
                return TIFF_SETGET_DOUBLE;
            case TIFF_IFD:
            case TIFF_IFD8:
                return TIFF_SETGET_IFD8;
            case TIFF_LONG8:
                return TIFF_SETGET_UINT64;
            case TIFF_SLONG8:
                return TIFF_SETGET_SINT64;
            default:
                return TIFF_SETGET_UNDEFINED;
        }
    }
 
    else if (count >= 1 && passcount == 0)
    {
        switch (type)
        {
            case TIFF_BYTE:
            case TIFF_UNDEFINED:
                return TIFF_SETGET_C0_UINT8;
            case TIFF_ASCII:
                return TIFF_SETGET_C0_ASCII;
            case TIFF_SHORT:
                return TIFF_SETGET_C0_UINT16;
            case TIFF_LONG:
                return TIFF_SETGET_C0_UINT32;
            case TIFF_RATIONAL:
            case TIFF_SRATIONAL:
            case TIFF_FLOAT:
                return TIFF_SETGET_C0_FLOAT;
            case TIFF_SBYTE:
                return TIFF_SETGET_C0_SINT8;
            case TIFF_SSHORT:
                return TIFF_SETGET_C0_SINT16;
            case TIFF_SLONG:
                return TIFF_SETGET_C0_SINT32;
            case TIFF_DOUBLE:
                return TIFF_SETGET_C0_DOUBLE;
            case TIFF_IFD:
            case TIFF_IFD8:
                return TIFF_SETGET_C0_IFD8;
            case TIFF_LONG8:
                return TIFF_SETGET_C0_UINT64;
            case TIFF_SLONG8:
                return TIFF_SETGET_C0_SINT64;
            default:
                return TIFF_SETGET_UNDEFINED;
        }
    }
 
    else if (count == TIFF_VARIABLE && passcount == 1)
    {
        switch (type)
        {
            case TIFF_BYTE:
            case TIFF_UNDEFINED:
                return TIFF_SETGET_C16_UINT8;
            case TIFF_ASCII:
                return TIFF_SETGET_C16_ASCII;
            case TIFF_SHORT:
                return TIFF_SETGET_C16_UINT16;
            case TIFF_LONG:
                return TIFF_SETGET_C16_UINT32;
            case TIFF_RATIONAL:
            case TIFF_SRATIONAL:
            case TIFF_FLOAT:
                return TIFF_SETGET_C16_FLOAT;
            case TIFF_SBYTE:
                return TIFF_SETGET_C16_SINT8;
            case TIFF_SSHORT:
                return TIFF_SETGET_C16_SINT16;
            case TIFF_SLONG:
                return TIFF_SETGET_C16_SINT32;
            case TIFF_DOUBLE:
                return TIFF_SETGET_C16_DOUBLE;
            case TIFF_IFD:
            case TIFF_IFD8:
                return TIFF_SETGET_C16_IFD8;
            case TIFF_LONG8:
                return TIFF_SETGET_C16_UINT64;
            case TIFF_SLONG8:
                return TIFF_SETGET_C16_SINT64;
            default:
                return TIFF_SETGET_UNDEFINED;
        }
    }
 
    else if (count == TIFF_VARIABLE2 && passcount == 1)
    {
        switch (type)
        {
            case TIFF_BYTE:
            case TIFF_UNDEFINED:
                return TIFF_SETGET_C32_UINT8;
            case TIFF_ASCII:
                return TIFF_SETGET_C32_ASCII;
            case TIFF_SHORT:
                return TIFF_SETGET_C32_UINT16;
            case TIFF_LONG:
                return TIFF_SETGET_C32_UINT32;
            case TIFF_RATIONAL:
            case TIFF_SRATIONAL:
            case TIFF_FLOAT:
                return TIFF_SETGET_C32_FLOAT;
            case TIFF_SBYTE:
                return TIFF_SETGET_C32_SINT8;
            case TIFF_SSHORT:
                return TIFF_SETGET_C32_SINT16;
            case TIFF_SLONG:
                return TIFF_SETGET_C32_SINT32;
            case TIFF_DOUBLE:
                return TIFF_SETGET_C32_DOUBLE;
            case TIFF_IFD:
            case TIFF_IFD8:
                return TIFF_SETGET_C32_IFD8;
            case TIFF_LONG8:
                return TIFF_SETGET_C32_UINT64;
            case TIFF_SLONG8:
                return TIFF_SETGET_C32_SINT64;
            default:
                return TIFF_SETGET_UNDEFINED;
        }
    }
 
    return TIFF_SETGET_UNDEFINED;
}

Referenced by TIFFMergeFieldInfo().

_TIFFSetupFields()

void _TIFFSetupFields	(	TIFF *	tif,
		const TIFFFieldArray *	fieldarray
	)

Definition at line 513 of file tif_dirinfo.c.

{
    if (tif->tif_fields && tif->tif_nfields > 0)
    {
        uint32_t i;
 
        for (i = 0; i < tif->tif_nfields; i++)
        {
            TIFFField *fld = tif->tif_fields[i];
            if (fld->field_name != NULL)
            {
                if (fld->field_bit == FIELD_CUSTOM && TIFFFieldIsAnonymous(fld))
                {
                    _TIFFfreeExt(tif, fld->field_name);
                    /* caution: tif_fields[i] must not be the beginning of a
                     * fields-array. Otherwise the following tags are also freed
                     * with the first free().
                     */
                    _TIFFfreeExt(tif, fld);
                }
            }
        }
 
        _TIFFfreeExt(tif, tif->tif_fields);
        tif->tif_fields = NULL;
        tif->tif_nfields = 0;
    }
    if (!_TIFFMergeFields(tif, fieldarray->fields, fieldarray->count))
    {
        TIFFErrorExtR(tif, "_TIFFSetupFields", "Setting up field info failed");
    }
}

Referenced by TIFFCreateCustomDirectory(), TIFFDefaultDirectory(), and TIFFReadCustomDirectory().

tagCompare()

static int tagCompare ( const void *  a, const void *  b  )

static

Definition at line 546 of file tif_dirinfo.c.

{
    const TIFFField *ta = *(const TIFFField **)a;
    const TIFFField *tb = *(const TIFFField **)b;
    /* NB: be careful of return values for 16-bit platforms */
    if (ta->field_tag != tb->field_tag)
        return (int)ta->field_tag - (int)tb->field_tag;
    else
        return (ta->field_type == TIFF_ANY)
                   ? 0
                   : ((int)tb->field_type - (int)ta->field_type);
}

Referenced by _TIFFMergeFields(), and TIFFFindField().

tagNameCompare()

static int tagNameCompare ( const void *  a, const void *  b  )

static

Definition at line 559 of file tif_dirinfo.c.

{
    const TIFFField *ta = *(const TIFFField **)a;
    const TIFFField *tb = *(const TIFFField **)b;
    int ret = strcmp(ta->field_name, tb->field_name);
 
    if (ret)
        return ret;
    else
        return (ta->field_type == TIFF_ANY)
                   ? 0
                   : ((int)tb->field_type - (int)ta->field_type);
}

Referenced by _TIFFFindFieldByName().

td_lfind()

static void * td_lfind ( const void *  key, const void *  base, size_t *  nmemb, size_t  size, int(*)(const void *, const void *)  compar  )

static

Definition at line 494 of file tif_dirinfo.c.

{
    char *element, *end;
 
    end = (char *)base + *nmemb * size;
    for (element = (char *)base; element < end; element += size)
        if (!compar(key, element)) /* key found */
            return element;
 
    return NULL;
}

Referenced by _TIFFFindFieldByName().

TIFFDataWidth()

int TIFFDataWidth

(

TIFFDataType

type

)

Definition at line 637 of file tif_dirinfo.c.

{
    switch (type)
    {
        case 0: /* nothing */
        case TIFF_BYTE:
        case TIFF_ASCII:
        case TIFF_SBYTE:
        case TIFF_UNDEFINED:
            return 1;
        case TIFF_SHORT:
        case TIFF_SSHORT:
            return 2;
        case TIFF_LONG:
        case TIFF_SLONG:
        case TIFF_FLOAT:
        case TIFF_IFD:
            return 4;
        case TIFF_RATIONAL:
        case TIFF_SRATIONAL:
        case TIFF_DOUBLE:
        case TIFF_LONG8:
        case TIFF_SLONG8:
        case TIFF_IFD8:
            return 8;
        default:
            return 0; /* will return 0 for unknown types */
    }
}

Referenced by _TIFFRewriteField(), EstimateStripByteCounts(), EvaluateIFDdatasizeReading(), and TIFFReadDirEntryArrayWithLimit().

TIFFFieldDataType()

TIFFDataType TIFFFieldDataType

(

const TIFFField *

fip

)

Definition at line 871 of file tif_dirinfo.c.

{ return fip->field_type; }

TIFFFieldIsAnonymous()

int TIFFFieldIsAnonymous

(

const TIFFField *

fip

)

Definition at line 879 of file tif_dirinfo.c.

{ return fip->field_anonymous; }

Referenced by _TIFFPrettyPrintField(), _TIFFPrintField(), _TIFFSetupFields(), TIFFCleanup(), and TIFFReadCustomDirectory().

TIFFFieldName()

const char * TIFFFieldName

(

const TIFFField *

fip

)

Definition at line 869 of file tif_dirinfo.c.

{ return fip->field_name; }

TIFFFieldPassCount()

int TIFFFieldPassCount

(

const TIFFField *

fip

)

Definition at line 873 of file tif_dirinfo.c.

{ return fip->field_passcount; }

TIFFFieldReadCount()

int TIFFFieldReadCount

(

const TIFFField *

fip

)

Definition at line 875 of file tif_dirinfo.c.

{ return fip->field_readcount; }

TIFFFieldSetGetCountSize()

int TIFFFieldSetGetCountSize

(

const TIFFField *

fip

)

Definition at line 757 of file tif_dirinfo.c.

{
    if (fip == NULL)
        return 0;
 
    switch (fip->set_get_field_type)
    {
        case TIFF_SETGET_C16_ASCII:
        case TIFF_SETGET_C16_UINT8:
        case TIFF_SETGET_C16_SINT8:
        case TIFF_SETGET_C16_UINT16:
        case TIFF_SETGET_C16_SINT16:
        case TIFF_SETGET_C16_UINT32:
        case TIFF_SETGET_C16_SINT32:
        case TIFF_SETGET_C16_FLOAT:
        case TIFF_SETGET_C16_UINT64:
        case TIFF_SETGET_C16_SINT64:
        case TIFF_SETGET_C16_DOUBLE:
        case TIFF_SETGET_C16_IFD8:
            return 2;
        case TIFF_SETGET_C32_ASCII:
        case TIFF_SETGET_C32_UINT8:
        case TIFF_SETGET_C32_SINT8:
        case TIFF_SETGET_C32_UINT16:
        case TIFF_SETGET_C32_SINT16:
        case TIFF_SETGET_C32_UINT32:
        case TIFF_SETGET_C32_SINT32:
        case TIFF_SETGET_C32_FLOAT:
        case TIFF_SETGET_C32_UINT64:
        case TIFF_SETGET_C32_SINT64:
        case TIFF_SETGET_C32_DOUBLE:
        case TIFF_SETGET_C32_IFD8:
            return 4;
        default:
            return 0;
    }
} /*-- TIFFFieldSetGetCountSize() --- */

TIFFFieldSetGetSize()

int TIFFFieldSetGetSize

(

const TIFFField *

fip

)

Definition at line 673 of file tif_dirinfo.c.

{
    /*
     * TIFFSetField() and TIFFGetField() must provide the parameter accordingly
     * to the definition of "set_get_field_type" of the tag definition in
     * dir_info.c. This function returns the data size for that purpose.
     *
     * Furthermore, this data size is also used for the internal storage,
     * even for TIFF_RATIONAL values for FIELD_CUSTOM, which are stored
     * internally as 4-byte float, but some of them should be stored internally
     * as 8-byte double, depending on the "set_get_field_type" _FLOAT_ or
     * _DOUBLE_.
     */
    if (fip == NULL)
        return 0;
 
    switch (fip->set_get_field_type)
    {
        case TIFF_SETGET_UNDEFINED:
        case TIFF_SETGET_ASCII:
        case TIFF_SETGET_C0_ASCII:
        case TIFF_SETGET_C16_ASCII:
        case TIFF_SETGET_C32_ASCII:
        case TIFF_SETGET_OTHER:
            return 1;
        case TIFF_SETGET_UINT8:
        case TIFF_SETGET_SINT8:
        case TIFF_SETGET_C0_UINT8:
        case TIFF_SETGET_C0_SINT8:
        case TIFF_SETGET_C16_UINT8:
        case TIFF_SETGET_C16_SINT8:
        case TIFF_SETGET_C32_UINT8:
        case TIFF_SETGET_C32_SINT8:
            return 1;
        case TIFF_SETGET_UINT16:
        case TIFF_SETGET_SINT16:
        case TIFF_SETGET_C0_UINT16:
        case TIFF_SETGET_C0_SINT16:
        case TIFF_SETGET_C16_UINT16:
        case TIFF_SETGET_C16_SINT16:
        case TIFF_SETGET_C32_UINT16:
        case TIFF_SETGET_C32_SINT16:
            return 2;
        case TIFF_SETGET_INT:
        case TIFF_SETGET_UINT32:
        case TIFF_SETGET_SINT32:
        case TIFF_SETGET_FLOAT:
        case TIFF_SETGET_UINT16_PAIR:
        case TIFF_SETGET_C0_UINT32:
        case TIFF_SETGET_C0_SINT32:
        case TIFF_SETGET_C0_FLOAT:
        case TIFF_SETGET_C16_UINT32:
        case TIFF_SETGET_C16_SINT32:
        case TIFF_SETGET_C16_FLOAT:
        case TIFF_SETGET_C32_UINT32:
        case TIFF_SETGET_C32_SINT32:
        case TIFF_SETGET_C32_FLOAT:
            return 4;
        case TIFF_SETGET_UINT64:
        case TIFF_SETGET_SINT64:
        case TIFF_SETGET_DOUBLE:
        case TIFF_SETGET_IFD8:
        case TIFF_SETGET_C0_UINT64:
        case TIFF_SETGET_C0_SINT64:
        case TIFF_SETGET_C0_DOUBLE:
        case TIFF_SETGET_C0_IFD8:
        case TIFF_SETGET_C16_UINT64:
        case TIFF_SETGET_C16_SINT64:
        case TIFF_SETGET_C16_DOUBLE:
        case TIFF_SETGET_C16_IFD8:
        case TIFF_SETGET_C32_UINT64:
        case TIFF_SETGET_C32_SINT64:
        case TIFF_SETGET_C32_DOUBLE:
        case TIFF_SETGET_C32_IFD8:
            return 8;
        default:
            return 0;
    }
} /*-- TIFFFieldSetGetSize() --- */

Referenced by _TIFFPrintField(), _TIFFVGetField(), _TIFFVSetField(), TIFFPrintDirectory(), and TIFFWriteDirectorySec().

TIFFFieldTag()

uint32_t TIFFFieldTag

(

const TIFFField *

fip

)

Definition at line 867 of file tif_dirinfo.c.

{ return fip->field_tag; }

Referenced by TIFFWriteDirectorySec().

TIFFFieldWithName()

const TIFFField * TIFFFieldWithName	(	TIFF *	tif,
		const char *	field_name
	)

Definition at line 856 of file tif_dirinfo.c.

{
    const TIFFField *fip = _TIFFFindFieldByName(tif, field_name, TIFF_ANY);
    if (!fip)
    {
        TIFFWarningExtR(tif, "TIFFFieldWithName", "Warning, unknown tag %s",
                        field_name);
    }
    return (fip);
}

TIFFFieldWithTag()

const TIFFField * TIFFFieldWithTag	(	TIFF *	tif,
		uint32_t	tag
	)

Definition at line 845 of file tif_dirinfo.c.

{
    const TIFFField *fip = TIFFFindField(tif, tag, TIFF_ANY);
    if (!fip)
    {
        TIFFWarningExtR(tif, "TIFFFieldWithTag", "Warning, unknown tag 0x%x",
                        (unsigned int)tag);
    }
    return (fip);
}

Referenced by _TIFFVSetField(), CheckDirCount(), TIFFFetchStripThing(), TIFFPrintDirectory(), TIFFReadDirectory(), and TIFFUnsetField().

TIFFFieldWriteCount()

int TIFFFieldWriteCount

(

const TIFFField *

fip

)

Definition at line 877 of file tif_dirinfo.c.

{ return fip->field_writecount; }

TIFFFindField()

const TIFFField * TIFFFindField	(	TIFF *	tif,
		uint32_t	tag,
		TIFFDataType	dt
	)

Definition at line 795 of file tif_dirinfo.c.

{
    TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0, 0, NULL, NULL};
    TIFFField *pkey = &key;
    const TIFFField **ret;
    if (tif->tif_foundfield && tif->tif_foundfield->field_tag == tag &&
        (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
        return tif->tif_foundfield;
 
    /* If we are invoked with no field information, then just return. */
    if (!tif->tif_fields)
        return NULL;
 
    /* NB: use sorted search (e.g. binary search) */
 
    key.field_tag = tag;
    key.field_type = dt;
 
    ret = (const TIFFField **)bsearch(&pkey, tif->tif_fields, tif->tif_nfields,
                                      sizeof(TIFFField *), tagCompare);
    return tif->tif_foundfield = (ret ? *ret : NULL);
}

Referenced by _TIFFFindOrRegisterField(), _TIFFMergeFields(), _TIFFRewriteField(), _TIFFVGetField(), _TIFFVSetField(), OkToChangeTag(), TIFFFieldWithTag(), and TIFFVGetField().

TIFFMergeFieldInfo()

int TIFFMergeFieldInfo	(	TIFF *	tif,
		const TIFFFieldInfo	info[],
		uint32_t	n
	)

Definition at line 1147 of file tif_dirinfo.c.

{
    static const char module[] = "TIFFMergeFieldInfo";
    static const char reason[] = "for fields array";
    TIFFField *tp;
    size_t nfields;
    uint32_t i;
 
    if (tif->tif_nfieldscompat > 0)
    {
        tif->tif_fieldscompat = (TIFFFieldArray *)_TIFFCheckRealloc(
            tif, tif->tif_fieldscompat, tif->tif_nfieldscompat + 1,
            sizeof(TIFFFieldArray), reason);
    }
    else
    {
        tif->tif_fieldscompat = (TIFFFieldArray *)_TIFFCheckMalloc(
            tif, 1, sizeof(TIFFFieldArray), reason);
    }
    if (!tif->tif_fieldscompat)
    {
        TIFFErrorExtR(tif, module, "Failed to allocate fields array");
        return -1;
    }
    nfields = tif->tif_nfieldscompat++;
 
    tif->tif_fieldscompat[nfields].type = tfiatOther;
    tif->tif_fieldscompat[nfields].allocated_size = n;
    tif->tif_fieldscompat[nfields].count = n;
    tif->tif_fieldscompat[nfields].fields =
        (TIFFField *)_TIFFCheckMalloc(tif, n, sizeof(TIFFField), reason);
    if (!tif->tif_fieldscompat[nfields].fields)
    {
        TIFFErrorExtR(tif, module, "Failed to allocate fields array");
        return -1;
    }
 
    tp = tif->tif_fieldscompat[nfields].fields;
    for (i = 0; i < n; i++)
    {
        tp->field_tag = info[i].field_tag;
        if (info[i].field_readcount < TIFF_VARIABLE2 ||
            info[i].field_writecount < TIFF_VARIABLE2)
        {
            /* The fields (field_readcount) and (field_writecount) may use the
             * values TIFF_VARIABLE (-1), TIFF_SPP (-2), TIFF_VARIABLE2 (-3). */
            TIFFErrorExtR(
                tif, module,
                "The value of field_readcount %d and field_writecount %d "
                "must be greater than or equal to -3.",
                info[i].field_readcount, info[i].field_writecount);
            return -1;
        }
        if ((info[i].field_readcount == 0 || info[i].field_writecount == 0) &&
            info[i].field_bit != FIELD_IGNORE)
        {
            /* The fields (field_readcount) and (field_writecount) may only
            be zero for pseudo_tags or ignored tags. */
            TIFFErrorExtR(
                tif, module,
                "The value of field_readcount %d and field_writecount %d "
                "may only be zero for field_bit = 0 (i.e. ignored tags).",
                info[i].field_readcount, info[i].field_writecount);
            return -1;
        }
        tp->field_readcount = info[i].field_readcount;
        tp->field_writecount = info[i].field_writecount;
        tp->field_type = info[i].field_type;
        tp->field_anonymous = 0;
        tp->set_get_field_type =
            _TIFFSetGetType(info[i].field_type, info[i].field_writecount,
                            info[i].field_passcount);
        tp->field_bit = info[i].field_bit;
        tp->field_oktochange = info[i].field_oktochange;
        tp->field_passcount = info[i].field_passcount;
        /* Define an empty static string to be passed as field_name where a NULL
         * pointer is passed in. Otherwise, this will lead to buffer overflow
         * furtheron. */
        if (info[i].field_name == NULL)
        {
            static const char *string_static_empty = "";
            tp->field_name = (char *)string_static_empty;
        }
        else
        {
            tp->field_name = info[i].field_name;
        }
        tp->field_subfields = NULL;
        tp++;
    }
 
    if (!_TIFFMergeFields(tif, tif->tif_fieldscompat[nfields].fields, n))
    {
        TIFFErrorExtR(tif, module, "Setting up field info failed");
        return -1;
    }
 
    return 0;
}

Variable Documentation

exifFieldArray

static const TIFFFieldArray exifFieldArray

static

Initial value:

= {
    tfiatExif, 0, TIFFArrayCount(exifFields), (TIFFField *)exifFields}

Definition at line 49 of file tif_dirinfo.c.

Referenced by _TIFFGetExifFields(), and TIFFCreateEXIFDirectory().

exifFields

const TIFFField exifFields[]

static

Definition at line 350 of file tif_dirinfo.c.

gpsFieldArray

static const TIFFFieldArray gpsFieldArray

static

Initial value:

= {
    tfiatGps, 0, TIFFArrayCount(gpsFields), (TIFFField *)gpsFields}

Definition at line 50 of file tif_dirinfo.c.

Referenced by _TIFFGetGpsFields(), and TIFFCreateGPSDirectory().

gpsFields

const TIFFField gpsFields[]

static

Definition at line 442 of file tif_dirinfo.c.

tiffFieldArray

static const TIFFFieldArray tiffFieldArray

static

Initial value:

= {
    tfiatImage, 0, TIFFArrayCount(tiffFields), (TIFFField *)tiffFields}

Definition at line 48 of file tif_dirinfo.c.

Referenced by _TIFFGetFields(), and TIFFDefaultDirectory().

tiffFields

const TIFFField tiffFields[]

static

Definition at line 67 of file tif_dirinfo.c.