← Back to branch summary

~cosme/ubuntu/precise/freeimage/freeimage-3.15.1

« back to all changes in this revision

Viewing changes to Source/Metadata/XTIFF.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Cosme Domínguez Díaz
  • Date: 2010-07-20 13:42:15 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100720134215-xt1454zaedv3b604
Tags: 3.13.1-0ubuntu1
https://launchpad.net/bugs/607800
* New upstream release. Closes: (LP: #607800)
 - Updated debian/freeimage-get-orig-source script.
 - Removing no longer necessary debian/patches/* and
   the patch system in debian/rules.
 - Updated debian/rules to work with the new Makefiles.
 - Drop from -O3 to -O2 and use lzma compression saves
   ~10 MB of free space. 
* lintian stuff
 - fixed debhelper-but-no-misc-depends
 - fixed ldconfig-symlink-missing-for-shlib

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/Metadata/XTIFF.cpp
5
5
// Design and implementation by
6
6
// - Herv� Drolon (drolon@infonie.fr)
7
7
// - Thorsten Radde (support@IdealSoftware.com)
 
8
// - Berend Engelbrecht (softwarecave@users.sourceforge.net)
8
9
//
9
10
// Based on the LibTIFF xtiffio sample and on LibGeoTIFF
10
11
//
58
59
 
59
60
static void 
60
61
_XTIFFLocalDefaultDirectory(TIFF *tif) {
61
 
        size_t tag_size = sizeof(xtiffFieldInfo) / sizeof(xtiffFieldInfo[0]);
 
62
        int tag_size = sizeof(xtiffFieldInfo) / sizeof(xtiffFieldInfo[0]);
62
63
    // Install the extended Tag field info
63
64
    TIFFMergeFieldInfo(tif, xtiffFieldInfo, tag_size);
64
65
}
128
129
                                FreeImage_SetTagID(tag, tag_id);
129
130
                                FreeImage_SetTagKey(tag, tag_lib.getTagFieldName(TagLib::GEOTIFF, tag_id, defaultKey));
130
131
                                FreeImage_SetTagDescription(tag, tag_lib.getTagDescription(TagLib::GEOTIFF, tag_id));
131
 
                                FreeImage_SetTagLength(tag, strlen(params) + 1);
 
132
                                FreeImage_SetTagLength(tag, (DWORD)strlen(params) + 1);
132
133
                                FreeImage_SetTagCount(tag, FreeImage_GetTagLength(tag));
133
134
                                FreeImage_SetTagValue(tag, params);
134
135
                                FreeImage_SetMetadata(FIMD_GEOTIFF, dib, FreeImage_GetTagKey(tag), tag);
196
197
//   EXIF tag reading 
197
198
// ----------------------------------------------------------
198
199
 
 
200
/**
 
201
Read a single exif tag
 
202
*/
 
203
BOOL tiff_read_exif_tag(TIFF *tif, TagLib::MDMODEL md_model, FIBITMAP *dib, TagLib& tagLib, TIFFDirectory *td, ttag_t tag) {
 
204
  const TIFFFieldInfo *fip;
 
205
  uint32 value_count;
 
206
  int mem_alloc = 0;
 
207
  void *raw_data = NULL;
 
208
 
 
209
  if(tag == TIFFTAG_EXIFIFD) return TRUE; 
 
210
 
 
211
  // get the tag key - use NULL to avoid reading GeoTIFF tags
 
212
  const char *key = tagLib.getTagFieldName(md_model, (WORD)tag, NULL);
 
213
  if(key == NULL) return TRUE;
 
214
 
 
215
  fip = TIFFFieldWithTag(tif, tag);
 
216
  if(fip == NULL) return TRUE;
 
217
 
 
218
  if(fip->field_passcount) {
 
219
    if (fip->field_readcount != TIFF_VARIABLE2) {
 
220
      // assume TIFF_VARIABLE
 
221
      uint16 value_count16;
 
222
      if(TIFFGetField(tif, tag, &value_count16, &raw_data) != 1) return TRUE;
 
223
      value_count = value_count16;
 
224
    } else {
 
225
      if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1) return TRUE;
 
226
    }
 
227
  } else {
 
228
    if (fip->field_readcount == TIFF_VARIABLE || fip->field_readcount == TIFF_VARIABLE2) {
 
229
      value_count = 1;
 
230
    } else if (fip->field_readcount == TIFF_SPP) {
 
231
      value_count = td->td_samplesperpixel;
 
232
    } else {
 
233
      value_count = fip->field_readcount;
 
234
    }
 
235
    if (fip->field_type == TIFF_ASCII 
 
236
      || fip->field_readcount == TIFF_VARIABLE
 
237
      || fip->field_readcount == TIFF_VARIABLE2
 
238
      || fip->field_readcount == TIFF_SPP
 
239
      || value_count > 1) {
 
240
        if(TIFFGetField(tif, tag, &raw_data) != 1) return TRUE;
 
241
    } else {
 
242
      raw_data = _TIFFmalloc(_TIFFDataSize(fip->field_type) * value_count);
 
243
      mem_alloc = 1;
 
244
      if(TIFFGetField(tif, tag, raw_data) != 1) { 
 
245
        _TIFFfree(raw_data);
 
246
        return TRUE;
 
247
      }
 
248
    }
 
249
  }
 
250
 
 
251
  // create a tag
 
252
  FITAG *fitag = FreeImage_CreateTag();
 
253
  if(!fitag) {
 
254
    if(mem_alloc)
 
255
      _TIFFfree(raw_data);
 
256
    return FALSE;
 
257
  }
 
258
 
 
259
  FreeImage_SetTagID(fitag, (WORD)tag);
 
260
  FreeImage_SetTagKey(fitag, key);
 
261
 
 
262
  switch(fip->field_type) {
 
263
      case TIFF_BYTE:
 
264
        FreeImage_SetTagType(fitag, FIDT_BYTE);
 
265
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
266
        FreeImage_SetTagCount(fitag, value_count);
 
267
        FreeImage_SetTagValue(fitag, raw_data);
 
268
        break;
 
269
 
 
270
      case TIFF_UNDEFINED:
 
271
        FreeImage_SetTagType(fitag, FIDT_UNDEFINED);
 
272
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
273
        FreeImage_SetTagCount(fitag, value_count);
 
274
        FreeImage_SetTagValue(fitag, raw_data);
 
275
        break;
 
276
 
 
277
      case TIFF_SBYTE:
 
278
        FreeImage_SetTagType(fitag, FIDT_SBYTE);
 
279
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
280
        FreeImage_SetTagCount(fitag, value_count);
 
281
        FreeImage_SetTagValue(fitag, raw_data);
 
282
        break;
 
283
 
 
284
      case TIFF_SHORT:
 
285
        FreeImage_SetTagType(fitag, FIDT_SHORT);
 
286
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
287
        FreeImage_SetTagCount(fitag, value_count);
 
288
        FreeImage_SetTagValue(fitag, raw_data);
 
289
        break;
 
290
 
 
291
      case TIFF_SSHORT:
 
292
        FreeImage_SetTagType(fitag, FIDT_SSHORT);
 
293
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
294
        FreeImage_SetTagCount(fitag, value_count);
 
295
        FreeImage_SetTagValue(fitag, raw_data);
 
296
        break;
 
297
 
 
298
      case TIFF_LONG:
 
299
        FreeImage_SetTagType(fitag, FIDT_LONG);
 
300
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
301
        FreeImage_SetTagCount(fitag, value_count);
 
302
        FreeImage_SetTagValue(fitag, raw_data);
 
303
        break;
 
304
 
 
305
      case TIFF_IFD:
 
306
        FreeImage_SetTagType(fitag, FIDT_IFD);
 
307
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
308
        FreeImage_SetTagCount(fitag, value_count);
 
309
        FreeImage_SetTagValue(fitag, raw_data);
 
310
        break;
 
311
 
 
312
      case TIFF_SLONG:
 
313
        FreeImage_SetTagType(fitag, FIDT_SLONG);
 
314
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
315
        FreeImage_SetTagCount(fitag, value_count);
 
316
        FreeImage_SetTagValue(fitag, raw_data);
 
317
        break;
 
318
 
 
319
      case TIFF_RATIONAL:
 
320
        {
 
321
          // LibTIFF converts rational to floats : reconvert floats to rationals
 
322
          DWORD *rvalue = (DWORD*)malloc(2 * value_count * sizeof(DWORD));
 
323
          for(uint32 i = 0; i < value_count; i++) {
 
324
            float *fv = (float*)raw_data;
 
325
            FIRational rational(fv[i]);
 
326
            rvalue[2*i] = rational.getNumerator();
 
327
            rvalue[2*i+1] = rational.getDenominator();
 
328
          }
 
329
          FreeImage_SetTagType(fitag, FIDT_RATIONAL);
 
330
          FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
331
          FreeImage_SetTagCount(fitag, value_count);
 
332
          FreeImage_SetTagValue(fitag, rvalue);
 
333
          free(rvalue);
 
334
        }
 
335
        break;
 
336
 
 
337
      case TIFF_SRATIONAL:
 
338
        {
 
339
          // LibTIFF converts rational to floats : reconvert floats to rationals
 
340
          LONG *rvalue = (LONG*)malloc(2 * value_count * sizeof(LONG));
 
341
          for(uint32 i = 0; i < value_count; i++) {
 
342
            float *fv = (float*)raw_data;
 
343
            FIRational rational(fv[i]);
 
344
            rvalue[2*i] = rational.getNumerator();
 
345
            rvalue[2*i+1] = rational.getDenominator();
 
346
          }
 
347
          FreeImage_SetTagType(fitag, FIDT_RATIONAL);
 
348
          FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
349
          FreeImage_SetTagCount(fitag, value_count);
 
350
          FreeImage_SetTagValue(fitag, rvalue);
 
351
          free(rvalue);
 
352
        }
 
353
        break;
 
354
 
 
355
      case TIFF_FLOAT:
 
356
        FreeImage_SetTagType(fitag, FIDT_FLOAT);
 
357
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
358
        FreeImage_SetTagCount(fitag, value_count);
 
359
        FreeImage_SetTagValue(fitag, raw_data);
 
360
        break;
 
361
 
 
362
      case TIFF_DOUBLE:
 
363
        FreeImage_SetTagType(fitag, FIDT_DOUBLE);
 
364
        FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
 
365
        FreeImage_SetTagCount(fitag, value_count);
 
366
        FreeImage_SetTagValue(fitag, raw_data);
 
367
        break;
 
368
 
 
369
      default:
 
370
        {
 
371
          size_t length = strlen((char*)raw_data) + 1;
 
372
          FreeImage_SetTagType(fitag, FIDT_ASCII);
 
373
          FreeImage_SetTagLength(fitag, (DWORD)length);
 
374
          FreeImage_SetTagCount(fitag, (DWORD)length);
 
375
          FreeImage_SetTagValue(fitag, raw_data);
 
376
        }
 
377
        break;
 
378
  }
 
379
 
 
380
  const char *description = tagLib.getTagDescription(md_model, (WORD)tag);
 
381
  if(description) {
 
382
    FreeImage_SetTagDescription(fitag, description);
 
383
  }
 
384
  // store the tag
 
385
  FreeImage_SetMetadata(tagLib.getFreeImageModel(md_model), dib, FreeImage_GetTagKey(fitag), fitag);
 
386
 
 
387
  // destroy the tag
 
388
  FreeImage_DeleteTag(fitag);
 
389
 
 
390
  if(mem_alloc)
 
391
    _TIFFfree(raw_data);
 
392
  return TRUE;
 
393
}
 
