static const TIFFFieldInfo *
GetField(TIFF *tiff, const char *tagname)
{
const TIFFFieldInfo *fip;
if( atoi(tagname) > 0 )
fip = TIFFFieldWithTag(tiff, (ttag_t)atoi(tagname));
else
fip = TIFFFieldWithName(tiff, tagname);
if (!fip) {
fprintf( stderr, "Field name %s not recognised.\n", tagname );
return (TIFFFieldInfo *)NULL;
}
return fip;
}
/*
* Setup a directory entry of an array of RATIONAL
* or SRATIONAL and write the associated indirect values.
*/
static int
TIFFWriteRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)
{
uint32 i;
uint32* t;
int status;
t = (uint32*) _TIFFmalloc(2 * dir->tdir_count * sizeof (uint32));
if (t == NULL) {
_TIFFError(tif, tif->tif_name,
"No space to write RATIONAL array");
return (0);
}
for (i = 0; i < dir->tdir_count; i++) {
float fv = v[i];
int sign = 1;
uint32 den;
if (fv < 0) {
if (dir->tdir_type == TIFF_RATIONAL) {
_TIFFWarning(tif, tif->tif_name,
"\"%s\": Information lost writing value (%g) as (unsigned) RATIONAL",
TIFFFieldWithTag(tif,dir->tdir_tag)->field_name,
fv);
fv = 0;
} else
fv = -fv, sign = -1;
}
den = 1L;
if (fv > 0) {
while (fv < 1L<<(31-3) && den < 1L<<(31-3))
fv *= 1<<3, den *= 1L<<3;
}
t[2*i+0] = (uint32) (sign * (fv + 0.5));
t[2*i+1] = den;
}
status = TIFFWriteData(tif, dir, (char *)t);
_TIFFfree((char*) t);
return (status);
}
/*
* Write a contiguous directory item.
*/
static int
TIFFWriteData(TIFF* tif, TIFFDirEntry* dir, char* cp)
{
tsize_t cc;
if (tif->tif_flags & TIFF_SWAB) {
switch (dir->tdir_type) {
case TIFF_SHORT:
case TIFF_SSHORT:
TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count);
break;
case TIFF_LONG:
case TIFF_SLONG:
case TIFF_FLOAT:
TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count);
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count);
break;
case TIFF_DOUBLE:
TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count);
break;
}
}
dir->tdir_offset = tif->tif_dataoff;
cc = dir->tdir_count * TIFFDataWidth((TIFFDataType) dir->tdir_type);
if (SeekOK(tif, dir->tdir_offset) &&
WriteOK(tif, cp, cc)) {
tif->tif_dataoff += (cc + 1) & ~1;
return (1);
}
_TIFFError(tif, tif->tif_name, "Error writing data for field \"%s\"",
TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
return (0);
}
/*
* Print the contents of the current directory
* to the specified stdio file stream.
*/
void
TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
{
TIFFDirectory *td = &tif->tif_dir;
char *sep;
uint16 i;
long l, n;
fprintf(fd, "TIFF Directory at offset 0x%lx (%lu)\n",
(unsigned long)tif->tif_diroff, (unsigned long)tif->tif_diroff);
if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) {
fprintf(fd, " Subfile Type:");
sep = " ";
if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) {
fprintf(fd, "%sreduced-resolution image", sep);
sep = "/";
}
if (td->td_subfiletype & FILETYPE_PAGE) {
fprintf(fd, "%smulti-page document", sep);
sep = "/";
}
if (td->td_subfiletype & FILETYPE_MASK)
fprintf(fd, "%stransparency mask", sep);
fprintf(fd, " (%lu = 0x%lx)\n",
(long) td->td_subfiletype, (long) td->td_subfiletype);
}
if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) {
fprintf(fd, " Image Width: %lu Image Length: %lu",
(unsigned long) td->td_imagewidth, (unsigned long) td->td_imagelength);
if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH))
fprintf(fd, " Image Depth: %lu",
(unsigned long) td->td_imagedepth);
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) {
fprintf(fd, " Tile Width: %lu Tile Length: %lu",
(unsigned long) td->td_tilewidth, (unsigned long) td->td_tilelength);
if (TIFFFieldSet(tif,FIELD_TILEDEPTH))
fprintf(fd, " Tile Depth: %lu",
(unsigned long) td->td_tiledepth);
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif,FIELD_RESOLUTION)) {
fprintf(fd, " Resolution: %g, %g",
td->td_xresolution, td->td_yresolution);
if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) {
switch (td->td_resolutionunit) {
case RESUNIT_NONE:
fprintf(fd, " (unitless)");
break;
case RESUNIT_INCH:
fprintf(fd, " pixels/inch");
break;
case RESUNIT_CENTIMETER:
fprintf(fd, " pixels/cm");
break;
default:
fprintf(fd, " (unit %u = 0x%x)",
td->td_resolutionunit,
td->td_resolutionunit);
break;
}
}
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif,FIELD_POSITION))
fprintf(fd, " Position: %g, %g\n",
td->td_xposition, td->td_yposition);
if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
fprintf(fd, " Bits/Sample: %u\n", td->td_bitspersample);
if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) {
fprintf(fd, " Sample Format: ");
switch (td->td_sampleformat) {
case SAMPLEFORMAT_VOID:
fprintf(fd, "void\n");
break;
case SAMPLEFORMAT_INT:
fprintf(fd, "signed integer\n");
break;
case SAMPLEFORMAT_UINT:
fprintf(fd, "unsigned integer\n");
break;
case SAMPLEFORMAT_IEEEFP:
fprintf(fd, "IEEE floating point\n");
break;
case SAMPLEFORMAT_COMPLEXINT:
fprintf(fd, "complex signed integer\n");
break;
case SAMPLEFORMAT_COMPLEXIEEEFP:
fprintf(fd, "complex IEEE floating point\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_sampleformat, td->td_sampleformat);
break;
}
}
if (TIFFFieldSet(tif,FIELD_COMPRESSION)) {
const TIFFCodec* c = TIFFFindCODEC(td->td_compression);
fprintf(fd, " Compression Scheme: ");
if (c)
fprintf(fd, "%s\n", c->name);
else
fprintf(fd, "%u (0x%x)\n",
td->td_compression, td->td_compression);
}
if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) {
fprintf(fd, " Photometric Interpretation: ");
if (td->td_photometric < NPHOTONAMES)
fprintf(fd, "%s\n", photoNames[td->td_photometric]);
else {
switch (td->td_photometric) {
case PHOTOMETRIC_LOGL:
fprintf(fd, "CIE Log2(L)\n");
break;
case PHOTOMETRIC_LOGLUV:
fprintf(fd, "CIE Log2(L) (u',v')\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_photometric, td->td_photometric);
break;
}
}
}
if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES) && td->td_extrasamples) {
fprintf(fd, " Extra Samples: %u<", td->td_extrasamples);
sep = "";
for (i = 0; i < td->td_extrasamples; i++) {
switch (td->td_sampleinfo[i]) {
case EXTRASAMPLE_UNSPECIFIED:
fprintf(fd, "%sunspecified", sep);
break;
case EXTRASAMPLE_ASSOCALPHA:
fprintf(fd, "%sassoc-alpha", sep);
break;
case EXTRASAMPLE_UNASSALPHA:
fprintf(fd, "%sunassoc-alpha", sep);
break;
default:
fprintf(fd, "%s%u (0x%x)", sep,
td->td_sampleinfo[i], td->td_sampleinfo[i]);
break;
}
sep = ", ";
}
fprintf(fd, ">\n");
}
if (TIFFFieldSet(tif,FIELD_INKNAMES)) {
char* cp;
fprintf(fd, " Ink Names: ");
i = td->td_samplesperpixel;
sep = "";
for (cp = td->td_inknames; i > 0; cp = strchr(cp,'\0')+1, i--) {
fputs(sep, fd);
_TIFFprintAscii(fd, cp);
sep = ", ";
}
fputs("\n", fd);
}
if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) {
fprintf(fd, " Thresholding: ");
switch (td->td_threshholding) {
case THRESHHOLD_BILEVEL:
fprintf(fd, "bilevel art scan\n");
break;
case THRESHHOLD_HALFTONE:
fprintf(fd, "halftone or dithered scan\n");
break;
case THRESHHOLD_ERRORDIFFUSE:
fprintf(fd, "error diffused\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_threshholding, td->td_threshholding);
break;
}
}
if (TIFFFieldSet(tif,FIELD_FILLORDER)) {
fprintf(fd, " FillOrder: ");
switch (td->td_fillorder) {
case FILLORDER_MSB2LSB:
fprintf(fd, "msb-to-lsb\n");
break;
case FILLORDER_LSB2MSB:
fprintf(fd, "lsb-to-msb\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_fillorder, td->td_fillorder);
break;
}
}
if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))
{
/*
* For hacky reasons (see tif_jpeg.c - JPEGFixupTestSubsampling),
* we need to fetch this rather than trust what is in our
* structures.
*/
uint16 subsampling[2];
TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
subsampling + 0, subsampling + 1 );
fprintf(fd, " YCbCr Subsampling: %u, %u\n",
subsampling[0], subsampling[1] );
}
if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) {
fprintf(fd, " YCbCr Positioning: ");
switch (td->td_ycbcrpositioning) {
case YCBCRPOSITION_CENTERED:
fprintf(fd, "centered\n");
break;
case YCBCRPOSITION_COSITED:
fprintf(fd, "cosited\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_ycbcrpositioning, td->td_ycbcrpositioning);
break;
}
}
if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS))
fprintf(fd, " Halftone Hints: light %u dark %u\n",
td->td_halftonehints[0], td->td_halftonehints[1]);
if (TIFFFieldSet(tif,FIELD_ORIENTATION)) {
fprintf(fd, " Orientation: ");
if (td->td_orientation < NORIENTNAMES)
fprintf(fd, "%s\n", orientNames[td->td_orientation]);
else
fprintf(fd, "%u (0x%x)\n",
td->td_orientation, td->td_orientation);
}
if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
fprintf(fd, " Samples/Pixel: %u\n", td->td_samplesperpixel);
if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) {
fprintf(fd, " Rows/Strip: ");
if (td->td_rowsperstrip == (uint32) -1)
fprintf(fd, "(infinite)\n");
else
fprintf(fd, "%lu\n", (unsigned long) td->td_rowsperstrip);
}
if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE))
fprintf(fd, " Min Sample Value: %u\n", td->td_minsamplevalue);
if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))
fprintf(fd, " Max Sample Value: %u\n", td->td_maxsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE))
fprintf(fd, " SMin Sample Value: %g\n",
td->td_sminsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE))
fprintf(fd, " SMax Sample Value: %g\n",
td->td_smaxsamplevalue);
if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) {
fprintf(fd, " Planar Configuration: ");
switch (td->td_planarconfig) {
case PLANARCONFIG_CONTIG:
fprintf(fd, "single image plane\n");
break;
case PLANARCONFIG_SEPARATE:
fprintf(fd, "separate image planes\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_planarconfig, td->td_planarconfig);
break;
}
}
if (TIFFFieldSet(tif,FIELD_PAGENUMBER))
fprintf(fd, " Page Number: %u-%u\n",
td->td_pagenumber[0], td->td_pagenumber[1]);
if (TIFFFieldSet(tif,FIELD_COLORMAP)) {
fprintf(fd, " Color Map: ");
if (flags & TIFFPRINT_COLORMAP) {
fprintf(fd, "\n");
n = 1L<<td->td_bitspersample;
for (l = 0; l < n; l++)
fprintf(fd, " %5lu: %5u %5u %5u\n",
l,
td->td_colormap[0][l],
td->td_colormap[1][l],
td->td_colormap[2][l]);
} else
fprintf(fd, "(present)\n");
}
if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) {
fprintf(fd, " Transfer Function: ");
if (flags & TIFFPRINT_CURVES) {
fprintf(fd, "\n");
n = 1L<<td->td_bitspersample;
for (l = 0; l < n; l++) {
fprintf(fd, " %2lu: %5u",
l, td->td_transferfunction[0][l]);
for (i = 1; i < td->td_samplesperpixel; i++)
fprintf(fd, " %5u",
td->td_transferfunction[i][l]);
fputc('\n', fd);
}
} else
fprintf(fd, "(present)\n");
}
if (TIFFFieldSet(tif, FIELD_SUBIFD)) {
fprintf(fd, " SubIFD Offsets:");
for (i = 0; i < td->td_nsubifd; i++)
fprintf(fd, " %5lu", (long) td->td_subifd[i]);
fputc('\n', fd);
}
/*
** Custom tag support.
*/
{
int i;
short count;
count = (short) TIFFGetTagListCount(tif);
for(i = 0; i < count; i++) {
ttag_t tag = TIFFGetTagListEntry(tif, i);
const TIFFFieldInfo *fip;
uint16 value_count;
int mem_alloc = 0;
void *raw_data;
fip = TIFFFieldWithTag(tif, tag);
if(fip == NULL)
continue;
if(fip->field_passcount) {
if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1)
continue;
} else {
if (fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2)
value_count = 1;
else if (fip->field_readcount == TIFF_SPP)
value_count = td->td_samplesperpixel;
else
value_count = fip->field_readcount;
if ((fip->field_type == TIFF_ASCII
|| fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2
|| fip->field_readcount == TIFF_SPP
|| value_count > 1)
&& fip->field_tag != TIFFTAG_PAGENUMBER
&& fip->field_tag != TIFFTAG_HALFTONEHINTS
&& fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
&& fip->field_tag != TIFFTAG_DOTRANGE) {
if(TIFFGetField(tif, tag, &raw_data) != 1)
continue;
} else if (fip->field_tag != TIFFTAG_PAGENUMBER
&& fip->field_tag != TIFFTAG_HALFTONEHINTS
&& fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
&& fip->field_tag != TIFFTAG_DOTRANGE) {
raw_data = _TIFFmalloc(
_TIFFDataSize(fip->field_type)
* value_count);
mem_alloc = 1;
if(TIFFGetField(tif, tag, raw_data) != 1) {
_TIFFfree(raw_data);
continue;
}
} else {
/*
* XXX: Should be fixed and removed, see the
* notes related to TIFFTAG_PAGENUMBER,
* TIFFTAG_HALFTONEHINTS,
* TIFFTAG_YCBCRSUBSAMPLING and
* TIFFTAG_DOTRANGE tags in tif_dir.c. */
char *tmp;
raw_data = _TIFFmalloc(
_TIFFDataSize(fip->field_type)
* value_count);
tmp = raw_data;
mem_alloc = 1;
if(TIFFGetField(tif, tag, tmp,
tmp + _TIFFDataSize(fip->field_type)) != 1) {
_TIFFfree(raw_data);
continue;
}
}
}
/*
* Catch the tags which needs to be specially handled and
* pretty print them. If tag not handled in
* _TIFFPrettyPrintField() fall down and print it as any other
* tag.
*/
if (_TIFFPrettyPrintField(tif, fd, tag, value_count, raw_data)) {
if(mem_alloc)
_TIFFfree(raw_data);
continue;
}
else
_TIFFPrintField(fd, fip, value_count, raw_data);
if(mem_alloc)
_TIFFfree(raw_data);
}
}
if (tif->tif_tagmethods.printdir)
(*tif->tif_tagmethods.printdir)(tif, fd, flags);
if ((flags & TIFFPRINT_STRIPS) &&
TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) {
tstrip_t s;
fprintf(fd, " %lu %s:\n",
(long) td->td_nstrips,
isTiled(tif) ? "Tiles" : "Strips");
for (s = 0; s < td->td_nstrips; s++)
fprintf(fd, " %3lu: [%8lu, %8lu]\n",
(unsigned long) s,
(unsigned long) td->td_stripoffset[s],
(unsigned long) td->td_stripbytecount[s]);
}
}
/*
* Print the contents of the current directory
* to the specified stdio file stream.
*/
void
TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
{
register TIFFDirectory *td;
char *sep;
uint16 i;
long l, n;
fprintf(fd, "TIFF Directory at offset 0x%lx\n",
(unsigned long)tif->tif_diroff);
td = &tif->tif_dir;
if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) {
fprintf(fd, " Subfile Type:");
sep = " ";
if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) {
fprintf(fd, "%sreduced-resolution image", sep);
sep = "/";
}
if (td->td_subfiletype & FILETYPE_PAGE) {
fprintf(fd, "%smulti-page document", sep);
sep = "/";
}
if (td->td_subfiletype & FILETYPE_MASK)
fprintf(fd, "%stransparency mask", sep);
fprintf(fd, " (%lu = 0x%lx)\n",
(long) td->td_subfiletype, (long) td->td_subfiletype);
}
if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) {
fprintf(fd, " Image Width: %lu Image Length: %lu",
(unsigned long) td->td_imagewidth, (unsigned long) td->td_imagelength);
if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH))
fprintf(fd, " Image Depth: %lu",
(unsigned long) td->td_imagedepth);
fprintf(fd, "\n");
}
/* Begin Pixar */
if (TIFFFieldSet(tif,FIELD_IMAGEFULLWIDTH) ||
TIFFFieldSet(tif,FIELD_IMAGEFULLLENGTH)) {
fprintf(fd, " Pixar Full Image Width: %lu Full Image Length: %lu\n",
(unsigned long) td->td_imagefullwidth,
(unsigned long) td->td_imagefulllength);
}
if (TIFFFieldSet(tif,FIELD_FOVCOT))
fprintf(fd, " Field of View Cotangent: %g\n", td->td_fovcot);
if (TIFFFieldSet(tif,FIELD_MATRIX_WORLDTOSCREEN)) {
typedef float Matrix[4][4];
Matrix* m = (Matrix*)td->td_matrixWorldToScreen;
fprintf(fd, " Matrix NP:\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n",
(*m)[0][0], (*m)[0][1], (*m)[0][2], (*m)[0][3],
(*m)[1][0], (*m)[1][1], (*m)[1][2], (*m)[1][3],
(*m)[2][0], (*m)[2][1], (*m)[2][2], (*m)[2][3],
(*m)[3][0], (*m)[3][1], (*m)[3][2], (*m)[3][3]);
}
if (TIFFFieldSet(tif,FIELD_MATRIX_WORLDTOCAMERA)) {
typedef float Matrix[4][4];
Matrix* m = (Matrix*)td->td_matrixWorldToCamera;
fprintf(fd, " Matrix Nl:\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n\t%g %g %g %g\n",
(*m)[0][0], (*m)[0][1], (*m)[0][2], (*m)[0][3],
(*m)[1][0], (*m)[1][1], (*m)[1][2], (*m)[1][3],
(*m)[2][0], (*m)[2][1], (*m)[2][2], (*m)[2][3],
(*m)[3][0], (*m)[3][1], (*m)[3][2], (*m)[3][3]);
}
/* End Pixar */
if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) {
fprintf(fd, " Tile Width: %lu Tile Length: %lu",
(unsigned long) td->td_tilewidth, (unsigned long) td->td_tilelength);
if (TIFFFieldSet(tif,FIELD_TILEDEPTH))
fprintf(fd, " Tile Depth: %lu",
(unsigned long) td->td_tiledepth);
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif,FIELD_RESOLUTION)) {
fprintf(fd, " Resolution: %g, %g",
td->td_xresolution, td->td_yresolution);
if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) {
switch (td->td_resolutionunit) {
case RESUNIT_NONE:
fprintf(fd, " (unitless)");
break;
case RESUNIT_INCH:
fprintf(fd, " pixels/inch");
break;
case RESUNIT_CENTIMETER:
fprintf(fd, " pixels/cm");
break;
default:
fprintf(fd, " (unit %u = 0x%x)",
td->td_resolutionunit,
td->td_resolutionunit);
break;
}
}
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif,FIELD_POSITION))
fprintf(fd, " Position: %g, %g\n",
td->td_xposition, td->td_yposition);
if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
fprintf(fd, " Bits/Sample: %u\n", td->td_bitspersample);
if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) {
fprintf(fd, " Sample Format: ");
switch (td->td_sampleformat) {
case SAMPLEFORMAT_VOID:
fprintf(fd, "void\n");
break;
case SAMPLEFORMAT_INT:
fprintf(fd, "signed integer\n");
break;
case SAMPLEFORMAT_UINT:
fprintf(fd, "unsigned integer\n");
break;
case SAMPLEFORMAT_IEEEFP:
fprintf(fd, "IEEE floating point\n");
break;
case SAMPLEFORMAT_COMPLEXINT:
fprintf(fd, "complex signed integer\n");
break;
case SAMPLEFORMAT_COMPLEXIEEEFP:
fprintf(fd, "complex IEEE floating point\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_sampleformat, td->td_sampleformat);
break;
}
}
if (TIFFFieldSet(tif,FIELD_COMPRESSION)) {
const TIFFCodec* c = TIFFFindCODEC(td->td_compression);
fprintf(fd, " Compression Scheme: ");
if (c)
fprintf(fd, "%s\n", c->name);
else
fprintf(fd, "%u (0x%x)\n",
td->td_compression, td->td_compression);
}
if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) {
fprintf(fd, " Photometric Interpretation: ");
if (td->td_photometric < NPHOTONAMES)
fprintf(fd, "%s\n", photoNames[td->td_photometric]);
else {
switch (td->td_photometric) {
case PHOTOMETRIC_LOGL:
fprintf(fd, "CIE Log2(L)\n");
break;
case PHOTOMETRIC_LOGLUV:
fprintf(fd, "CIE Log2(L) (u',v')\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_photometric, td->td_photometric);
break;
}
}
}
if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES) && td->td_extrasamples) {
fprintf(fd, " Extra Samples: %u<", td->td_extrasamples);
sep = "";
for (i = 0; i < td->td_extrasamples; i++) {
switch (td->td_sampleinfo[i]) {
case EXTRASAMPLE_UNSPECIFIED:
fprintf(fd, "%sunspecified", sep);
break;
case EXTRASAMPLE_ASSOCALPHA:
fprintf(fd, "%sassoc-alpha", sep);
break;
case EXTRASAMPLE_UNASSALPHA:
fprintf(fd, "%sunassoc-alpha", sep);
break;
default:
fprintf(fd, "%s%u (0x%x)", sep,
td->td_sampleinfo[i], td->td_sampleinfo[i]);
break;
}
sep = ", ";
}
fprintf(fd, ">\n");
}
if (TIFFFieldSet(tif,FIELD_STONITS)) {
fprintf(fd, " Sample to Nits conversion factor: %.4e\n",
td->td_stonits);
}
if (TIFFFieldSet(tif,FIELD_INKSET)) {
fprintf(fd, " Ink Set: ");
switch (td->td_inkset) {
case INKSET_CMYK:
fprintf(fd, "CMYK\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_inkset, td->td_inkset);
break;
}
}
if (TIFFFieldSet(tif,FIELD_INKNAMES)) {
char* cp;
fprintf(fd, " Ink Names: ");
i = td->td_samplesperpixel;
sep = "";
for (cp = td->td_inknames; i > 0; cp = strchr(cp,'\0')+1, i--) {
fputs(sep, fd);
_TIFFprintAscii(fd, cp);
sep = ", ";
}
fputs("\n", fd);
}
if (TIFFFieldSet(tif,FIELD_NUMBEROFINKS))
fprintf(fd, " Number of Inks: %u\n", td->td_ninks);
if (TIFFFieldSet(tif,FIELD_DOTRANGE))
fprintf(fd, " Dot Range: %u-%u\n",
td->td_dotrange[0], td->td_dotrange[1]);
if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) {
fprintf(fd, " Thresholding: ");
switch (td->td_threshholding) {
case THRESHHOLD_BILEVEL:
fprintf(fd, "bilevel art scan\n");
break;
case THRESHHOLD_HALFTONE:
fprintf(fd, "halftone or dithered scan\n");
break;
case THRESHHOLD_ERRORDIFFUSE:
fprintf(fd, "error diffused\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_threshholding, td->td_threshholding);
break;
}
}
if (TIFFFieldSet(tif,FIELD_FILLORDER)) {
fprintf(fd, " FillOrder: ");
switch (td->td_fillorder) {
case FILLORDER_MSB2LSB:
fprintf(fd, "msb-to-lsb\n");
break;
case FILLORDER_LSB2MSB:
fprintf(fd, "lsb-to-msb\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_fillorder, td->td_fillorder);
break;
}
}
if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))
{
/*
* For hacky reasons (see tif_jpeg.c - JPEGFixupTestSubsampling),
* we need to fetch this rather than trust what is in our
* structures.
*/
uint16 subsampling[2];
TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
subsampling + 0, subsampling + 1 );
fprintf(fd, " YCbCr Subsampling: %u, %u\n",
subsampling[0], subsampling[1] );
}
if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) {
fprintf(fd, " YCbCr Positioning: ");
switch (td->td_ycbcrpositioning) {
case YCBCRPOSITION_CENTERED:
fprintf(fd, "centered\n");
break;
case YCBCRPOSITION_COSITED:
fprintf(fd, "cosited\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_ycbcrpositioning, td->td_ycbcrpositioning);
break;
}
}
if (TIFFFieldSet(tif,FIELD_YCBCRCOEFFICIENTS))
fprintf(fd, " YCbCr Coefficients: %g, %g, %g\n",
td->td_ycbcrcoeffs[0],
td->td_ycbcrcoeffs[1],
td->td_ycbcrcoeffs[2]);
if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS))
fprintf(fd, " Halftone Hints: light %u dark %u\n",
td->td_halftonehints[0], td->td_halftonehints[1]);
if (TIFFFieldSet(tif,FIELD_ORIENTATION)) {
fprintf(fd, " Orientation: ");
if (td->td_orientation < NORIENTNAMES)
fprintf(fd, "%s\n", orientNames[td->td_orientation]);
else
fprintf(fd, "%u (0x%x)\n",
td->td_orientation, td->td_orientation);
}
if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
fprintf(fd, " Samples/Pixel: %u\n", td->td_samplesperpixel);
if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) {
fprintf(fd, " Rows/Strip: ");
if (td->td_rowsperstrip == (uint32) -1)
fprintf(fd, "(infinite)\n");
else
fprintf(fd, "%lu\n", (unsigned long) td->td_rowsperstrip);
}
if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE))
fprintf(fd, " Min Sample Value: %u\n", td->td_minsamplevalue);
if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))
fprintf(fd, " Max Sample Value: %u\n", td->td_maxsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE))
fprintf(fd, " SMin Sample Value: %g\n",
td->td_sminsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE))
fprintf(fd, " SMax Sample Value: %g\n",
td->td_smaxsamplevalue);
if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) {
fprintf(fd, " Planar Configuration: ");
switch (td->td_planarconfig) {
case PLANARCONFIG_CONTIG:
fprintf(fd, "single image plane\n");
break;
case PLANARCONFIG_SEPARATE:
fprintf(fd, "separate image planes\n");
break;
default:
fprintf(fd, "%u (0x%x)\n",
td->td_planarconfig, td->td_planarconfig);
break;
}
}
if (TIFFFieldSet(tif,FIELD_PAGENUMBER))
fprintf(fd, " Page Number: %u-%u\n",
td->td_pagenumber[0], td->td_pagenumber[1]);
if (TIFFFieldSet(tif,FIELD_COLORMAP)) {
fprintf(fd, " Color Map: ");
if (flags & TIFFPRINT_COLORMAP) {
fprintf(fd, "\n");
n = 1L<<td->td_bitspersample;
for (l = 0; l < n; l++)
fprintf(fd, " %5lu: %5u %5u %5u\n",
l,
td->td_colormap[0][l],
td->td_colormap[1][l],
td->td_colormap[2][l]);
} else
fprintf(fd, "(present)\n");
}
if (TIFFFieldSet(tif,FIELD_WHITEPOINT))
fprintf(fd, " White Point: %g-%g\n",
td->td_whitepoint[0], td->td_whitepoint[1]);
if (TIFFFieldSet(tif,FIELD_PRIMARYCHROMAS))
fprintf(fd, " Primary Chromaticities: %g,%g %g,%g %g,%g\n",
td->td_primarychromas[0], td->td_primarychromas[1],
td->td_primarychromas[2], td->td_primarychromas[3],
td->td_primarychromas[4], td->td_primarychromas[5]);
if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) {
fprintf(fd, " Reference Black/White:\n");
for (i = 0; i < td->td_samplesperpixel; i++)
fprintf(fd, " %2d: %5g %5g\n",
i,
td->td_refblackwhite[2*i+0],
td->td_refblackwhite[2*i+1]);
}
if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) {
fprintf(fd, " Transfer Function: ");
if (flags & TIFFPRINT_CURVES) {
fprintf(fd, "\n");
n = 1L<<td->td_bitspersample;
for (l = 0; l < n; l++) {
fprintf(fd, " %2lu: %5u",
l, td->td_transferfunction[0][l]);
for (i = 1; i < td->td_samplesperpixel; i++)
fprintf(fd, " %5u",
td->td_transferfunction[i][l]);
fputc('\n', fd);
}
} else
fprintf(fd, "(present)\n");
}
if (TIFFFieldSet(tif,FIELD_ICCPROFILE))
fprintf(fd, " ICC Profile: <present>, %lu bytes\n",
(unsigned long) td->td_profileLength);
if (TIFFFieldSet(tif,FIELD_PHOTOSHOP))
fprintf(fd, " Photoshop Data: <present>, %lu bytes\n",
(unsigned long) td->td_photoshopLength);
if (TIFFFieldSet(tif,FIELD_RICHTIFFIPTC))
fprintf(fd, " RichTIFFIPTC Data: <present>, %lu bytes\n",
(unsigned long) td->td_richtiffiptcLength);
if (TIFFFieldSet(tif, FIELD_SUBIFD)) {
fprintf(fd, " SubIFD Offsets:");
for (i = 0; i < td->td_nsubifd; i++)
fprintf(fd, " %5lu", (long) td->td_subifd[i]);
fputc('\n', fd);
}
if (TIFFFieldSet(tif,FIELD_XMLPACKET)) {
fprintf(fd, " XMLPacket (XMP Metadata):\n" );
for( i=0; i < td->td_xmlpacketLength; i++ )
fputc( ((char *)td->td_xmlpacketData)[i], fd );
fprintf( fd, "\n" );
}
/*
** Custom tag support.
*/
{
int i;
short count;
count = (short) TIFFGetTagListCount(tif);
for(i = 0; i < count; i++) {
ttag_t tag = TIFFGetTagListEntry(tif, i);
const TIFFFieldInfo *fip;
uint16 value_count;
int j, mem_alloc = 0;
void *raw_data;
fip = TIFFFieldWithTag(tif, tag);
if(fip == NULL)
continue;
if(fip->field_passcount) {
if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1)
continue;
} else {
if (fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2)
value_count = 1;
else if (fip->field_readcount == TIFF_SPP)
value_count = td->td_samplesperpixel;
else
value_count = fip->field_readcount;
if (fip->field_type == TIFF_ASCII
|| fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2
|| fip->field_readcount == TIFF_SPP
|| value_count > 1) {
if(TIFFGetField(tif, tag, &raw_data) != 1)
continue;
} else {
raw_data = _TIFFmalloc(
_TIFFDataSize(fip->field_type)
* value_count);
mem_alloc = 1;
if(TIFFGetField(tif, tag, raw_data) != 1)
continue;
}
}
fprintf(fd, " %s: ", fip->field_name);
for(j = 0; j < value_count; j++) {
if(fip->field_type == TIFF_BYTE)
fprintf(fd, "%u",
(unsigned int) ((uint16 *) raw_data)[j]);
else if(fip->field_type == TIFF_UNDEFINED)
fprintf(fd, "0x%x",
(unsigned int) ((unsigned char *) raw_data)[j]); else if(fip->field_type == TIFF_SBYTE)
fprintf(fd, "%d", (int) ((uint16 *) raw_data)[j]);
else if(fip->field_type == TIFF_SHORT)
fprintf(fd, "%u",
(unsigned int)((unsigned short *) raw_data)[j]);
else if(fip->field_type == TIFF_SSHORT)
fprintf(fd, "%d", (int)((short *) raw_data)[j]);
else if(fip->field_type == TIFF_LONG)
fprintf(fd, "%lu",
(unsigned long)((unsigned long *) raw_data)[j]);
else if(fip->field_type == TIFF_SLONG)
fprintf(fd, "%ld", (long)((long *) raw_data)[j]);
else if(fip->field_type == TIFF_RATIONAL
|| fip->field_type == TIFF_SRATIONAL
|| fip->field_type == TIFF_FLOAT)
fprintf(fd, "%f", ((float *) raw_data)[j]);
else if(fip->field_type == TIFF_IFD)
fprintf(fd, "0x%x",
(int)((unsigned long *) raw_data)[j]);
else if(fip->field_type == TIFF_ASCII) {
fprintf(fd, "%s", (char *) raw_data);
break;
}
else if(fip->field_type == TIFF_DOUBLE)
fprintf(fd, "%f", ((double *) raw_data)[j]);
else if(fip->field_type == TIFF_FLOAT)
fprintf(fd, "%f", ((float *)raw_data)[j]);
else {
fprintf(fd, "<unsupported data type in TIFFPrint>");
break;
}
if(j < value_count - 1)
fprintf(fd, ",");
}
fprintf(fd, "\n");
if(mem_alloc)
_TIFFfree(raw_data);
}
}
if (tif->tif_tagmethods.printdir)
(*tif->tif_tagmethods.printdir)(tif, fd, flags);
if ((flags & TIFFPRINT_STRIPS) &&
TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) {
tstrip_t s;
fprintf(fd, " %lu %s:\n",
(long) td->td_nstrips,
isTiled(tif) ? "Tiles" : "Strips");
for (s = 0; s < td->td_nstrips; s++)
fprintf(fd, " %3lu: [%8lu, %8lu]\n",
(unsigned long) s,
(unsigned long) td->td_stripoffset[s],
(unsigned long) td->td_stripbytecount[s]);
}
}
/**
Read a single exif tag
*/
static BOOL
tiff_read_exif_tag(TIFF *tif, TagLib::MDMODEL md_model, FIBITMAP *dib, TagLib& tagLib, TIFFDirectory *td, uint32 tag) {
const TIFFField *fip;
uint32 value_count;
int mem_alloc = 0;
void *raw_data = NULL;
if(tag == TIFFTAG_EXIFIFD) {
return TRUE;
}
// get the tag key - use NULL to avoid reading GeoTIFF tags
const char *key = tagLib.getTagFieldName(md_model, (WORD)tag, NULL);
if(key == NULL) {
return TRUE;
}
fip = TIFFFieldWithTag(tif, tag);
if(fip == NULL) {
return TRUE;
}
if(fip->field_passcount) { //<- "passcount" means "returns count"
if (fip->field_readcount != TIFF_VARIABLE2) { //<- TIFF_VARIABLE2 means "uses LONG count"
// assume TIFF_VARIABLE (uses SHORT count)
uint16 value_count16;
if(TIFFGetField(tif, tag, &value_count16, &raw_data) != 1) {
return TRUE;
}
value_count = value_count16;
} else {
if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1) {
return TRUE;
}
}
} else {
// determine count
if (fip->field_readcount == TIFF_VARIABLE || fip->field_readcount == TIFF_VARIABLE2) {
value_count = 1;
} else if (fip->field_readcount == TIFF_SPP) {
value_count = td->td_samplesperpixel;
} else {
value_count = fip->field_readcount;
}
// access fields as pointers to data
// (### determining this is NOT robust... and hardly can be. It is implemented looking the _TIFFVGetField code)
if(fip->field_tag == TIFFTAG_TRANSFERFUNCTION) {
// reading this tag cause a bug probably located somewhere inside libtiff
return TRUE;
}
if ((fip->field_type == TIFF_ASCII
|| fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2
|| fip->field_readcount == TIFF_SPP
|| value_count > 1)
&& fip->field_tag != TIFFTAG_PAGENUMBER
&& fip->field_tag != TIFFTAG_HALFTONEHINTS
&& fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
&& fip->field_tag != TIFFTAG_DOTRANGE
&& fip->field_tag != TIFFTAG_BITSPERSAMPLE //<- these two are tricky -
&& fip->field_tag != TIFFTAG_COMPRESSION //<- they are defined as TIFF_VARIABLE but in reality return a single value
) {
if(TIFFGetField(tif, tag, &raw_data) != 1) {
return TRUE;
}
} else {
// access fields as values
const int value_size = _TIFFDataSize(fip->field_type);
raw_data = _TIFFmalloc(value_size * value_count);
mem_alloc = 1;
int ok = FALSE;
// ### if value_count > 1, tag is PAGENUMBER or HALFTONEHINTS or YCBCRSUBSAMPLING or DOTRANGE,
// all off which are value_count == 2 (see tif_dirinfo.c)
switch(value_count)
{
case 1:
ok = TIFFGetField(tif, tag, raw_data);
break;
case 2:
ok = TIFFGetField(tif, tag, raw_data, (BYTE*)(raw_data) + value_size*1);
break;
/* # we might need more in the future:
case 3:
ok = TIFFGetField(tif, tag, raw_data, (BYTE*)(raw_data) + value_size*1, (BYTE*)(raw_data) + value_size*2);
break;
*/
default:
FreeImage_OutputMessageProc(FIF_TIFF, "Unimplemented variable number of parameters for Tiff Tag %s", fip->field_name);
break;
}
if(ok != 1) {
_TIFFfree(raw_data);
return TRUE;
}
}
}
// build FreeImage tag from Tiff Tag data we collected
FITAG *fitag = FreeImage_CreateTag();
if(!fitag) {
if(mem_alloc) {
_TIFFfree(raw_data);
}
return FALSE;
}
FreeImage_SetTagID(fitag, (WORD)tag);
FreeImage_SetTagKey(fitag, key);
switch(fip->field_type) {
case TIFF_BYTE:
FreeImage_SetTagType(fitag, FIDT_BYTE);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_UNDEFINED:
FreeImage_SetTagType(fitag, FIDT_UNDEFINED);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SBYTE:
FreeImage_SetTagType(fitag, FIDT_SBYTE);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SHORT:
FreeImage_SetTagType(fitag, FIDT_SHORT);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SSHORT:
FreeImage_SetTagType(fitag, FIDT_SSHORT);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_LONG:
FreeImage_SetTagType(fitag, FIDT_LONG);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_IFD:
FreeImage_SetTagType(fitag, FIDT_IFD);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SLONG:
FreeImage_SetTagType(fitag, FIDT_SLONG);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_RATIONAL: {
// LibTIFF converts rational to floats : reconvert floats to rationals
DWORD *rvalue = (DWORD*)malloc(2 * value_count * sizeof(DWORD));
for(uint32 i = 0; i < value_count; i++) {
float *fv = (float*)raw_data;
FIRational rational(fv[i]);
rvalue[2*i] = rational.getNumerator();
rvalue[2*i+1] = rational.getDenominator();
}
FreeImage_SetTagType(fitag, FIDT_RATIONAL);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, rvalue);
free(rvalue);
}
break;
case TIFF_SRATIONAL: {
// LibTIFF converts rational to floats : reconvert floats to rationals
LONG *rvalue = (LONG*)malloc(2 * value_count * sizeof(LONG));
for(uint32 i = 0; i < value_count; i++) {
float *fv = (float*)raw_data;
FIRational rational(fv[i]);
rvalue[2*i] = rational.getNumerator();
rvalue[2*i+1] = rational.getDenominator();
}
FreeImage_SetTagType(fitag, FIDT_RATIONAL);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, rvalue);
free(rvalue);
}
break;
case TIFF_FLOAT:
FreeImage_SetTagType(fitag, FIDT_FLOAT);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_DOUBLE:
FreeImage_SetTagType(fitag, FIDT_DOUBLE);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_LONG8: // BigTIFF 64-bit unsigned integer
FreeImage_SetTagType(fitag, FIDT_LONG8);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_IFD8: // BigTIFF 64-bit unsigned integer (offset)
FreeImage_SetTagType(fitag, FIDT_IFD8);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SLONG8: // BigTIFF 64-bit signed integer
FreeImage_SetTagType(fitag, FIDT_SLONG8);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
default: {
size_t length = strlen((char*)raw_data) + 1;
FreeImage_SetTagType(fitag, FIDT_ASCII);
FreeImage_SetTagLength(fitag, (DWORD)length);
FreeImage_SetTagCount(fitag, (DWORD)length);
FreeImage_SetTagValue(fitag, raw_data);
}
break;
}
const char *description = tagLib.getTagDescription(md_model, (WORD)tag);
if(description) {
FreeImage_SetTagDescription(fitag, description);
}
// store the tag
FreeImage_SetMetadata(tagLib.getFreeImageModel(md_model), dib, FreeImage_GetTagKey(fitag), fitag);
// destroy the tag
FreeImage_DeleteTag(fitag);
if(mem_alloc) {
_TIFFfree(raw_data);
}
return TRUE;
}
BOOL tiff_read_exif_tags(TIFF *tif, TagLib::MDMODEL md_model, FIBITMAP *dib) {
int i;
short count;
TagLib& tagLib = TagLib::instance();
TIFFDirectory *td = &tif->tif_dir;
count = (short) TIFFGetTagListCount(tif);
for(i = 0; i < count; i++) {
ttag_t tag = TIFFGetTagListEntry(tif, i);
const TIFFFieldInfo *fip;
uint32 value_count;
int mem_alloc = 0;
void *raw_data;
if(tag == TIFFTAG_EXIFIFD) continue;
// get the tag key - use NULL to avoid reading GeoTIFF tags
const char *key = tagLib.getTagFieldName(md_model, (WORD)tag, NULL);
if(key == NULL) continue;
fip = TIFFFieldWithTag(tif, tag);
if(fip == NULL) continue;
if(fip->field_passcount) {
if (fip->field_readcount != TIFF_VARIABLE2) {
// assume TIFF_VARIABLE
uint16 value_count16;
if(TIFFGetField(tif, tag, &value_count16, &raw_data) != 1) continue;
value_count = value_count16;
} else {
if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1) continue;
}
} else {
if (fip->field_readcount == TIFF_VARIABLE || fip->field_readcount == TIFF_VARIABLE2) {
value_count = 1;
} else if (fip->field_readcount == TIFF_SPP) {
value_count = td->td_samplesperpixel;
} else {
value_count = fip->field_readcount;
}
if (fip->field_type == TIFF_ASCII
|| fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2
|| fip->field_readcount == TIFF_SPP
|| value_count > 1) {
if(TIFFGetField(tif, tag, &raw_data) != 1) continue;
} else {
raw_data = _TIFFmalloc(_TIFFDataSize(fip->field_type) * value_count);
mem_alloc = 1;
if(TIFFGetField(tif, tag, raw_data) != 1) {
_TIFFfree(raw_data);
continue;
}
}
}
// create a tag
FITAG *fitag = FreeImage_CreateTag();
if(!fitag) {
if(mem_alloc)
_TIFFfree(raw_data);
return FALSE;
}
FreeImage_SetTagID(fitag, (WORD)tag);
FreeImage_SetTagKey(fitag, key);
switch(fip->field_type) {
case TIFF_BYTE:
FreeImage_SetTagType(fitag, FIDT_BYTE);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_UNDEFINED:
FreeImage_SetTagType(fitag, FIDT_UNDEFINED);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SBYTE:
FreeImage_SetTagType(fitag, FIDT_SBYTE);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SHORT:
FreeImage_SetTagType(fitag, FIDT_SHORT);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SSHORT:
FreeImage_SetTagType(fitag, FIDT_SSHORT);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_LONG:
FreeImage_SetTagType(fitag, FIDT_LONG);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_IFD:
FreeImage_SetTagType(fitag, FIDT_IFD);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SLONG:
FreeImage_SetTagType(fitag, FIDT_SLONG);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_RATIONAL:
{
// LibTIFF converts rational to floats : reconvert floats to rationals
DWORD *rvalue = (DWORD*)malloc(2 * value_count * sizeof(DWORD));
for(uint32 i = 0; i < value_count; i++) {
float *fv = (float*)raw_data;
FIRational rational(fv[i]);
rvalue[2*i] = rational.getNumerator();
rvalue[2*i+1] = rational.getDenominator();
}
FreeImage_SetTagType(fitag, FIDT_RATIONAL);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, rvalue);
free(rvalue);
}
break;
case TIFF_SRATIONAL:
{
// LibTIFF converts rational to floats : reconvert floats to rationals
LONG *rvalue = (LONG*)malloc(2 * value_count * sizeof(LONG));
for(uint32 i = 0; i < value_count; i++) {
float *fv = (float*)raw_data;
FIRational rational(fv[i]);
rvalue[2*i] = rational.getNumerator();
rvalue[2*i+1] = rational.getDenominator();
}
FreeImage_SetTagType(fitag, FIDT_RATIONAL);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, rvalue);
free(rvalue);
}
break;
case TIFF_FLOAT:
FreeImage_SetTagType(fitag, FIDT_FLOAT);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_DOUBLE:
FreeImage_SetTagType(fitag, FIDT_DOUBLE);
FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
default:
{
size_t length = strlen((char*)raw_data) + 1;
FreeImage_SetTagType(fitag, FIDT_ASCII);
FreeImage_SetTagLength(fitag, (DWORD)length);
FreeImage_SetTagCount(fitag, (DWORD)length);
FreeImage_SetTagValue(fitag, raw_data);
}
break;
}
const char *description = tagLib.getTagDescription(md_model, (WORD)tag);
if(description) {
FreeImage_SetTagDescription(fitag, description);
}
// store the tag
FreeImage_SetMetadata(tagLib.getFreeImageModel(md_model), dib, FreeImage_GetTagKey(fitag), fitag);
// destroy the tag
FreeImage_DeleteTag(fitag);
if(mem_alloc)
_TIFFfree(raw_data);
}
return TRUE;
}
/**
Read a single Exif tag
@param tif TIFF handle
@param tag_id TIFF Tag ID
@param dib Image being read
@param md_model Metadata model where to store the tag
@return Returns TRUE if successful, returns FALSE otherwise
*/
static BOOL
tiff_read_exif_tag(TIFF *tif, uint32 tag_id, FIBITMAP *dib, TagLib::MDMODEL md_model) {
uint32 value_count = 0;
int mem_alloc = 0;
void *raw_data = NULL;
if(tag_id == TIFFTAG_EXIFIFD) {
// Exif IFD offset - skip this tag
// md_model should be EXIF_MAIN, the Exif IFD is processed later using the EXIF_EXIF metadata model
return TRUE;
}
if((tag_id == TIFFTAG_GPSIFD) && (md_model == TagLib::EXIF_MAIN)) {
// Exif GPS IFD offset - skip this tag
// should be processed in another way ...
return TRUE;
}
TagLib& tagLib = TagLib::instance();
// get the tag key - use NULL to avoid reading GeoTIFF tags
const char *key = tagLib.getTagFieldName(md_model, (WORD)tag_id, NULL);
if(key == NULL) {
return TRUE;
}
const TIFFField *fip = TIFFFieldWithTag(tif, tag_id);
if(fip == NULL) {
return TRUE;
}
if(TIFFFieldPassCount(fip)) {
// a count value is required for 'TIFFGetField'
if (TIFFFieldReadCount(fip) != TIFF_VARIABLE2) {
// a count is required, it will be of type uint16
uint16 value_count16 = 0;
if(TIFFGetField(tif, tag_id, &value_count16, &raw_data) != 1) {
// stop, ignore error
return TRUE;
}
value_count = value_count16;
} else {
// a count is required, it will be of type uint32
uint32 value_count32 = 0;
if(TIFFGetField(tif, tag_id, &value_count32, &raw_data) != 1) {
// stop, ignore error
return TRUE;
}
value_count = value_count32;
}
} else {
// determine count
if (TIFFFieldReadCount(fip) == TIFF_VARIABLE || TIFFFieldReadCount(fip) == TIFF_VARIABLE2) {
value_count = 1;
} else if (TIFFFieldReadCount(fip) == TIFF_SPP) {
uint16 spp;
TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &spp);
value_count = spp;
} else {
value_count = TIFFFieldReadCount(fip);
}
// access fields as pointers to data
// (### determining this is NOT robust... and hardly can be. It is implemented looking the _TIFFVGetField code)
if(TIFFFieldTag(fip) == TIFFTAG_TRANSFERFUNCTION) {
// reading this tag cause a bug probably located somewhere inside libtiff
return TRUE;
}
if ((TIFFFieldDataType(fip) == TIFF_ASCII
|| TIFFFieldReadCount(fip) == TIFF_VARIABLE
|| TIFFFieldReadCount(fip) == TIFF_VARIABLE2
|| TIFFFieldReadCount(fip) == TIFF_SPP
|| value_count > 1)
&& TIFFFieldTag(fip) != TIFFTAG_PAGENUMBER
&& TIFFFieldTag(fip) != TIFFTAG_HALFTONEHINTS
&& TIFFFieldTag(fip) != TIFFTAG_YCBCRSUBSAMPLING
&& TIFFFieldTag(fip) != TIFFTAG_DOTRANGE
&& TIFFFieldTag(fip) != TIFFTAG_BITSPERSAMPLE //<- these two are tricky -
&& TIFFFieldTag(fip) != TIFFTAG_COMPRESSION //<- they are defined as TIFF_VARIABLE but in reality return a single value
) {
if(TIFFGetField(tif, tag_id, &raw_data) != 1) {
// stop, ignore error
return TRUE;
}
} else {
int value_size = 0;
// access fields as values
// Note:
// For TIFF_RATIONAL values, TIFFDataWidth() returns 8, but LibTIFF use internaly 4-byte float to represent rationals.
{
TIFFDataType tag_type = TIFFFieldDataType(fip);
switch(tag_type) {
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
value_size = 4;
break;
default:
value_size = TIFFDataWidth(tag_type);
break;
}
}
raw_data = _TIFFmalloc(value_size * value_count);
mem_alloc = 1;
int ok = FALSE;
// ### if value_count > 1, tag is PAGENUMBER or HALFTONEHINTS or YCBCRSUBSAMPLING or DOTRANGE,
// all off which are value_count == 2 (see tif_dirinfo.c)
switch(value_count)
{
case 1:
ok = TIFFGetField(tif, tag_id, raw_data);
break;
case 2:
ok = TIFFGetField(tif, tag_id, raw_data, (BYTE*)(raw_data) + value_size*1);
break;
/* # we might need more in the future:
case 3:
ok = TIFFGetField(tif, tag_id, raw_data, (BYTE*)(raw_data) + value_size*1, (BYTE*)(raw_data) + value_size*2);
break;
*/
default:
FreeImage_OutputMessageProc(FIF_TIFF, "Unimplemented variable number of parameters for Tiff Tag %s", TIFFFieldName(fip));
break;
}
if(ok != 1) {
_TIFFfree(raw_data);
return TRUE;
}
}
}
// build FreeImage tag from Tiff Tag data we collected
FITAG *fitag = FreeImage_CreateTag();
if(!fitag) {
if(mem_alloc) {
_TIFFfree(raw_data);
}
return FALSE;
}
FreeImage_SetTagID(fitag, (WORD)tag_id);
FreeImage_SetTagKey(fitag, key);
switch(TIFFFieldDataType(fip)) {
case TIFF_BYTE:
FreeImage_SetTagType(fitag, FIDT_BYTE);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_UNDEFINED:
FreeImage_SetTagType(fitag, FIDT_UNDEFINED);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SBYTE:
FreeImage_SetTagType(fitag, FIDT_SBYTE);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SHORT:
FreeImage_SetTagType(fitag, FIDT_SHORT);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SSHORT:
FreeImage_SetTagType(fitag, FIDT_SSHORT);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_LONG:
FreeImage_SetTagType(fitag, FIDT_LONG);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_IFD:
FreeImage_SetTagType(fitag, FIDT_IFD);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SLONG:
FreeImage_SetTagType(fitag, FIDT_SLONG);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_RATIONAL: {
// LibTIFF converts rational to floats : reconvert floats to rationals
DWORD *rvalue = (DWORD*)malloc(2 * value_count * sizeof(DWORD));
for(uint32 i = 0; i < value_count; i++) {
float *fv = (float*)raw_data;
FIRational rational(fv[i]);
rvalue[2*i] = rational.getNumerator();
rvalue[2*i+1] = rational.getDenominator();
}
FreeImage_SetTagType(fitag, FIDT_RATIONAL);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, rvalue);
free(rvalue);
}
break;
case TIFF_SRATIONAL: {
// LibTIFF converts rational to floats : reconvert floats to rationals
LONG *rvalue = (LONG*)malloc(2 * value_count * sizeof(LONG));
for(uint32 i = 0; i < value_count; i++) {
float *fv = (float*)raw_data;
FIRational rational(fv[i]);
rvalue[2*i] = rational.getNumerator();
rvalue[2*i+1] = rational.getDenominator();
}
FreeImage_SetTagType(fitag, FIDT_RATIONAL);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, rvalue);
free(rvalue);
}
break;
case TIFF_FLOAT:
FreeImage_SetTagType(fitag, FIDT_FLOAT);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_DOUBLE:
FreeImage_SetTagType(fitag, FIDT_DOUBLE);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_LONG8: // BigTIFF 64-bit unsigned integer
FreeImage_SetTagType(fitag, FIDT_LONG8);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_IFD8: // BigTIFF 64-bit unsigned integer (offset)
FreeImage_SetTagType(fitag, FIDT_IFD8);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_SLONG8: // BigTIFF 64-bit signed integer
FreeImage_SetTagType(fitag, FIDT_SLONG8);
FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
FreeImage_SetTagCount(fitag, value_count);
FreeImage_SetTagValue(fitag, raw_data);
break;
case TIFF_ASCII:
default: {
size_t length = 0;
if(!mem_alloc && (TIFFFieldDataType(fip) == TIFF_ASCII) && (TIFFFieldReadCount(fip) == TIFF_VARIABLE)) {
// when metadata tag is of type ASCII and it's value is of variable size (TIFF_VARIABLE),
// tiff_read_exif_tag function gives length of 1 so all strings are truncated ...
// ... try to avoid this by using an explicit calculation for 'length'
length = strlen((char*)raw_data) + 1;
}
else {
// remember that raw_data = _TIFFmalloc(value_size * value_count);
const int value_size = TIFFDataWidth( TIFFFieldDataType(fip) );
length = value_size * value_count;
}
FreeImage_SetTagType(fitag, FIDT_ASCII);
FreeImage_SetTagLength(fitag, (DWORD)length);
FreeImage_SetTagCount(fitag, (DWORD)length);
FreeImage_SetTagValue(fitag, raw_data);
}
break;
}
const char *description = tagLib.getTagDescription(md_model, (WORD)tag_id);
if(description) {
FreeImage_SetTagDescription(fitag, description);
}
// store the tag
FreeImage_SetMetadata(tagLib.getFreeImageModel(md_model), dib, FreeImage_GetTagKey(fitag), fitag);
// destroy the tag
FreeImage_DeleteTag(fitag);
if(mem_alloc) {
_TIFFfree(raw_data);
}
return TRUE;
}
