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