tif_dirinfo.c File Reference

#include <precomp.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)
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 n)
void	_TIFFPrintFieldInfo (TIFF *tif, FILE *fd)
int	TIFFDataWidth (TIFFDataType type)
int	_TIFFDataSize (TIFFDataType type)
const TIFFField *	TIFFFindField (TIFF *tif, uint32 tag, TIFFDataType dt)
static const TIFFField *	_TIFFFindFieldByName (TIFF *tif, const char *field_name, TIFFDataType dt)
const TIFFField *	TIFFFieldWithTag (TIFF *tif, uint32 tag)
const TIFFField *	TIFFFieldWithName (TIFF *tif, const char *field_name)
uint32	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)
const TIFFField *	_TIFFFindOrRegisterField (TIFF *tif, uint32 tag, TIFFDataType dt)
TIFFField *	_TIFFCreateAnonField (TIFF *tif, uint32 tag, TIFFDataType field_type)
static TIFFSetGetFieldType	_TIFFSetGetType (TIFFDataType type, short count, unsigned char passcount)
int	TIFFMergeFieldInfo (TIFF *tif, const TIFFFieldInfo info[], uint32 n)
int	_TIFFCheckFieldIsValidForCodec (TIFF *tif, ttag_t tag)

Variables
static const TIFFFieldArray	tiffFieldArray = { tfiatImage, 0, TIFFArrayCount(tiffFields), (TIFFField*) tiffFields }
static const TIFFFieldArray	exifFieldArray = { tfiatExif, 0, TIFFArrayCount(exifFields), (TIFFField*) exifFields }
static const TIFFField	tiffFields []
static const TIFFField	exifFields []

Function Documentation

_TIFFCheckFieldIsValidForCodec()

int _TIFFCheckFieldIsValidForCodec	(	TIFF *	tif,
		ttag_t	tag
	)

Definition at line 958 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;
    }
    /* 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;
          case COMPRESSION_WEBP:
        if (tag == TIFFTAG_PREDICTOR)
                return 1;
        break;
    }
    return 0;
}

Referenced by TIFFReadDirectory().

_TIFFCreateAnonField()

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

Definition at line 634 of file tif_dirinfo.c.

{
    TIFFField *fld;
    (void) tif;
 
    fld = (TIFFField *) _TIFFmalloc(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->reserved = 0;
    switch (field_type)
    {
        case TIFF_BYTE:
        case TIFF_UNDEFINED:
            fld->set_field_type = TIFF_SETGET_C32_UINT8;
            fld->get_field_type = TIFF_SETGET_C32_UINT8;
            break;
        case TIFF_ASCII:
            fld->set_field_type = TIFF_SETGET_C32_ASCII;
            fld->get_field_type = TIFF_SETGET_C32_ASCII;
            break;
        case TIFF_SHORT:
            fld->set_field_type = TIFF_SETGET_C32_UINT16;
            fld->get_field_type = TIFF_SETGET_C32_UINT16;
            break;
        case TIFF_LONG:
            fld->set_field_type = TIFF_SETGET_C32_UINT32;
            fld->get_field_type = TIFF_SETGET_C32_UINT32;
            break;
        case TIFF_RATIONAL:
        case TIFF_SRATIONAL:
        case TIFF_FLOAT:
            fld->set_field_type = TIFF_SETGET_C32_FLOAT;
            fld->get_field_type = TIFF_SETGET_C32_FLOAT;
            break;
        case TIFF_SBYTE:
            fld->set_field_type = TIFF_SETGET_C32_SINT8;
            fld->get_field_type = TIFF_SETGET_C32_SINT8;
            break;
        case TIFF_SSHORT:
            fld->set_field_type = TIFF_SETGET_C32_SINT16;
            fld->get_field_type = TIFF_SETGET_C32_SINT16;
            break;
        case TIFF_SLONG:
            fld->set_field_type = TIFF_SETGET_C32_SINT32;
            fld->get_field_type = TIFF_SETGET_C32_SINT32;
            break;
        case TIFF_DOUBLE:
            fld->set_field_type = TIFF_SETGET_C32_DOUBLE;
            fld->get_field_type = TIFF_SETGET_C32_DOUBLE;
            break;
        case TIFF_IFD:
        case TIFF_IFD8:
            fld->set_field_type = TIFF_SETGET_C32_IFD8;
            fld->get_field_type = TIFF_SETGET_C32_IFD8;
            break;
        case TIFF_LONG8:
            fld->set_field_type = TIFF_SETGET_C32_UINT64;
            fld->get_field_type = TIFF_SETGET_C32_UINT64;
            break;
        case TIFF_SLONG8:
            fld->set_field_type = TIFF_SETGET_C32_SINT64;
            fld->get_field_type = TIFF_SETGET_C32_SINT64;
            break;
        default:
            fld->set_field_type = TIFF_SETGET_UNDEFINED;
            fld->get_field_type = TIFF_SETGET_UNDEFINED;
            break;
    }
    fld->field_bit = FIELD_CUSTOM;
    fld->field_oktochange = TRUE;
    fld->field_passcount = TRUE;
    fld->field_name = (char *) _TIFFmalloc(32);
    if (fld->field_name == NULL) {
        _TIFFfree(fld);
        return NULL;
    }
    fld->field_subfields = NULL;
 
    /* 
     * note that this name is a special sign to TIFFClose() and
     * _TIFFSetupFields() to free the field
     */
    (void) snprintf(fld->field_name, 32, "Tag %d", (int) tag);
 
    return fld;    
}

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

