1 // ==========================================================
2 // Metadata functions implementation
3 // Extended TIFF Directory GEO Tag Support
4 //
5 // Design and implementation by
6 // - Hervé Drolon (drolon@infonie.fr)
7 // - Thorsten Radde (support@IdealSoftware.com)
8 // - Berend Engelbrecht (softwarecave@users.sourceforge.net)
9 // - Mihail Naydenov (mnaydenov@users.sourceforge.net)
10 //
11 // Based on the LibTIFF xtiffio sample and on LibGeoTIFF
12 //
13 // This file is part of FreeImage 3
14 //
15 // COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
16 // OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
17 // THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
18 // OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
19 // CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
20 // THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
21 // SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
22 // PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
23 // THIS DISCLAIMER.
24 //
25 // Use at your own risk!
26 // ==========================================================
27
28 #ifdef _MSC_VER
29 #pragma warning (disable : 4786) // identifier was truncated to 'number' characters
30 #endif
31
32 #include "../LibTIFF4/tiffiop.h"
33
34 #include "FreeImage.h"
35 #include "Utilities.h"
36 #include "FreeImageTag.h"
37 #include "FIRational.h"
38
39 // ----------------------------------------------------------
40 // Extended TIFF Directory GEO Tag Support
41 // ----------------------------------------------------------
42
43 /**
44 Tiff info structure.
45 Entry format:
46 { TAGNUMBER, ReadCount, WriteCount, DataType, FIELDNUM, OkToChange, PassDirCountOnSet, AsciiName }
47
48 For ReadCount, WriteCount, -1 = unknown.
49 */
50 static const TIFFFieldInfo xtiffFieldInfo[] = {
51 { TIFFTAG_GEOPIXELSCALE, -1, -1, TIFF_DOUBLE, FIELD_CUSTOM, TRUE, TRUE, (char*)"GeoPixelScale" },
52 { TIFFTAG_INTERGRAPH_MATRIX, -1, -1, TIFF_DOUBLE, FIELD_CUSTOM, TRUE, TRUE, (char*)"Intergraph TransformationMatrix" },
53 { TIFFTAG_GEOTRANSMATRIX, -1, -1, TIFF_DOUBLE, FIELD_CUSTOM, TRUE, TRUE, (char*)"GeoTransformationMatrix" },
54 { TIFFTAG_GEOTIEPOINTS, -1, -1, TIFF_DOUBLE, FIELD_CUSTOM, TRUE, TRUE, (char*)"GeoTiePoints" },
55 { TIFFTAG_GEOKEYDIRECTORY,-1,-1, TIFF_SHORT, FIELD_CUSTOM, TRUE, TRUE, (char*)"GeoKeyDirectory" },
56 { TIFFTAG_GEODOUBLEPARAMS, -1, -1, TIFF_DOUBLE, FIELD_CUSTOM, TRUE, TRUE, (char*)"GeoDoubleParams" },
57 { TIFFTAG_GEOASCIIPARAMS, -1, -1, TIFF_ASCII, FIELD_CUSTOM, TRUE, FALSE, (char*) "GeoASCIIParams" },
58 { TIFFTAG_JPL_CARTO_IFD, 1, 1, TIFF_LONG, FIELD_CUSTOM, TRUE, TRUE, (char*)"JPL Carto IFD offset" } /** Don't use this! **/
59 };
60
61 static void
_XTIFFLocalDefaultDirectory(TIFF * tif)62 _XTIFFLocalDefaultDirectory(TIFF *tif) {
63 int tag_size = sizeof(xtiffFieldInfo) / sizeof(xtiffFieldInfo[0]);
64 // Install the extended Tag field info
65 TIFFMergeFieldInfo(tif, xtiffFieldInfo, tag_size);
66 }
67
68 static TIFFExtendProc _ParentExtender;
69
70 /**
71 This is the callback procedure, and is
72 called by the DefaultDirectory method
73 every time a new TIFF directory is opened.
74 */
75 static void
_XTIFFDefaultDirectory(TIFF * tif)76 _XTIFFDefaultDirectory(TIFF *tif) {
77 // set up our own defaults
78 _XTIFFLocalDefaultDirectory(tif);
79
80 /*
81 Since an XTIFF client module may have overridden
82 the default directory method, we call it now to
83 allow it to set up the rest of its own methods.
84 */
85 if (_ParentExtender) {
86 (*_ParentExtender)(tif);
87 }
88 }
89
90 /**
91 XTIFF Initializer -- sets up the callback procedure for the TIFF module.
92 @see PluginTIFF::InitTIFF
93 */
94 void
XTIFFInitialize(void)95 XTIFFInitialize(void) {
96 static int first_time = 1;
97
98 if (! first_time) {
99 return; /* Been there. Done that. */
100 }
101 first_time = 0;
102
103 // Grab the inherited method and install
104 _ParentExtender = TIFFSetTagExtender(_XTIFFDefaultDirectory);
105 }
106
107 // ----------------------------------------------------------
108 // GeoTIFF tag reading / writing
109 // ----------------------------------------------------------
110
111 BOOL
tiff_read_geotiff_profile(TIFF * tif,FIBITMAP * dib)112 tiff_read_geotiff_profile(TIFF *tif, FIBITMAP *dib) {
113 char defaultKey[16];
114
115 // first check for a mandatory tag
116 {
117 short tag_count = 0;
118 void* data = NULL;
119
120 if(!TIFFGetField(tif, TIFFTAG_GEOKEYDIRECTORY, &tag_count, &data)) {
121 // no GeoTIFF tag here
122 return TRUE;
123 }
124 }
125
126 // next, read GeoTIFF tags
127
128 const size_t tag_size = sizeof(xtiffFieldInfo) / sizeof(xtiffFieldInfo[0]);
129
130 TagLib& tag_lib = TagLib::instance();
131
132 for(size_t i = 0; i < tag_size; i++) {
133
134 const TIFFFieldInfo *fieldInfo = &xtiffFieldInfo[i];
135
136 if(fieldInfo->field_type == TIFF_ASCII) {
137 char *params = NULL;
138
139 if(TIFFGetField(tif, fieldInfo->field_tag, ¶ms)) {
140 // create a tag
141 FITAG *tag = FreeImage_CreateTag();
142 if(!tag) {
143 return FALSE;
144 }
145
146 WORD tag_id = (WORD)fieldInfo->field_tag;
147
148 FreeImage_SetTagType(tag, (FREE_IMAGE_MDTYPE)fieldInfo->field_type);
149 FreeImage_SetTagID(tag, tag_id);
150 FreeImage_SetTagKey(tag, tag_lib.getTagFieldName(TagLib::GEOTIFF, tag_id, defaultKey));
151 FreeImage_SetTagDescription(tag, tag_lib.getTagDescription(TagLib::GEOTIFF, tag_id));
152 FreeImage_SetTagLength(tag, (DWORD)strlen(params) + 1);
153 FreeImage_SetTagCount(tag, FreeImage_GetTagLength(tag));
154 FreeImage_SetTagValue(tag, params);
155 FreeImage_SetMetadata(FIMD_GEOTIFF, dib, FreeImage_GetTagKey(tag), tag);
156
157 // delete the tag
158 FreeImage_DeleteTag(tag);
159 }
160 } else {
161 short tag_count = 0;
162 void* data = NULL;
163
164 if(TIFFGetField(tif, fieldInfo->field_tag, &tag_count, &data)) {
165 // create a tag
166 FITAG *tag = FreeImage_CreateTag();
167 if(!tag) {
168 return FALSE;
169 }
170
171 WORD tag_id = (WORD)fieldInfo->field_tag;
172 FREE_IMAGE_MDTYPE tag_type = (FREE_IMAGE_MDTYPE)fieldInfo->field_type;
173
174 FreeImage_SetTagType(tag, tag_type);
175 FreeImage_SetTagID(tag, tag_id);
176 FreeImage_SetTagKey(tag, tag_lib.getTagFieldName(TagLib::GEOTIFF, tag_id, defaultKey));
177 FreeImage_SetTagDescription(tag, tag_lib.getTagDescription(TagLib::GEOTIFF, tag_id));
178 FreeImage_SetTagLength(tag, FreeImage_TagDataWidth(tag_type) * tag_count);
179 FreeImage_SetTagCount(tag, tag_count);
180 FreeImage_SetTagValue(tag, data);
181 FreeImage_SetMetadata(FIMD_GEOTIFF, dib, FreeImage_GetTagKey(tag), tag);
182
183 // delete the tag
184 FreeImage_DeleteTag(tag);
185 }
186 }
187 } // for(tag_size)
188
189 return TRUE;
190 }
191
192 BOOL
tiff_write_geotiff_profile(TIFF * tif,FIBITMAP * dib)193 tiff_write_geotiff_profile(TIFF *tif, FIBITMAP *dib) {
194 char defaultKey[16];
195
196 if(FreeImage_GetMetadataCount(FIMD_GEOTIFF, dib) == 0) {
197 // no GeoTIFF tag here
198 return TRUE;
199 }
200
201 const size_t tag_size = sizeof(xtiffFieldInfo) / sizeof(xtiffFieldInfo[0]);
202
203 TagLib& tag_lib = TagLib::instance();
204
205 for(size_t i = 0; i < tag_size; i++) {
206 const TIFFFieldInfo *fieldInfo = &xtiffFieldInfo[i];
207
208 FITAG *tag = NULL;
209 const char *key = tag_lib.getTagFieldName(TagLib::GEOTIFF, (WORD)fieldInfo->field_tag, defaultKey);
210
211 if(FreeImage_GetMetadata(FIMD_GEOTIFF, dib, key, &tag)) {
212 if(FreeImage_GetTagType(tag) == FIDT_ASCII) {
213 TIFFSetField(tif, fieldInfo->field_tag, FreeImage_GetTagValue(tag));
214 } else {
215 TIFFSetField(tif, fieldInfo->field_tag, FreeImage_GetTagCount(tag), FreeImage_GetTagValue(tag));
216 }
217 }
218 }
219
220 return TRUE;
221 }
222
223 // ----------------------------------------------------------
224 // TIFF EXIF tag reading & writing
225 // ----------------------------------------------------------
226
227 /**
228 Read a single Exif tag
229
230 @param tif TIFF handle
231 @param tag_id TIFF Tag ID
232 @param dib Image being read
233 @param md_model Metadata model where to store the tag
234 @return Returns TRUE if successful, returns FALSE otherwise
235 */
236 static BOOL
tiff_read_exif_tag(TIFF * tif,uint32 tag_id,FIBITMAP * dib,TagLib::MDMODEL md_model)237 tiff_read_exif_tag(TIFF *tif, uint32 tag_id, FIBITMAP *dib, TagLib::MDMODEL md_model) {
238 uint32 value_count = 0;
239 int mem_alloc = 0;
240 void *raw_data = NULL;
241
242 if(tag_id == TIFFTAG_EXIFIFD) {
243 // Exif IFD offset - skip this tag
244 // md_model should be EXIF_MAIN, the Exif IFD is processed later using the EXIF_EXIF metadata model
245 return TRUE;
246 }
247 if((tag_id == TIFFTAG_GPSIFD) && (md_model == TagLib::EXIF_MAIN)) {
248 // Exif GPS IFD offset - skip this tag
249 // should be processed in another way ...
250 return TRUE;
251 }
252
253 TagLib& tagLib = TagLib::instance();
254
255 // get the tag key - use NULL to avoid reading GeoTIFF tags
256 const char *key = tagLib.getTagFieldName(md_model, (WORD)tag_id, NULL);
257 if(key == NULL) {
258 return TRUE;
259 }
260
261 const TIFFField *fip = TIFFFieldWithTag(tif, tag_id);
262 if(fip == NULL) {
263 return TRUE;
264 }
265
266 if(TIFFFieldPassCount(fip)) {
267 // a count value is required for 'TIFFGetField'
268
269 if (TIFFFieldReadCount(fip) != TIFF_VARIABLE2) {
270 // a count is required, it will be of type uint16
271 uint16 value_count16 = 0;
272 if(TIFFGetField(tif, tag_id, &value_count16, &raw_data) != 1) {
273 // stop, ignore error
274 return TRUE;
275 }
276 value_count = value_count16;
277 } else {
278 // a count is required, it will be of type uint32
279 uint32 value_count32 = 0;
280 if(TIFFGetField(tif, tag_id, &value_count32, &raw_data) != 1) {
281 // stop, ignore error
282 return TRUE;
283 }
284 value_count = value_count32;
285 }
286
287 } else {
288 // determine count
289
290 if (TIFFFieldReadCount(fip) == TIFF_VARIABLE || TIFFFieldReadCount(fip) == TIFF_VARIABLE2) {
291 value_count = 1;
292 } else if (TIFFFieldReadCount(fip) == TIFF_SPP) {
293 uint16 spp;
294 TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &spp);
295 value_count = spp;
296 } else {
297 value_count = TIFFFieldReadCount(fip);
298 }
299
300 // access fields as pointers to data
301 // (### determining this is NOT robust... and hardly can be. It is implemented looking the _TIFFVGetField code)
302
303 if(TIFFFieldTag(fip) == TIFFTAG_TRANSFERFUNCTION) {
304 // reading this tag cause a bug probably located somewhere inside libtiff
305 return TRUE;
306 }
307
308 if ((TIFFFieldDataType(fip) == TIFF_ASCII
309 || TIFFFieldReadCount(fip) == TIFF_VARIABLE
310 || TIFFFieldReadCount(fip) == TIFF_VARIABLE2
311 || TIFFFieldReadCount(fip) == TIFF_SPP
312 || value_count > 1)
313
314 && TIFFFieldTag(fip) != TIFFTAG_PAGENUMBER
315 && TIFFFieldTag(fip) != TIFFTAG_HALFTONEHINTS
316 && TIFFFieldTag(fip) != TIFFTAG_YCBCRSUBSAMPLING
317 && TIFFFieldTag(fip) != TIFFTAG_DOTRANGE
318
319 && TIFFFieldTag(fip) != TIFFTAG_BITSPERSAMPLE //<- these two are tricky -
320 && TIFFFieldTag(fip) != TIFFTAG_COMPRESSION //<- they are defined as TIFF_VARIABLE but in reality return a single value
321 ) {
322 if(TIFFGetField(tif, tag_id, &raw_data) != 1) {
323 // stop, ignore error
324 return TRUE;
325 }
326 } else {
327 int value_size = 0;
328
329 // access fields as values
330
331 // Note:
332 // For TIFF_RATIONAL values, TIFFDataWidth() returns 8, but LibTIFF use internaly 4-byte float to represent rationals.
333 {
334 TIFFDataType tag_type = TIFFFieldDataType(fip);
335 switch(tag_type) {
336 case TIFF_RATIONAL:
337 case TIFF_SRATIONAL:
338 value_size = 4;
339 break;
340 default:
341 value_size = TIFFDataWidth(tag_type);
342 break;
343 }
344 }
345
346 raw_data = _TIFFmalloc(value_size * value_count);
347 mem_alloc = 1;
348 int ok = FALSE;
349
350 // ### if value_count > 1, tag is PAGENUMBER or HALFTONEHINTS or YCBCRSUBSAMPLING or DOTRANGE,
351 // all off which are value_count == 2 (see tif_dirinfo.c)
352 switch(value_count)
353 {
354 case 1:
355 ok = TIFFGetField(tif, tag_id, raw_data);
356 break;
357 case 2:
358 ok = TIFFGetField(tif, tag_id, raw_data, (BYTE*)(raw_data) + value_size*1);
359 break;
360 /* # we might need more in the future:
361 case 3:
362 ok = TIFFGetField(tif, tag_id, raw_data, (BYTE*)(raw_data) + value_size*1, (BYTE*)(raw_data) + value_size*2);
363 break;
364 */
365 default:
366 FreeImage_OutputMessageProc(FIF_TIFF, "Unimplemented variable number of parameters for Tiff Tag %s", TIFFFieldName(fip));
367 break;
368 }
369 if(ok != 1) {
370 _TIFFfree(raw_data);
371 return TRUE;
372 }
373 }
374 }
375
376 // build FreeImage tag from Tiff Tag data we collected
377
378 FITAG *fitag = FreeImage_CreateTag();
379 if(!fitag) {
380 if(mem_alloc) {
381 _TIFFfree(raw_data);
382 }
383 return FALSE;
384 }
385
386 FreeImage_SetTagID(fitag, (WORD)tag_id);
387 FreeImage_SetTagKey(fitag, key);
388
389 switch(TIFFFieldDataType(fip)) {
390 case TIFF_BYTE:
391 FreeImage_SetTagType(fitag, FIDT_BYTE);
392 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
393 FreeImage_SetTagCount(fitag, value_count);
394 FreeImage_SetTagValue(fitag, raw_data);
395 break;
396
397 case TIFF_UNDEFINED:
398 FreeImage_SetTagType(fitag, FIDT_UNDEFINED);
399 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
400 FreeImage_SetTagCount(fitag, value_count);
401 FreeImage_SetTagValue(fitag, raw_data);
402 break;
403
404 case TIFF_SBYTE:
405 FreeImage_SetTagType(fitag, FIDT_SBYTE);
406 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
407 FreeImage_SetTagCount(fitag, value_count);
408 FreeImage_SetTagValue(fitag, raw_data);
409 break;
410
411 case TIFF_SHORT:
412 FreeImage_SetTagType(fitag, FIDT_SHORT);
413 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
414 FreeImage_SetTagCount(fitag, value_count);
415 FreeImage_SetTagValue(fitag, raw_data);
416 break;
417
418 case TIFF_SSHORT:
419 FreeImage_SetTagType(fitag, FIDT_SSHORT);
420 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
421 FreeImage_SetTagCount(fitag, value_count);
422 FreeImage_SetTagValue(fitag, raw_data);
423 break;
424
425 case TIFF_LONG:
426 FreeImage_SetTagType(fitag, FIDT_LONG);
427 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
428 FreeImage_SetTagCount(fitag, value_count);
429 FreeImage_SetTagValue(fitag, raw_data);
430 break;
431
432 case TIFF_IFD:
433 FreeImage_SetTagType(fitag, FIDT_IFD);
434 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
435 FreeImage_SetTagCount(fitag, value_count);
436 FreeImage_SetTagValue(fitag, raw_data);
437 break;
438
439 case TIFF_SLONG:
440 FreeImage_SetTagType(fitag, FIDT_SLONG);
441 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
442 FreeImage_SetTagCount(fitag, value_count);
443 FreeImage_SetTagValue(fitag, raw_data);
444 break;
445
446 case TIFF_RATIONAL: {
447 // LibTIFF converts rational to floats : reconvert floats to rationals
448 DWORD *rvalue = (DWORD*)malloc(2 * value_count * sizeof(DWORD));
449 for(uint32 i = 0; i < value_count; i++) {
450 float *fv = (float*)raw_data;
451 FIRational rational(fv[i]);
452 rvalue[2*i] = rational.getNumerator();
453 rvalue[2*i+1] = rational.getDenominator();
454 }
455 FreeImage_SetTagType(fitag, FIDT_RATIONAL);
456 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
457 FreeImage_SetTagCount(fitag, value_count);
458 FreeImage_SetTagValue(fitag, rvalue);
459 free(rvalue);
460 }
461 break;
462
463 case TIFF_SRATIONAL: {
464 // LibTIFF converts rational to floats : reconvert floats to rationals
465 LONG *rvalue = (LONG*)malloc(2 * value_count * sizeof(LONG));
466 for(uint32 i = 0; i < value_count; i++) {
467 float *fv = (float*)raw_data;
468 FIRational rational(fv[i]);
469 rvalue[2*i] = rational.getNumerator();
470 rvalue[2*i+1] = rational.getDenominator();
471 }
472 FreeImage_SetTagType(fitag, FIDT_RATIONAL);
473 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
474 FreeImage_SetTagCount(fitag, value_count);
475 FreeImage_SetTagValue(fitag, rvalue);
476 free(rvalue);
477 }
478 break;
479
480 case TIFF_FLOAT:
481 FreeImage_SetTagType(fitag, FIDT_FLOAT);
482 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
483 FreeImage_SetTagCount(fitag, value_count);
484 FreeImage_SetTagValue(fitag, raw_data);
485 break;
486
487 case TIFF_DOUBLE:
488 FreeImage_SetTagType(fitag, FIDT_DOUBLE);
489 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
490 FreeImage_SetTagCount(fitag, value_count);
491 FreeImage_SetTagValue(fitag, raw_data);
492 break;
493
494 case TIFF_LONG8: // BigTIFF 64-bit unsigned integer
495 FreeImage_SetTagType(fitag, FIDT_LONG8);
496 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
497 FreeImage_SetTagCount(fitag, value_count);
498 FreeImage_SetTagValue(fitag, raw_data);
499 break;
500
501 case TIFF_IFD8: // BigTIFF 64-bit unsigned integer (offset)
502 FreeImage_SetTagType(fitag, FIDT_IFD8);
503 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
504 FreeImage_SetTagCount(fitag, value_count);
505 FreeImage_SetTagValue(fitag, raw_data);
506 break;
507
508 case TIFF_SLONG8: // BigTIFF 64-bit signed integer
509 FreeImage_SetTagType(fitag, FIDT_SLONG8);
510 FreeImage_SetTagLength(fitag, TIFFDataWidth( TIFFFieldDataType(fip) ) * value_count);
511 FreeImage_SetTagCount(fitag, value_count);
512 FreeImage_SetTagValue(fitag, raw_data);
513 break;
514
515 case TIFF_ASCII:
516 default: {
517 size_t length = 0;
518 if(!mem_alloc && (TIFFFieldDataType(fip) == TIFF_ASCII) && (TIFFFieldReadCount(fip) == TIFF_VARIABLE)) {
519 // when metadata tag is of type ASCII and it's value is of variable size (TIFF_VARIABLE),
520 // tiff_read_exif_tag function gives length of 1 so all strings are truncated ...
521 // ... try to avoid this by using an explicit calculation for 'length'
522 length = strlen((char*)raw_data) + 1;
523 }
524 else {
525 // remember that raw_data = _TIFFmalloc(value_size * value_count);
526 const int value_size = TIFFDataWidth( TIFFFieldDataType(fip) );
527 length = value_size * value_count;
528 }
529 FreeImage_SetTagType(fitag, FIDT_ASCII);
530 FreeImage_SetTagLength(fitag, (DWORD)length);
531 FreeImage_SetTagCount(fitag, (DWORD)length);
532 FreeImage_SetTagValue(fitag, raw_data);
533 }
534 break;
535 }
536
537 const char *description = tagLib.getTagDescription(md_model, (WORD)tag_id);
538 if(description) {
539 FreeImage_SetTagDescription(fitag, description);
540 }
541 // store the tag
542 FreeImage_SetMetadata(tagLib.getFreeImageModel(md_model), dib, FreeImage_GetTagKey(fitag), fitag);
543
544 // destroy the tag
545 FreeImage_DeleteTag(fitag);
546
547 if(mem_alloc) {
548 _TIFFfree(raw_data);
549 }
550 return TRUE;
551 }
552
553 /**
554 Read all known exif tags
555
556 @param tif TIFF handle
557 @param md_model Metadata model where to store the tags
558 @param dib Image being read
559 @return Returns TRUE if successful, returns FALSE otherwise
560 */
561 BOOL
tiff_read_exif_tags(TIFF * tif,TagLib::MDMODEL md_model,FIBITMAP * dib)562 tiff_read_exif_tags(TIFF *tif, TagLib::MDMODEL md_model, FIBITMAP *dib) {
563
564 TagLib& tagLib = TagLib::instance();
565
566 const int count = TIFFGetTagListCount(tif);
567 for(int i = 0; i < count; i++) {
568 uint32 tag_id = TIFFGetTagListEntry(tif, i);
569 // read the tag
570 if (!tiff_read_exif_tag(tif, tag_id, dib, md_model))
571 return FALSE;
572 }
573
574 // we want to know values of standard tags too!!
575
576 // loop over all Core Directory Tags
577 // ### uses private data, but there is no other way
578 if(md_model == TagLib::EXIF_MAIN) {
579 const TIFFDirectory *td = &tif->tif_dir;
580
581 uint32 lastTag = 0; //<- used to prevent reading some tags twice (as stored in tif_fieldinfo)
582
583 for (int fi = 0, nfi = (int)tif->tif_nfields; nfi > 0; nfi--, fi++) {
584 const TIFFField *fld = tif->tif_fields[fi];
585
586 const uint32 tag_id = TIFFFieldTag(fld);
587
588 if(tag_id == lastTag) {
589 continue;
590 }
591
592 // test if tag value is set
593 // (lifted directly from LibTiff _TIFFWriteDirectory)
594
595 if( fld->field_bit == FIELD_CUSTOM ) {
596 int is_set = FALSE;
597
598 for(int ci = 0; ci < td->td_customValueCount; ci++ ) {
599 is_set |= (td->td_customValues[ci].info == fld);
600 }
601
602 if( !is_set ) {
603 continue;
604 }
605
606 } else if(!TIFFFieldSet(tif, fld->field_bit)) {
607 continue;
608 }
609
610 // process *all* other tags (some will be ignored)
611
612 tiff_read_exif_tag(tif, tag_id, dib, md_model);
613
614 lastTag = tag_id;
615 }
616
617 }
618
619 return TRUE;
620 }
621
622
623 /**
624 Skip tags that are already handled by the LibTIFF writing process
625 */
626 static BOOL
skip_write_field(TIFF * tif,uint32 tag)627 skip_write_field(TIFF* tif, uint32 tag) {
628 switch (tag) {
629 case TIFFTAG_SUBFILETYPE:
630 case TIFFTAG_OSUBFILETYPE:
631 case TIFFTAG_IMAGEWIDTH:
632 case TIFFTAG_IMAGELENGTH:
633 case TIFFTAG_BITSPERSAMPLE:
634 case TIFFTAG_COMPRESSION:
635 case TIFFTAG_PHOTOMETRIC:
636 case TIFFTAG_THRESHHOLDING:
637 case TIFFTAG_CELLWIDTH:
638 case TIFFTAG_CELLLENGTH:
639 case TIFFTAG_FILLORDER:
640 case TIFFTAG_STRIPOFFSETS:
641 case TIFFTAG_ORIENTATION:
642 case TIFFTAG_SAMPLESPERPIXEL:
643 case TIFFTAG_ROWSPERSTRIP:
644 case TIFFTAG_STRIPBYTECOUNTS:
645 case TIFFTAG_MINSAMPLEVALUE:
646 case TIFFTAG_MAXSAMPLEVALUE:
647 case TIFFTAG_XRESOLUTION:
648 case TIFFTAG_YRESOLUTION:
649 case TIFFTAG_PLANARCONFIG:
650 case TIFFTAG_FREEOFFSETS:
651 case TIFFTAG_FREEBYTECOUNTS:
652 case TIFFTAG_GRAYRESPONSEUNIT:
653 case TIFFTAG_GRAYRESPONSECURVE:
654 case TIFFTAG_GROUP3OPTIONS:
655 case TIFFTAG_GROUP4OPTIONS:
656 case TIFFTAG_RESOLUTIONUNIT:
657 case TIFFTAG_PAGENUMBER:
658 case TIFFTAG_COLORRESPONSEUNIT:
659 case TIFFTAG_PREDICTOR:
660 case TIFFTAG_COLORMAP:
661 case TIFFTAG_HALFTONEHINTS:
662 case TIFFTAG_TILEWIDTH:
663 case TIFFTAG_TILELENGTH:
664 case TIFFTAG_TILEOFFSETS:
665 case TIFFTAG_TILEBYTECOUNTS:
666 case TIFFTAG_EXTRASAMPLES:
667 case TIFFTAG_SAMPLEFORMAT:
668 case TIFFTAG_SMINSAMPLEVALUE:
669 case TIFFTAG_SMAXSAMPLEVALUE:
670 // skip always, values have been set in SaveOneTIFF()
671 return TRUE;
672 break;
673
674 case TIFFTAG_RICHTIFFIPTC:
675 // skip always, IPTC metadata model is set in tiff_write_iptc_profile()
676 return TRUE;
677 break;
678
679 case TIFFTAG_YCBCRCOEFFICIENTS:
680 case TIFFTAG_REFERENCEBLACKWHITE:
681 case TIFFTAG_YCBCRSUBSAMPLING:
682 // skip as they cannot be filled yet
683 return TRUE;
684 break;
685
686 case TIFFTAG_PAGENAME:
687 {
688 char *value = NULL;
689 TIFFGetField(tif, TIFFTAG_PAGENAME, &value);
690 // only skip if no value has been set
691 if(value == NULL) {
692 return FALSE;
693 } else {
694 return TRUE;
695 }
696 }
697 default:
698 return FALSE;
699 break;
700 }
701 }
702
703 /**
704 Write all known exif tags
705
706 @param tif TIFF handle
707 @param md_model Metadata model from where to load the tags
708 @param dib Image being written
709 @return Returns TRUE if successful, returns FALSE otherwise
710 */
711 BOOL
tiff_write_exif_tags(TIFF * tif,TagLib::MDMODEL md_model,FIBITMAP * dib)712 tiff_write_exif_tags(TIFF *tif, TagLib::MDMODEL md_model, FIBITMAP *dib) {
713 char defaultKey[16];
714
715 // only EXIF_MAIN so far
716 if(md_model != TagLib::EXIF_MAIN) {
717 return FALSE;
718 }
719
720 if(FreeImage_GetMetadataCount(FIMD_EXIF_MAIN, dib) == 0) {
721 return FALSE;
722 }
723
724 TagLib& tag_lib = TagLib::instance();
725
726 for (int fi = 0, nfi = (int)tif->tif_nfields; nfi > 0; nfi--, fi++) {
727 const TIFFField *fld = tif->tif_fields[fi];
728
729 const uint32 tag_id = TIFFFieldTag(fld);
730
731 if(skip_write_field(tif, tag_id)) {
732 // skip tags that are already handled by the LibTIFF writing process
733 continue;
734 }
735
736 FITAG *tag = NULL;
737 // get the tag key
738 const char *key = tag_lib.getTagFieldName(TagLib::EXIF_MAIN, (WORD)tag_id, defaultKey);
739
740 if(FreeImage_GetMetadata(FIMD_EXIF_MAIN, dib, key, &tag)) {
741 FREE_IMAGE_MDTYPE tag_type = FreeImage_GetTagType(tag);
742 TIFFDataType tif_tag_type = TIFFFieldDataType(fld);
743
744 // check for identical formats
745
746 // (enum value are the sames between FREE_IMAGE_MDTYPE and TIFFDataType types)
747 if((int)tif_tag_type != (int)tag_type) {
748 // skip tag or _TIFFmemcpy will fail
749 continue;
750 }
751 // type of storage may differ (e.g. rationnal array vs float array type)
752 if((unsigned)_TIFFDataSize(tif_tag_type) != FreeImage_TagDataWidth(tag_type)) {
753 // skip tag or _TIFFmemcpy will fail
754 continue;
755 }
756
757 if(tag_type == FIDT_ASCII) {
758 TIFFSetField(tif, tag_id, FreeImage_GetTagValue(tag));
759 } else {
760 TIFFSetField(tif, tag_id, FreeImage_GetTagCount(tag), FreeImage_GetTagValue(tag));
761 }
762 }
763 }
764
765 return TRUE;
766 }
767