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 #ifdef HAVE_CONFIG_H
  13 #  include "config.h"
  14 #endif
  15
  16 #ifdef HAVE_EXIV2
  17
  18 #include <exiv2/image.hpp>
  19 #include <exiv2/exif.hpp>
  20 #include <iostream>
  21
  22 // EXIV2_TEST_VERSION is defined in Exiv2 0.15 and newer.
  23 #ifndef EXIV2_TEST_VERSION
  24 # define EXIV2_TEST_VERSION(major,minor,patch) \
  25         ( EXIV2_VERSION >= EXIV2_MAKE_VERSION(major,minor,patch) )
  26 #endif
  27
  28
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <unistd.h>
  32 #include <fcntl.h>
  33 #include <sys/mman.h>
  34
  35 #include <exiv2/tiffparser.hpp>
  36 #include <exiv2/tiffcomposite.hpp>
  37 #include <exiv2/tiffvisitor.hpp>
  38 #include <exiv2/tiffimage.hpp>
  39 #include <exiv2/cr2image.hpp>
  40 #include <exiv2/crwimage.hpp>
  41 #if EXIV2_TEST_VERSION(0,16,0)
  42 #include <exiv2/orfimage.hpp>
  43 #endif
  44 #if EXIV2_TEST_VERSION(0,13,0)
  45 #include <exiv2/rafimage.hpp>
  46 #endif
  47 #include <exiv2/futils.hpp>
  48
  49
  50
  51 extern "C" {
  52 #include <glib.h>
  53
  54 #include "main.h"
  55 #include "exif.h"
  56
  57 #include "filefilter.h"
  58 #include "ui_fileops.h"
  59 }
  60
  61 struct _ExifData
  62 {
  63         Exiv2::Image::AutoPtr image;
  64         Exiv2::Image::AutoPtr sidecar;
  65         Exiv2::ExifData::const_iterator exifIter; /* for exif_get_next_item */
  66         Exiv2::IptcData::const_iterator iptcIter; /* for exif_get_next_item */
  67 #if EXIV2_TEST_VERSION(0,16,0)
  68         Exiv2::XmpData::const_iterator xmpIter; /* for exif_get_next_item */
  69 #endif
  70         bool have_sidecar;
  71
  72         /* the icc profile in jpeg is not technically exif - store it here */
  73         unsigned char *cp_data;
  74         guint cp_length;
  75
  76         _ExifData(gchar *path, gchar *sidecar_path)
  77         {
  78                 have_sidecar = false;
  79                 cp_data = NULL;
  80                 cp_length = 0;
  81                 gchar *pathl = path_from_utf8(path);
  82                 image = Exiv2::ImageFactory::open(pathl);
  83                 g_free(pathl);
  84 //              g_assert (image.get() != 0);
  85                 image->readMetadata();
  86
  87 #if EXIV2_TEST_VERSION(0,16,0)
  88                 DEBUG_2("xmp count %li", image->xmpData().count());
  89                 if (sidecar_path && image->xmpData().empty())
  90                         {
  91                         gchar *sidecar_pathl = path_from_utf8(sidecar_path);
  92                         sidecar = Exiv2::ImageFactory::open(sidecar_pathl);
  93                         g_free(sidecar_pathl);
  94                         sidecar->readMetadata();
  95                         have_sidecar = sidecar->good();
  96                         DEBUG_2("sidecar xmp count %li", sidecar->xmpData().count());
  97                         }
  98
  99 #endif
 100 #if EXIV2_TEST_VERSION(0,14,0)
 101                 if (image->mimeType() == std::string("image/jpeg"))
 102                         {
 103                         /* try to get jpeg color profile */
 104                         Exiv2::BasicIo &io = image->io();
 105                         gint open = io.isopen();
 106                         if (!open) io.open();
 107                         unsigned char *mapped = (unsigned char*)io.mmap();
 108                         if (mapped) exif_jpeg_parse_color(this, mapped, io.size());
 109                         io.munmap();
 110                         if (!open) io.close();
 111                         }
 112 #endif
 113         }
 114
 115         ~_ExifData()
 116         {
 117                 if (cp_data) g_free(cp_data);
 118         }
 119
 120         void writeMetadata()
 121         {
 122                 if (have_sidecar) sidecar->writeMetadata();
 123                 image->writeMetadata();
 124         }
 125
 126         Exiv2::ExifData &exifData ()
 127         {
 128                 return image->exifData();
 129         }
 130
 131         Exiv2::IptcData &iptcData ()
 132         {
 133                 return image->iptcData();
 134         }
 135
 136 #if EXIV2_TEST_VERSION(0,16,0)
 137         Exiv2::XmpData &xmpData ()
 138         {
 139                 return have_sidecar ? sidecar->xmpData() : image->xmpData();
 140         }
 141 #endif
 142
 143 };
 144
 145 extern "C" {
 146
 147 ExifData *exif_read(gchar *path, gchar *sidecar_path)
 148 {
 149         DEBUG_1("exif read %s, sidecar: %s", path, sidecar_path ? sidecar_path : "-");
 150         try {
 151                 return new ExifData(path, sidecar_path);
 152         }
 153         catch (Exiv2::AnyError& e) {
 154                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 155                 return NULL;
 156         }
 157
 158 }
 159
 160 int exif_write(ExifData *exif)
 161 {
 162         try {
 163                 exif->writeMetadata();
 164                 return 1;
 165         }
 166         catch (Exiv2::AnyError& e) {
 167                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 168                 return 0;
 169         }
 170
 171 }
 172
 173
 174 void exif_free(ExifData *exif)
 175 {
 176
 177         delete exif;
 178 }
 179
 180 ExifItem *exif_get_item(ExifData *exif, const gchar *key)
 181 {
 182         try {
 183                 Exiv2::Metadatum *item = NULL;
 184                 try {
 185                         Exiv2::ExifKey ekey(key);
 186                         Exiv2::ExifData::iterator pos = exif->exifData().findKey(ekey);
 187                         if (pos == exif->exifData().end()) return NULL;
 188                         item = &*pos;
 189                 }
 190                 catch (Exiv2::AnyError& e) {
 191                         try {
 192                                 Exiv2::IptcKey ekey(key);
 193                                 Exiv2::IptcData::iterator pos = exif->iptcData().findKey(ekey);
 194                                 if (pos == exif->iptcData().end()) return NULL;
 195                                 item = &*pos;
 196                         }
 197                         catch (Exiv2::AnyError& e) {
 198 #if EXIV2_TEST_VERSION(0,16,0)
 199                                 Exiv2::XmpKey ekey(key);
 200                                 Exiv2::XmpData::iterator pos = exif->xmpData().findKey(ekey);
 201                                 if (pos == exif->xmpData().end()) return NULL;
 202                                 item = &*pos;
 203 #endif
 204                         }
 205                 }
 206                 return (ExifItem *)item;
 207         }
 208         catch (Exiv2::AnyError& e) {
 209                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 210                 return NULL;
 211         }
 212 }
 213
 214 ExifItem *exif_add_item(ExifData *exif, const gchar *key)
 215 {
 216         try {
 217                 Exiv2::Metadatum *item = NULL;
 218                 try {
 219                         Exiv2::ExifKey ekey(key);
 220                         exif->exifData().add(ekey, NULL);
 221                         Exiv2::ExifData::iterator pos = exif->exifData().end(); // a hack, there should be a better way to get the currently added item
 222                         pos--;
 223                         item = &*pos;
 224                 }
 225                 catch (Exiv2::AnyError& e) {
 226                         try {
 227                                 Exiv2::IptcKey ekey(key);
 228                                 exif->iptcData().add(ekey, NULL);
 229                                 Exiv2::IptcData::iterator pos = exif->iptcData().end();
 230                                 pos--;
 231                                 item = &*pos;
 232                         }
 233                         catch (Exiv2::AnyError& e) {
 234 #if EXIV2_TEST_VERSION(0,16,0)
 235                                 Exiv2::XmpKey ekey(key);
 236                                 exif->xmpData().add(ekey, NULL);
 237                                 Exiv2::XmpData::iterator pos = exif->xmpData().end();
 238                                 pos--;
 239                                 item = &*pos;
 240 #endif
 241                         }
 242                 }
 243                 return (ExifItem *)item;
 244         }
 245         catch (Exiv2::AnyError& e) {
 246                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 247                 return NULL;
 248         }
 249 }
 250
 251
 252 ExifItem *exif_get_first_item(ExifData *exif)
 253 {
 254         try {
 255                 exif->exifIter = exif->exifData().begin();
 256                 exif->iptcIter = exif->iptcData().begin();
 257 #if EXIV2_TEST_VERSION(0,16,0)
 258                 exif->xmpIter = exif->xmpData().begin();
 259 #endif
 260                 if (exif->exifIter != exif->exifData().end())
 261                         {
 262                         const Exiv2::Metadatum *item = &*exif->exifIter;
 263                         exif->exifIter++;
 264                         return (ExifItem *)item;
 265                         }
 266                 if (exif->iptcIter != exif->iptcData().end())
 267                         {
 268                         const Exiv2::Metadatum *item = &*exif->iptcIter;
 269                         exif->iptcIter++;
 270                         return (ExifItem *)item;
 271                         }
 272 #if EXIV2_TEST_VERSION(0,16,0)
 273                 if (exif->xmpIter != exif->xmpData().end())
 274                         {
 275                         const Exiv2::Metadatum *item = &*exif->xmpIter;
 276                         exif->xmpIter++;
 277                         return (ExifItem *)item;
 278                         }
 279 #endif
 280                 return NULL;
 281
 282         }
 283         catch (Exiv2::AnyError& e) {
 284                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 285                 return NULL;
 286         }
 287 }
 288
 289 ExifItem *exif_get_next_item(ExifData *exif)
 290 {
 291         try {
 292                 if (exif->exifIter != exif->exifData().end())
 293                         {
 294                         const Exiv2::Metadatum *item = &*exif->exifIter;
 295                         exif->exifIter++;
 296                         return (ExifItem *)item;
 297                 }
 298                 if (exif->iptcIter != exif->iptcData().end())
 299                         {
 300                         const Exiv2::Metadatum *item = &*exif->iptcIter;
 301                         exif->iptcIter++;
 302                         return (ExifItem *)item;
 303                 }
 304 #if EXIV2_TEST_VERSION(0,16,0)
 305                 if (exif->xmpIter != exif->xmpData().end())
 306                         {
 307                         const Exiv2::Metadatum *item = &*exif->xmpIter;
 308                         exif->xmpIter++;
 309                         return (ExifItem *)item;
 310                 }
 311 #endif
 312                 return NULL;
 313         }
 314         catch (Exiv2::AnyError& e) {
 315                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 316                 return NULL;
 317         }
 318 }
 319
 320 char *exif_item_get_tag_name(ExifItem *item)
 321 {
 322         try {
 323                 if (!item) return NULL;
 324                 return g_strdup(((Exiv2::Metadatum *)item)->key().c_str());
 325         }
 326         catch (Exiv2::AnyError& e) {
 327                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 328                 return NULL;
 329         }
 330 }
 331
 332 guint exif_item_get_tag_id(ExifItem *item)
 333 {
 334         try {
 335                 if (!item) return 0;
 336                 return ((Exiv2::Metadatum *)item)->tag();
 337         }
 338         catch (Exiv2::AnyError& e) {
 339                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 340                 return 0;
 341         }
 342 }
 343
 344 guint exif_item_get_elements(ExifItem *item)
 345 {
 346         try {
 347                 if (!item) return 0;
 348                 return ((Exiv2::Metadatum *)item)->count();
 349         }
 350         catch (Exiv2::AnyError& e) {
 351                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 352                 return 0;
 353         }
 354 }
 355
 356 char *exif_item_get_data(ExifItem *item, guint *data_len)
 357 {
 358         try {
 359                 if (!item) return 0;
 360                 Exiv2::Metadatum *md = (Exiv2::Metadatum *)item;
 361                 if(data_len) *data_len = md->size();
 362                 char *data = (char *)g_malloc(md->size());
 363                 long res = md->copy((Exiv2::byte *)data, Exiv2::littleEndian /* should not matter */);
 364                 g_assert(res == md->size());
 365                 return data;
 366         }
 367         catch (Exiv2::AnyError& e) {
 368                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 369                 return NULL;
 370         }
 371 }
 372
 373 char *exif_item_get_description(ExifItem *item)
 374 {
 375         try {
 376                 if (!item) return NULL;
 377                 return g_strdup(((Exiv2::Metadatum *)item)->tagLabel().c_str());
 378         }
 379         catch (std::exception& e) {
 380 //              std::cout << "Caught Exiv2 exception '" << e << "'\n";
 381                 return NULL;
 382         }
 383 }
 384
 385 /*
 386 invalidTypeId, unsignedByte, asciiString, unsignedShort,
 387   unsignedLong, unsignedRational, signedByte, undefined,
 388   signedShort, signedLong, signedRational, string,
 389   date, time, comment, directory,
 390   xmpText, xmpAlt, xmpBag, xmpSeq,
 391   langAlt, lastTypeId
 392 */
 393
 394 static guint format_id_trans_tbl [] = {
 395         EXIF_FORMAT_UNKNOWN,
 396         EXIF_FORMAT_BYTE_UNSIGNED,
 397         EXIF_FORMAT_STRING,
 398         EXIF_FORMAT_SHORT_UNSIGNED,
 399         EXIF_FORMAT_LONG_UNSIGNED,
 400         EXIF_FORMAT_RATIONAL_UNSIGNED,
 401         EXIF_FORMAT_BYTE,
 402         EXIF_FORMAT_UNDEFINED,
 403         EXIF_FORMAT_SHORT,
 404         EXIF_FORMAT_LONG,
 405         EXIF_FORMAT_RATIONAL,
 406         EXIF_FORMAT_STRING,
 407         EXIF_FORMAT_STRING,
 408         EXIF_FORMAT_STRING,
 409         EXIF_FORMAT_UNDEFINED,
 410         EXIF_FORMAT_STRING,
 411         EXIF_FORMAT_STRING,
 412         EXIF_FORMAT_STRING,
 413         EXIF_FORMAT_STRING
 414         };
 415
 416
 417
 418 guint exif_item_get_format_id(ExifItem *item)
 419 {
 420         try {
 421                 if (!item) return EXIF_FORMAT_UNKNOWN;
 422                 guint id = ((Exiv2::Metadatum *)item)->typeId();
 423                 if (id >= (sizeof(format_id_trans_tbl) / sizeof(format_id_trans_tbl[0])) ) return EXIF_FORMAT_UNKNOWN;
 424                 return format_id_trans_tbl[id];
 425         }
 426         catch (Exiv2::AnyError& e) {
 427                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 428                 return EXIF_FORMAT_UNKNOWN;
 429         }
 430 }
 431
 432 const char *exif_item_get_format_name(ExifItem *item, gint brief)
 433 {
 434         try {
 435                 if (!item) return NULL;
 436                 return ((Exiv2::Metadatum *)item)->typeName();
 437         }
 438         catch (Exiv2::AnyError& e) {
 439                 std::cout << "Caught Exiv2 exception '" << e << "'\n";
 440                 return NULL;
 441         }
 442 }
 443
 444
 445 gchar *exif_item_get_data_as_text(ExifItem *item)
 446 {
 447         try {
 448                 if (!item) return NULL;
 449                 Exiv2::Metadatum *metadatum = (Exiv2::Metadatum *)item;
 450 #if EXIV2_TEST_VERSION(0,16,0)
 451                 return g_strdup(metadatum->print().c_str());
 452 #else
 453                 std::stringstream str;
 454                 Exiv2::Exifdatum *exifdatum;
 455                 Exiv2::Iptcdatum *iptcdatum;
 456                 Exiv2::Xmpdatum *xmpdatum;
 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 */