_TIFFDataSize()

int _TIFFDataSize

(

TIFFDataType

type

)

Definition at line 476 of file tif_dirinfo.c.

{
    switch (type)
    {
        case TIFF_BYTE:
        case TIFF_SBYTE:
        case TIFF_ASCII:
        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:
        case TIFF_RATIONAL:
        case TIFF_SRATIONAL:
            return 4;
        case TIFF_DOUBLE:
        case TIFF_LONG8:
        case TIFF_SLONG8:
        case TIFF_IFD8:
            return 8;
        default:
            return 0;
    }
}

Referenced by _TIFFVSetField(), and TIFFPrintDirectory().

_TIFFFindFieldByName()

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

static

Definition at line 531 of file tif_dirinfo.c.

{
    TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 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	tag,
		TIFFDataType	dt
	)

Definition at line 618 of file tif_dirinfo.c.

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

_TIFFGetExifFields()

const TIFFFieldArray * _TIFFGetExifFields

(

void

)

Definition at line 311 of file tif_dirinfo.c.

{
    return(&exifFieldArray);
}

Referenced by TIFFCreateEXIFDirectory(), and TIFFReadEXIFDirectory().

_TIFFGetFields()

const TIFFFieldArray * _TIFFGetFields

(

void

)

Definition at line 305 of file tif_dirinfo.c.

{
    return(&tiffFieldArray);
}

Referenced by TIFFDefaultDirectory().

_TIFFMergeFields()

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

Definition at line 369 of file tif_dirinfo.c.

