src/exiv2.cc

   1 /*
   2  * Geeqie
   3  * Copyright (C) 2008 The Geeqie Team
   4  *
   5  * Author: Vladimir Nadvornik
   6  *
   7  * This software is released under the GNU General Public License (GNU GPL).
   8  * Please read the included file COPYING for more information.
   9  * This software comes with no warranty of any kind, use at your own risk!
  10  */
  11
  12 #include "config.h"
  13
  14 #ifdef HAVE_EXIV2
  15
  16 #include <exiv2/image.hpp>
  17 #include <exiv2/exif.hpp>
  18 #include <iostream>
  19
  20 // EXIV2_TEST_VERSION is defined in Exiv2 0.15 and newer.
  21 #ifndef EXIV2_TEST_VERSION
  22 # define EXIV2_TEST_VERSION(major,minor,patch) \
  23         ( EXIV2_VERSION >= EXIV2_MAKE_VERSION(major,minor,patch) )
  24 #endif
  25
  26
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30 #include <fcntl.h>
  31 #include <sys/mman.h>
  32
  33 #include <exiv2/tiffparser.hpp>
  34 #include <exiv2/tiffcomposite.hpp>
  35 #include <exiv2/tiffvisitor.hpp>
  36 #include <exiv2/tiffimage.hpp>
  37 #include <exiv2/cr2image.hpp>
  38 #include <exiv2/crwimage.hpp>
  39 #if EXIV2_TEST_VERSION(0,16,0)
  40 #include <exiv2/orfimage.hpp>
  41 #endif
  42 #if EXIV2_TEST_VERSION(0,13,0)
  43 #include <exiv2/rafimage.hpp>
  44 #endif
  45 #include <exiv2/futils.hpp>
  46
  47
  48
  49 extern "C" {
  50 #include <glib.h>
  51
  52 #include "main.h"
  53 #include "exif.h"
  54
  55 #include "filefilter.h"
  56 #include "ui_fileops.h"
  57 }
  58
  59 struct _ExifData
  60 {
  61         Exiv2::Image::AutoPtr image;
  62         Exiv2::Image::AutoPtr sidecar;
  63         Exiv2::ExifData::const_iterator exifIter; /* for exif_get_next_item */
  64         Exiv2::IptcData::const_iterator iptcIter; /* for exif_get_next_item */
  65 #if EXIV2_TEST_VERSION(0,16,0)
  66         Exiv2::XmpData::const_iterator xmpIter; /* for exif_get_next_item */
  67 #endif
  68         bool have_sidecar;
  69
  70         /* the icc profile in jpeg is not technically exif - store it here */
  71         unsigned char *cp_data;
  72         guint cp_length;
  73
  74         _ExifData(gchar *path, gchar *sidecar_path)
  75         {
  76                 have_sidecar = false;
  77                 cp_data = NULL;
  78                 cp_length = 0;
  79                 gchar *pathl = path_from_utf8(path);
  80                 image = Exiv2::ImageFactory::open(pathl);
  81                 g_free(pathl);
  82 //              g_assert (image.get() != 0);
  83                 image->readMetadata();
  84
  85 #if EXIV2_TEST_VERSION(0,16,0)
  86                 DEBUG_2("xmp count %li", image->xmpData().count());
  87                 if (sidecar_path && image->xmpData().empty())
  88                         {
  89                         gchar *sidecar_pathl = path_from_utf8(sidecar_path);
  90                         sidecar = Exiv2::ImageFactory::open(sidecar_pathl);
  91                         g_free(sidecar_pathl);
  92                         sidecar->readMetadata();
  93                         have_sidecar = sidecar->good();
  94                         DEBUG_2("sidecar xmp count %li", sidecar->xmpData().count());
  95                         }
  96
  97 #endif
  98 #if EXIV2_TEST_VERSION(0,14,0)
  99                 if (image->mimeType() == std::string("image/jpeg"))
 100                         {
 101                         /* try to get jpeg color profile */
 102                         Exiv2::BasicIo &io = image->io();
 103                         gint open = io.isopen();
 104                         if (!open) io.open();
 105                         unsigned char *mapped = (unsigned char*)io.mmap();
 106                         if (mapped) exif_jpeg_parse_color(this, mapped, io.size());
 107                         io.munmap();
 108                         if (!open) io.close();
 109                         }
 110 #endif
 111         }
 112
 113         ~_ExifData()
 114         {
 115                 if (cp_data) g_free(cp_data);
 116         }
 117
 118         void writeMetadata()
 119         {
 120                 if (have_sidecar) sidecar->writeMetadata();
 121                 image->writeMetadata();
 122         }
 123
 124         Exiv2::ExifData &exifData ()
 125         {
 126                 return image->exifData();
 127         }
 128
 129         Exiv2::IptcData &iptcData ()
 130         {
 131                 return image->iptcData();
 132         }
 133
 134 #if EXIV2_TEST_VERSION(0,16,0)
 135         Exiv2::XmpData &xmpData ()
 136         {
 137                 return have_sidecar ? sidecar->xmpData() : image->xmpData();
 138         }
 139 #endif
 140
 141 };
 142
 143 extern "C" {
 144
 145 ExifData *exif_read(gchar *path, gchar *sidecar_path)
 146 {
 147         DEBUG_1("exif read %s, sidecar: %s", path, sidecar_path ? sidecar_path : "-");
 148         try {
 149                 return new ExifData(path, sidecar_path);
 150         }
 151         catch (Exiv2::AnyError& e) {
 152                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 153                 return NULL;
 154         }
 155
 156 }
 157
 158 int exif_write(ExifData *exif)
 159 {
 160         try {
 161                 exif->writeMetadata();
 162                 return 1;
 163         }
 164         catch (Exiv2::AnyError& e) {
 165                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 166                 return 0;
 167         }
 168
 169 }
 170
 171
 172 void exif_free(ExifData *exif)
 173 {
 174
 175         delete exif;
 176 }
 177
 178 ExifItem *exif_get_item(ExifData *exif, const gchar *key)
 179 {
 180         try {
 181                 Exiv2::Metadatum *item = NULL;
 182                 try {
 183                         Exiv2::ExifKey ekey(key);
 184                         Exiv2::ExifData::iterator pos = exif->exifData().findKey(ekey);
 185                         if (pos == exif->exifData().end()) return NULL;
 186                         item = &*pos;
 187                 }
 188                 catch (Exiv2::AnyError& e) {
 189                         try {
 190                                 Exiv2::IptcKey ekey(key);
 191                                 Exiv2::IptcData::iterator pos = exif->iptcData().findKey(ekey);
 192                                 if (pos == exif->iptcData().end()) return NULL;
 193                                 item = &*pos;
 194                         }
 195                         catch (Exiv2::AnyError& e) {
 196 #if EXIV2_TEST_VERSION(0,16,0)
 197                                 Exiv2::XmpKey ekey(key);
 198                                 Exiv2::XmpData::iterator pos = exif->xmpData().findKey(ekey);
 199                                 if (pos == exif->xmpData().end()) return NULL;
 200                                 item = &*pos;
 201 #endif
 202                         }
 203                 }
 204                 return (ExifItem *)item;
 205         }
 206         catch (Exiv2::AnyError& e) {
 207                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 208                 return NULL;
 209         }
 210 }
 211
 212 ExifItem *exif_add_item(ExifData *exif, const gchar *key)
 213 {
 214         try {
 215                 Exiv2::Metadatum *item = NULL;
 216                 try {
 217                         Exiv2::ExifKey ekey(key);
 218                         exif->exifData().add(ekey, NULL);
 219                         Exiv2::ExifData::iterator pos = exif->exifData().end(); // a hack, there should be a better way to get the currently added item
 220                         pos--;
 221                         item = &*pos;
 222                 }
 223                 catch (Exiv2::AnyError& e) {
 224                         try {
 225                                 Exiv2::IptcKey ekey(key);
 226                                 exif->iptcData().add(ekey, NULL);
 227                                 Exiv2::IptcData::iterator pos = exif->iptcData().end();
 228                                 pos--;
 229                                 item = &*pos;
 230                         }
 231                         catch (Exiv2::AnyError& e) {
 232 #if EXIV2_TEST_VERSION(0,16,0)
 233                                 Exiv2::XmpKey ekey(key);
 234                                 exif->xmpData().add(ekey, NULL);
 235                                 Exiv2::XmpData::iterator pos = exif->xmpData().end();
 236                                 pos--;
 237                                 item = &*pos;
 238 #endif
 239                         }
 240                 }
 241                 return (ExifItem *)item;
 242         }
 243         catch (Exiv2::AnyError& e) {
 244                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 245                 return NULL;
 246         }
 247 }
 248
 249
 250 ExifItem *exif_get_first_item(ExifData *exif)
 251 {
 252         try {
 253                 exif->exifIter = exif->exifData().begin();
 254                 exif->iptcIter = exif->iptcData().begin();
 255 #if EXIV2_TEST_VERSION(0,16,0)
 256                 exif->xmpIter = exif->xmpData().begin();
 257 #endif
 258                 if (exif->exifIter != exif->exifData().end())
 259                         {
 260                         const Exiv2::Metadatum *item = &*exif->exifIter;
 261                         exif->exifIter++;
 262                         return (ExifItem *)item;
 263                         }
 264                 if (exif->iptcIter != exif->iptcData().end())
 265                         {
 266                         const Exiv2::Metadatum *item = &*exif->iptcIter;
 267                         exif->iptcIter++;
 268                         return (ExifItem *)item;
 269                         }
 270 #if EXIV2_TEST_VERSION(0,16,0)
 271                 if (exif->xmpIter != exif->xmpData().end())
 272                         {
 273                         const Exiv2::Metadatum *item = &*exif->xmpIter;
 274                         exif->xmpIter++;
 275                         return (ExifItem *)item;
 276                         }
 277 #endif
 278                 return NULL;
 279
 280         }
 281         catch (Exiv2::AnyError& e) {
 282                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 283                 return NULL;
 284         }
 285 }
 286
 287 ExifItem *exif_get_next_item(ExifData *exif)
 288 {
 289         try {
 290                 if (exif->exifIter != exif->exifData().end())
 291                         {
 292                         const Exiv2::Metadatum *item = &*exif->exifIter;
 293                         exif->exifIter++;
 294                         return (ExifItem *)item;
 295                 }
 296                 if (exif->iptcIter != exif->iptcData().end())
 297                         {
 298                         const Exiv2::Metadatum *item = &*exif->iptcIter;
 299                         exif->iptcIter++;
 300                         return (ExifItem *)item;
 301                 }
 302 #if EXIV2_TEST_VERSION(0,16,0)
 303                 if (exif->xmpIter != exif->xmpData().end())
 304                         {
 305                         const Exiv2::Metadatum *item = &*exif->xmpIter;
 306                         exif->xmpIter++;
 307                         return (ExifItem *)item;
 308                 }
 309 #endif
 310                 return NULL;
 311         }
 312         catch (Exiv2::AnyError& e) {
 313                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 314                 return NULL;
 315         }
 316 }
 317
 318 char *exif_item_get_tag_name(ExifItem *item)
 319 {
 320         try {
 321                 if (!item) return NULL;
 322                 return g_strdup(((Exiv2::Metadatum *)item)->key().c_str());
 323         }
 324         catch (Exiv2::AnyError& e) {
 325                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 326                 return NULL;
 327         }
 328 }
 329
 330 guint exif_item_get_tag_id(ExifItem *item)
 331 {
 332         try {
 333                 if (!item) return 0;
 334                 return ((Exiv2::Metadatum *)item)->tag();
 335         }
 336         catch (Exiv2::AnyError& e) {
 337                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 338                 return 0;
 339         }
 340 }
 341
 342 guint exif_item_get_elements(ExifItem *item)
 343 {
 344         try {
 345                 if (!item) return 0;
 346                 return ((Exiv2::Metadatum *)item)->count();
 347         }
 348         catch (Exiv2::AnyError& e) {
 349                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 350                 return 0;
 351         }
 352 }
 353
 354 char *exif_item_get_data(ExifItem *item, guint *data_len)
 355 {
 356         try {
 357                 if (!item) return 0;
 358                 Exiv2::Metadatum *md = (Exiv2::Metadatum *)item;
 359                 if (data_len) *data_len = md->size();
 360                 char *data = (char *)g_malloc(md->size());
 361                 long res = md->copy((Exiv2::byte *)data, Exiv2::littleEndian /* should not matter */);
 362                 g_assert(res == md->size());
 363                 return data;
 364         }
 365         catch (Exiv2::AnyError& e) {
 366                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 367                 return NULL;
 368         }
 369 }
 370
 371 char *exif_item_get_description(ExifItem *item)
 372 {
 373         try {
 374                 if (!item) return NULL;
 375                 return g_strdup(((Exiv2::Metadatum *)item)->tagLabel().c_str());
 376         }
 377         catch (std::exception& e) {
 378 //              std::cout << "Caught Exiv2 exception '" << e << "'\n";
 379                 return NULL;
 380         }
 381 }
 382
 383 /*
 384 invalidTypeId, unsignedByte, asciiString, unsignedShort,
 385   unsignedLong, unsignedRational, signedByte, undefined,
 386   signedShort, signedLong, signedRational, string,
 387   date, time, comment, directory,
 388   xmpText, xmpAlt, xmpBag, xmpSeq,
 389   langAlt, lastTypeId
 390 */
 391
 392 static guint format_id_trans_tbl [] = {
 393         EXIF_FORMAT_UNKNOWN,
 394         EXIF_FORMAT_BYTE_UNSIGNED,
 395         EXIF_FORMAT_STRING,
 396         EXIF_FORMAT_SHORT_UNSIGNED,
 397         EXIF_FORMAT_LONG_UNSIGNED,
 398         EXIF_FORMAT_RATIONAL_UNSIGNED,
 399         EXIF_FORMAT_BYTE,
 400         EXIF_FORMAT_UNDEFINED,
 401         EXIF_FORMAT_SHORT,
 402         EXIF_FORMAT_LONG,
 403         EXIF_FORMAT_RATIONAL,
 404         EXIF_FORMAT_STRING,
 405         EXIF_FORMAT_STRING,
 406         EXIF_FORMAT_STRING,
 407         EXIF_FORMAT_UNDEFINED,
 408         EXIF_FORMAT_STRING,
 409         EXIF_FORMAT_STRING,
 410         EXIF_FORMAT_STRING,
 411         EXIF_FORMAT_STRING
 412         };
 413
 414
 415
 416 guint exif_item_get_format_id(ExifItem *item)
 417 {
 418         try {
 419                 if (!item) return EXIF_FORMAT_UNKNOWN;
 420                 guint id = ((Exiv2::Metadatum *)item)->typeId();
 421                 if (id >= (sizeof(format_id_trans_tbl) / sizeof(format_id_trans_tbl[0])) ) return EXIF_FORMAT_UNKNOWN;
 422                 return format_id_trans_tbl[id];
 423         }
 424         catch (Exiv2::AnyError& e) {
 425                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 426                 return EXIF_FORMAT_UNKNOWN;
 427         }
 428 }
 429
 430 const char *exif_item_get_format_name(ExifItem *item, gint brief)
 431 {
 432         try {
 433                 if (!item) return NULL;
 434                 return ((Exiv2::Metadatum *)item)->typeName();
 435         }
 436         catch (Exiv2::AnyError& e) {
 437                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 438                 return NULL;
 439         }
 440 }
 441
 442
 443 gchar *exif_item_get_data_as_text(ExifItem *item)
 444 {
 445         try {
 446                 if (!item) return NULL;
 447                 Exiv2::Metadatum *metadatum = (Exiv2::Metadatum *)item;
 448 #if EXIV2_TEST_VERSION(0,17,0)
 449                 return g_strdup(metadatum->print().c_str());
 450 #else
 451                 std::stringstream str;
 452                 Exiv2::Exifdatum *exifdatum;
 453                 Exiv2::Iptcdatum *iptcdatum;
 454 #if EXIV2_TEST_VERSION(0,16,0)
 455                 Exiv2::Xmpdatum *xmpdatum;
 456 #endif
 457                 if ((exifdatum = dynamic_cast<Exiv2::Exifdatum *>(metadatum)))
 458                         str << *exifdatum;
 459                 else if ((iptcdatum = dynamic_cast<Exiv2::Iptcdatum *>(metadatum)))
 460                         str << *iptcdatum;
 461 #if EXIV2_TEST_VERSION(0,16,0)
 462                 else if ((xmpdatum = dynamic_cast<Exiv2::Xmpdatum *>(metadatum)))
 463                         str << *xmpdatum;
 464 #endif
 465
 466                 return g_strdup(str.str().c_str());
 467 #endif
 468         }
 469         catch (Exiv2::AnyError& e) {
 470                 return NULL;
 471         }
 472 }
 473
 474 gchar *exif_item_get_string(ExifItem *item, int idx)
 475 {
 476         try {
 477                 if (!item) return NULL;
 478                 Exiv2::Metadatum *em = (Exiv2::Metadatum *)item;
 479 #if EXIV2_TEST_VERSION(0,16,0)
 480                 std::string str = em->toString(idx);
 481 #else
 482                 std::string str = em->toString(); // FIXME
 483 #endif
 484                 if (idx == 0 && str == "") str = em->toString();
 485                 if (str.length() > 5 && str.substr(0, 5) == "lang=")
 486                         {
 487                         std::string::size_type pos = str.find_first_of(' ');
 488                         if (pos != std::string::npos) str = str.substr(pos+1);
 489                         }
 490
 491                 return g_strdup(str.c_str());
 492         }
 493         catch (Exiv2::AnyError& e) {
 494                 return NULL;
 495         }
 496 }
 497
 498
 499 gint exif_item_get_integer(ExifItem *item, gint *value)
 500 {
 501         try {
 502                 if (!item) return 0;
 503                 *value = ((Exiv2::Metadatum *)item)->toLong();
 504                 return 1;
 505         }
 506         catch (Exiv2::AnyError& e) {
 507                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 508                 return 0;
 509         }
 510 }
 511
 512 ExifRational *exif_item_get_rational(ExifItem *item, gint *sign)
 513 {
 514         try {
 515                 if (!item) return NULL;
 516                 Exiv2::Rational v = ((Exiv2::Metadatum *)item)->toRational();
 517                 static ExifRational ret;
 518                 ret.num = v.first;
 519                 ret.den = v.second;
 520                 if (sign) *sign = (((Exiv2::Metadatum *)item)->typeId() == Exiv2::signedRational);
 521                 return &ret;
 522         }
 523         catch (Exiv2::AnyError& e) {
 524                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 525                 return NULL;
 526         }
 527 }
 528
 529 const gchar *exif_get_tag_description_by_key(const gchar *key)
 530 {
 531         try {
 532                 Exiv2::ExifKey ekey(key);
 533                 return Exiv2::ExifTags::tagLabel(ekey.tag(), ekey.ifdId ());
 534         }
 535         catch (Exiv2::AnyError& e) {
 536                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 537                 return NULL;
 538         }
 539 }
 540
 541 int exif_item_set_string(ExifItem *item, const char *str)
 542 {
 543         try {
 544                 if (!item) return 0;
 545                 ((Exiv2::Metadatum *)item)->setValue(std::string(str));
 546                 return 1;
 547         }
 548         catch (Exiv2::AnyError& e) {
 549                 return 0;
 550         }
 551 }
 552
 553 int exif_item_delete(ExifData *exif, ExifItem *item)
 554 {
 555         try {
 556                 if (!item) return 0;
 557                 for (Exiv2::ExifData::iterator i = exif->exifData().begin(); i != exif->exifData().end(); ++i) {
 558                         if (((Exiv2::Metadatum *)item) == &*i) {
 559                                 i = exif->exifData().erase(i);
 560                                 return 1;
 561                         }
 562                 }
 563                 for (Exiv2::IptcData::iterator i = exif->iptcData().begin(); i != exif->iptcData().end(); ++i) {
 564                         if (((Exiv2::Metadatum *)item) == &*i) {
 565                                 i = exif->iptcData().erase(i);
 566                                 return 1;
 567                         }
 568                 }
 569 #if EXIV2_TEST_VERSION(0,16,0)
 570                 for (Exiv2::XmpData::iterator i = exif->xmpData().begin(); i != exif->xmpData().end(); ++i) {
 571                         if (((Exiv2::Metadatum *)item) == &*i) {
 572                                 i = exif->xmpData().erase(i);
 573                                 return 1;
 574                         }
 575                 }
 576 #endif
 577                 return 0;
 578         }
 579         catch (Exiv2::AnyError& e) {
 580                 return 0;
 581         }
 582 }
 583
 584 void exif_add_jpeg_color_profile(ExifData *exif, unsigned char *cp_data, guint cp_length)
 585 {
 586         if (exif->cp_data) g_free(exif->cp_data);
 587         exif->cp_data = cp_data;
 588         exif->cp_length =cp_length;
 589 }
 590
 591 unsigned char *exif_get_color_profile(ExifData *exif, guint *data_len)
 592 {
 593         if (exif->cp_data)
 594                 {
 595                 if (data_len) *data_len = exif->cp_length;
 596                 return (unsigned char *) g_memdup(exif->cp_data, exif->cp_length);
 597                 }
 598         ExifItem *prof_item = exif_get_item(exif, "Exif.Image.InterColorProfile");
 599         if (prof_item && exif_item_get_format_id(prof_item) == EXIF_FORMAT_UNDEFINED)
 600                 return (unsigned char *) exif_item_get_data(prof_item, data_len);
 601         return NULL;
 602 }
 603
 604
 605
 606 }
 607
 608 /* This is a dirty hack to support raw file preview, bassed on
 609 tiffparse.cpp from Exiv2 examples */
 610
 611 class RawFile {
 612         public:
 613
 614         RawFile(int fd);
 615         ~RawFile();
 616
 617         const Exiv2::Value *find(uint16_t tag, uint16_t group);
 618
 619         unsigned long preview_offset();
 620
 621         private:
 622         int type;
 623         Exiv2::TiffComponent::AutoPtr rootDir;
 624         Exiv2::byte *map_data;
 625         size_t map_len;
 626         unsigned long offset;
 627 };
 628
 629 using namespace Exiv2;
 630
 631 RawFile::RawFile(int fd) : map_data(NULL), map_len(0), offset(0)
 632 {
 633         struct stat st;
 634         if (fstat(fd, &st) == -1)
 635                 {
 636                 throw Error(14);
 637                 }
 638         map_len = st.st_size;
 639         map_data = (Exiv2::byte *) mmap(0, map_len, PROT_READ, MAP_PRIVATE, fd, 0);
 640         if (map_data == MAP_FAILED)
 641                 {
 642                 throw Error(14);
 643                 }
 644         type = Exiv2::ImageFactory::getType(map_data, map_len);
 645
 646 #if EXIV2_TEST_VERSION(0,16,0)
 647         TiffHeaderBase *tiffHeader = NULL;
 648 #else
 649         TiffHeade2 *tiffHeader = NULL;
 650 #endif
 651         Cr2Header *cr2Header = NULL;
 652
 653         switch (type) {
 654                 case Exiv2::ImageType::tiff:
 655                         tiffHeader = new TiffHeade2();
 656                         break;
 657                 case Exiv2::ImageType::cr2:
 658                         cr2Header = new Cr2Header();
 659                         break;
 660 #if EXIV2_TEST_VERSION(0,16,0)
 661                 case Exiv2::ImageType::orf:
 662                         tiffHeader = new OrfHeader();
 663                         break;
 664 #endif
 665 #if EXIV2_TEST_VERSION(0,13,0)
 666                 case Exiv2::ImageType::raf:
 667                         if (map_len < 84 + 4) throw Error(14);
 668                         offset = getULong(map_data + 84, bigEndian);
 669                         return;
 670 #endif
 671                 case Exiv2::ImageType::crw:
 672                         {
 673                         // Parse the image, starting with a CIFF header component
 674                         Exiv2::CiffHeader::AutoPtr parseTree(new Exiv2::CiffHeader);
 675                         parseTree->read(map_data, map_len);
 676                         CiffComponent *entry = parseTree->findComponent(0x2007, 0);
 677                         if (entry) offset =  entry->pData() - map_data;
 678                         return;
 679                         }
 680
 681                 default:
 682                         throw Error(3, "RAW");
 683         }
 684
 685         // process tiff-like formats
 686
 687         TiffCompFactoryFct createFct = TiffCreator::create;
 688
 689         rootDir = createFct(Tag::root, Group::none);
 690         if (0 == rootDir.get()) {
 691                 throw Error(1, "No root element defined in TIFF structure");
 692         }
 693
 694         if (tiffHeader)
 695                 {
 696                 if (!tiffHeader->read(map_data, map_len)) throw Error(3, "TIFF");
 697 #if EXIV2_TEST_VERSION(0,16,0)
 698                 rootDir->setStart(map_data + tiffHeader->offset());
 699 #else
 700                 rootDir->setStart(map_data + tiffHeader->ifdOffset());
 701 #endif
 702                 }
 703
 704         if (cr2Header)
 705                 {
 706                 rootDir->setStart(map_data + cr2Header->offset());
 707                 }
 708
 709         TiffRwState::AutoPtr state(new TiffRwState(tiffHeader ? tiffHeader->byteOrder() : littleEndian, 0, createFct));
 710
 711         TiffReader reader(map_data,
 712                       map_len,
 713                       rootDir.get(),
 714                       state);
 715
 716         rootDir->accept(reader);
 717
 718         if (tiffHeader)
 719                 delete tiffHeader;
 720         if (cr2Header)
 721                 delete cr2Header;
 722 }
 723
 724 RawFile::~RawFile(void)
 725 {
 726         if (map_data && munmap(map_data, map_len) == -1)
 727                 {
 728                 log_printf("Failed to unmap file \n");
 729                 }
 730 }
 731
 732 const Value * RawFile::find(uint16_t tag, uint16_t group)
 733 {
 734         TiffFinder finder(tag, group);
 735         rootDir->accept(finder);
 736         TiffEntryBase* te = dynamic_cast<TiffEntryBase*>(finder.result());
 737         if (te)
 738                 {
 739                 DEBUG_1("(tag: %04x %04x) ", tag, group);
 740                 return te->pValue();
 741                 }
 742         else
 743                 return NULL;
 744 }
 745
 746 unsigned long RawFile::preview_offset(void)
 747 {
 748         const Value *val;
 749         if (offset) return offset;
 750
 751         if (type == Exiv2::ImageType::cr2)
 752                 {
 753                 val = find(0x111, Group::ifd0);
 754                 if (val) return val->toLong();
 755
 756                 return 0;
 757                 }
 758
 759         val = find(0x201, Group::sub0_0);
 760         if (val) return val->toLong();
 761
 762         val = find(0x201, Group::ifd0);
 763         if (val) return val->toLong();
 764
 765         val = find(0x201, Group::ignr); // for PEF files, originally it was probably ifd2
 766         if (val) return val->toLong();
 767
 768         val = find(0x111, Group::sub0_1); // dng
 769         if (val) return val->toLong();
 770
 771         return 0;
 772 }
 773
 774
 775 extern "C" gint format_raw_img_exif_offsets_fd(int fd, const gchar *path,
 776                                     unsigned char *header_data, const guint header_len,
 777                                     guint *image_offset, guint *exif_offset)
 778 {
 779         int success;
 780         unsigned long offset;
 781
 782         /* given image pathname, first do simple (and fast) file extension test */
 783         if (!filter_file_class(path, FORMAT_CLASS_RAWIMAGE)) return 0;
 784
 785         try {
 786                 RawFile rf(fd);
 787                 offset = rf.preview_offset();
 788                 DEBUG_1("%s: offset %lu", path, offset);
 789         }
 790         catch (Exiv2::AnyError& e) {
 791                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 792                 return 0;
 793         }
 794
 795         if (image_offset && offset > 0)
 796                 {
 797                 *image_offset = offset;
 798                 if ((unsigned long) lseek(fd, *image_offset, SEEK_SET) != *image_offset)
 799                         {
 800                         log_printf("Failed to seek to embedded image\n");
 801
 802                         *image_offset = 0;
 803                         if (*exif_offset) *exif_offset = 0;
 804                         success = FALSE;
 805                         }
 806                 }
 807
 808         return offset > 0;
 809 }
 810
 811
 812 #endif
 813 /* HAVE_EXIV2 */