394
 
 
395
/** 
 
396
Read all known exif tags
 
397
*/
199
398
BOOL tiff_read_exif_tags(TIFF *tif, TagLib::MDMODEL md_model, FIBITMAP *dib) {
200
 
    int  i;
201
 
    short count;
202
 
 
203
 
        TagLib& tagLib = TagLib::instance();
204
 
 
205
 
        TIFFDirectory *td = &tif->tif_dir;
206
 
    
207
 
        count = (short) TIFFGetTagListCount(tif);
208
 
    for(i = 0; i < count; i++) {
209
 
        ttag_t tag = TIFFGetTagListEntry(tif, i);
210
 
        const TIFFFieldInfo *fip;
211
 
        uint32 value_count;
212
 
        int mem_alloc = 0;
213
 
        void *raw_data;
214
 
 
215
 
                if(tag == TIFFTAG_EXIFIFD) continue;
216
 
 
217
 
                // get the tag key - use NULL to avoid reading GeoTIFF tags
218
 
                const char *key = tagLib.getTagFieldName(md_model, (WORD)tag, NULL);
219
 
                if(key == NULL) continue;
220
 
        
221
 
                fip = TIFFFieldWithTag(tif, tag);
222
 
        if(fip == NULL)
223
 
                        continue;
224
 
                
225
 
                if(fip->field_passcount) {
226
 
                        if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1)
227
 
                                continue;
228
 
                } else {
229
 
                        if (fip->field_readcount == TIFF_VARIABLE || fip->field_readcount == TIFF_VARIABLE2)
230
 
                                value_count = 1;
231
 
                        else if (fip->field_readcount == TIFF_SPP)
232
 
                                value_count = td->td_samplesperpixel;
233
 
                        else
234
 
                                value_count = fip->field_readcount;
235
 
                        if (fip->field_type == TIFF_ASCII 
236
 
                                || fip->field_readcount == TIFF_VARIABLE
237
 
                                || fip->field_readcount == TIFF_VARIABLE2
238
 
                                || fip->field_readcount == TIFF_SPP
239
 
                                || value_count > 1) {
240
 
                                if(TIFFGetField(tif, tag, &raw_data) != 1)
241
 
                                        continue;
242
 
                        } else {
243
 
                                raw_data = _TIFFmalloc(_TIFFDataSize(fip->field_type) * value_count);
244
 
                                mem_alloc = 1;
245
 
                                if(TIFFGetField(tif, tag, raw_data) != 1) {
246
 
                                        _TIFFfree(raw_data);
247
 
                                        continue;
248
 
                                }
249
 
                        }
250
 
                }
251
 
                
252
 
                // create a tag
253
 
                FITAG *fitag = FreeImage_CreateTag();
254
 
                if(!fitag) {
255
 
                        if(mem_alloc)
256
 
                                _TIFFfree(raw_data);
257
 
                        return FALSE;
258
 
                }
259
 
 
260
 
                FreeImage_SetTagID(fitag, (WORD)tag);
261
 
                FreeImage_SetTagKey(fitag, key);
262
 
 
263
 
                switch(fip->field_type) {
264
 
                        case TIFF_BYTE:
265
 
                                FreeImage_SetTagType(fitag, FIDT_BYTE);
266
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
267
 
                                FreeImage_SetTagCount(fitag, value_count);
268
 
                                FreeImage_SetTagValue(fitag, raw_data);
269
 
                                break;
270
 
 
271
 
                        case TIFF_UNDEFINED:
272
 
                                FreeImage_SetTagType(fitag, FIDT_UNDEFINED);
273
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
274
 
                                FreeImage_SetTagCount(fitag, value_count);
275
 
                                FreeImage_SetTagValue(fitag, raw_data);
276
 
                                break;
277
 
 
278
 
                        case TIFF_SBYTE:
279
 
                                FreeImage_SetTagType(fitag, FIDT_SBYTE);
280
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
281
 
                                FreeImage_SetTagCount(fitag, value_count);
282
 
                                FreeImage_SetTagValue(fitag, raw_data);
283
 
                                break;
284
 
 
285
 
                        case TIFF_SHORT:
286
 
                                FreeImage_SetTagType(fitag, FIDT_SHORT);
287
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
288
 
                                FreeImage_SetTagCount(fitag, value_count);
289
 
                                FreeImage_SetTagValue(fitag, raw_data);
290
 
                                break;
291
 
 
292
 
                        case TIFF_SSHORT:
293
 
                                FreeImage_SetTagType(fitag, FIDT_SSHORT);
294
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
295
 
                                FreeImage_SetTagCount(fitag, value_count);
296
 
                                FreeImage_SetTagValue(fitag, raw_data);
297
 
                                break;
298
 
 
299
 
                        case TIFF_LONG:
300
 
                                FreeImage_SetTagType(fitag, FIDT_LONG);
301
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
302
 
                                FreeImage_SetTagCount(fitag, value_count);
303
 
                                FreeImage_SetTagValue(fitag, raw_data);
304
 
                                break;
305
 
 
306
 
                        case TIFF_IFD:
307
 
                                FreeImage_SetTagType(fitag, FIDT_IFD);
308
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
309
 
                                FreeImage_SetTagCount(fitag, value_count);
310
 
                                FreeImage_SetTagValue(fitag, raw_data);
311
 
                                break;
312
 
 
313
 
                        case TIFF_SLONG:
314
 
                                FreeImage_SetTagType(fitag, FIDT_SLONG);
315
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
316
 
                                FreeImage_SetTagCount(fitag, value_count);
317
 
                                FreeImage_SetTagValue(fitag, raw_data);
318
 
                                break;
319
 
 
320
 
                        case TIFF_RATIONAL:
321
 
                        {
322
 
                                // LibTIFF converts rational to floats : reconvert floats to rationals
323
 
                                DWORD *rvalue = (DWORD*)malloc(2 * value_count * sizeof(DWORD));
324
 
                                for(uint32 i = 0; i < value_count; i++) {
325
 
                                        float *fv = (float*)raw_data;
326
 
                                        FIRational rational(fv[i]);
327
 
                                        rvalue[2*i] = rational.getNumerator();
328
 
                                        rvalue[2*i+1] = rational.getDenominator();
329
 
                                }
330
 
                                FreeImage_SetTagType(fitag, FIDT_RATIONAL);
331
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
332
 
                                FreeImage_SetTagCount(fitag, value_count);
333
 
                                FreeImage_SetTagValue(fitag, rvalue);
334
 
                                free(rvalue);
335
 
                        }
336
 
                        break;
337
 
 
338
 
                        case TIFF_SRATIONAL:
339
 
                        {
340
 
                                // LibTIFF converts rational to floats : reconvert floats to rationals
341
 
                                LONG *rvalue = (LONG*)malloc(2 * value_count * sizeof(LONG));
342
 
                                for(uint32 i = 0; i < value_count; i++) {
343
 
                                        float *fv = (float*)raw_data;
344
 
                                        FIRational rational(fv[i]);
345
 
                                        rvalue[2*i] = rational.getNumerator();
346
 
                                        rvalue[2*i+1] = rational.getDenominator();
347
 
                                }
348
 
                                FreeImage_SetTagType(fitag, FIDT_RATIONAL);
349
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
350
 
                                FreeImage_SetTagCount(fitag, value_count);
351
 
                                FreeImage_SetTagValue(fitag, rvalue);
352
 
                                free(rvalue);
353
 
                        }
354
 
                        break;
355
 
 
356
 
                        case TIFF_FLOAT:
357
 
                                FreeImage_SetTagType(fitag, FIDT_FLOAT);
358
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
359
 
                                FreeImage_SetTagCount(fitag, value_count);
360
 
                                FreeImage_SetTagValue(fitag, raw_data);
361
 
                                break;
362
 
 
363
 
                        case TIFF_DOUBLE:
364
 
                                FreeImage_SetTagType(fitag, FIDT_DOUBLE);
365
 
                                FreeImage_SetTagLength(fitag, TIFFDataWidth(fip->field_type) * value_count);
366
 
                                FreeImage_SetTagCount(fitag, value_count);
367
 
                                FreeImage_SetTagValue(fitag, raw_data);
368
 
                                break;
369
 
 
370
 
                        default:
371
 
                        {
372
 
                                int length = strlen((char*)raw_data) + 1;
373
 
                                FreeImage_SetTagType(fitag, FIDT_ASCII);
374
 
                                FreeImage_SetTagLength(fitag, length);
375
 
                                FreeImage_SetTagCount(fitag, length);
376
 
                                FreeImage_SetTagValue(fitag, raw_data);
377
 
                        }
378
 
                        break;
379
 
                }
380
 
 
381
 
                const char *description = tagLib.getTagDescription(md_model, (WORD)tag);
382
 
                if(description) {
383
 
                        FreeImage_SetTagDescription(fitag, description);
384
 
                }
385
 
                // store the tag
386
 
                FreeImage_SetMetadata(tagLib.getFreeImageModel(md_model), dib, FreeImage_GetTagKey(fitag), fitag);
387
 
 
388
 
                // destroy the tag
389
 
                FreeImage_DeleteTag(fitag);
390
 
        
391
 
                if(mem_alloc)
392
 
                        _TIFFfree(raw_data);
393
 
    }
394
 
 
395
 
        return TRUE;
 
399
  int  i;
 
400
  short count;
 
401
 
 
402
  TagLib& tagLib = TagLib::instance();
 
403
 
 
404
  TIFFDirectory *td = &tif->tif_dir;
 
405
 
 
406
  count = (short) TIFFGetTagListCount(tif);
 
407
  for(i = 0; i < count; i++) {
 
408
    ttag_t tag = TIFFGetTagListEntry(tif, i);
 
409
    // read the tag
 
410
    if (!tiff_read_exif_tag(tif, md_model, dib, tagLib, td, tag))
 
411
      return FALSE;
 
412
  }
 
413
 
 
414
  // we want to know values of standard tags too!!
 
415
  if(md_model == FIMD_EXIF_MAIN) {
 
416
          if(td->td_orientation && !tiff_read_exif_tag(tif, md_model, dib, tagLib, td, TIFFTAG_ORIENTATION))
 
417
                  return FALSE;
 
418
  }
 
419
 
 
420
  return TRUE;
396
421
 
397
422
}
398
423
 
399
424
 
 
425