{
    static const char module[] = "_TIFFMergeFields";
    static const char reason[] = "for fields array";
    /* TIFFField** tp; */
    uint32 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) {
        TIFFErrorExt(tif->tif_clientdata, 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 414 of file tif_dirinfo.c.

{
    uint32 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 735 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 317 of file tif_dirinfo.c.

{
    if (tif->tif_fields && tif->tif_nfields > 0) {
        uint32 i;
 
        for (i = 0; i < tif->tif_nfields; i++) {
            TIFFField *fld = tif->tif_fields[i];
            if (fld->field_bit == FIELD_CUSTOM &&
                strncmp("Tag ", fld->field_name, 4) == 0) {
                    _TIFFfree(fld->field_name);
                    _TIFFfree(fld);
                }
        }
 
        _TIFFfree(tif->tif_fields);
        tif->tif_fields = NULL;
        tif->tif_nfields = 0;
    }
    if (!_TIFFMergeFields(tif, fieldarray->fields, fieldarray->count)) {
        TIFFErrorExt(tif->tif_clientdata, "_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 342 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 355 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 291 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 438 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(), and TIFFReadDirEntryArrayWithLimit().

TIFFFieldDataType()

TIFFDataType TIFFFieldDataType

(

const TIFFField *

fip

)

Definition at line 594 of file tif_dirinfo.c.

{
    return fip->field_type;
}

TIFFFieldName()

const char * TIFFFieldName

(

const TIFFField *

fip

)

Definition at line 588 of file tif_dirinfo.c.

{
    return fip->field_name;
}

TIFFFieldPassCount()

int TIFFFieldPassCount

(

const TIFFField *

fip

)

Definition at line 600 of file tif_dirinfo.c.

{
    return fip->field_passcount;
}

TIFFFieldReadCount()

int TIFFFieldReadCount

(

const TIFFField *

fip

)

Definition at line 606 of file tif_dirinfo.c.

{
    return fip->field_readcount;
}

TIFFFieldTag()

uint32 TIFFFieldTag

(

const TIFFField *

fip

)

Definition at line 582 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 570 of file tif_dirinfo.c.

{
    const TIFFField* fip =
        _TIFFFindFieldByName(tif, field_name, TIFF_ANY);
    if (!fip) {
        TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithName",
                 "Internal error, unknown tag %s", field_name);
    }
    return (fip);
}

TIFFFieldWithTag()

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

Definition at line 558 of file tif_dirinfo.c.

{
    const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY);
    if (!fip) {
        TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithTag",
                 "Internal error, 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 612 of file tif_dirinfo.c.

{
    return fip->field_writecount;
}

TIFFFindField()

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

Definition at line 506 of file tif_dirinfo.c.

{
    TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 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	n
	)

Definition at line 888 of file tif_dirinfo.c.

{
    static const char module[] = "TIFFMergeFieldInfo";
    static const char reason[] = "for fields array";
    TIFFField *tp;
    size_t nfields;
    uint32 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) {
        TIFFErrorExt(tif->tif_clientdata, 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) {
        TIFFErrorExt(tif->tif_clientdata, 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;
        tp->field_readcount = info[i].field_readcount;
        tp->field_writecount = info[i].field_writecount;
        tp->field_type = info[i].field_type;
        tp->reserved = 0;
        tp->set_field_type =
             _TIFFSetGetType(info[i].field_type,
                info[i].field_readcount,
                info[i].field_passcount);
        tp->get_field_type =
             _TIFFSetGetType(info[i].field_type,
                info[i].field_readcount,
                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;
        tp->field_name = info[i].field_name;
        tp->field_subfields = NULL;
        tp++;
    }
 
    if (!_TIFFMergeFields(tif, tif->tif_fieldscompat[nfields].fields, n)) {
        TIFFErrorExt(tif->tif_clientdata, module,
                 "Setting up field info failed");
        return -1;
    }
 
    return 0;
}

Variable Documentation

exifFieldArray

static const TIFFFieldArray exifFieldArray = { tfiatExif, 0, TIFFArrayCount(exifFields), (TIFFField*) exifFields }

static

Definition at line 49 of file tif_dirinfo.c.

Referenced by _TIFFGetExifFields(), TIFFCreateEXIFDirectory(), and TIFFReadEXIFDirectory().

exifFields

const TIFFField exifFields[]

static

Definition at line 221 of file tif_dirinfo.c.

tiffFieldArray

static const TIFFFieldArray tiffFieldArray = { tfiatImage, 0, TIFFArrayCount(tiffFields), (TIFFField*) tiffFields }

static

Definition at line 48 of file tif_dirinfo.c.

Referenced by _TIFFGetFields(), and TIFFDefaultDirectory().

tiffFields

const TIFFField tiffFields[]

static

Definition at line 55 of file tif_dirinfo.c.