annotate src/exiv2.cc @ 1572:df4e69170f2b

compilation fixes
author nadvornik
date Mon, 27 Apr 2009 21:39:56 +0000
parents 6fdb447d87b7
children 7f9a99258d13
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
475
48c8e49b571c updated copyright in source files
nadvornik
parents: 452
diff changeset
1 /*
48c8e49b571c updated copyright in source files
nadvornik
parents: 452
diff changeset
2 * Geeqie
1284
8b89e3ff286b Add year 2009 to copyright info everywhere.
zas_
parents: 1245
diff changeset
3 * Copyright (C) 2008 - 2009 The Geeqie Team
475
48c8e49b571c updated copyright in source files
nadvornik
parents: 452
diff changeset
4 *
48c8e49b571c updated copyright in source files
nadvornik
parents: 452
diff changeset
5 * Author: Vladimir Nadvornik
48c8e49b571c updated copyright in source files
nadvornik
parents: 452
diff changeset
6 *
48c8e49b571c updated copyright in source files
nadvornik
parents: 452
diff changeset
7 * This software is released under the GNU General Public License (GNU GPL).
48c8e49b571c updated copyright in source files
nadvornik
parents: 452
diff changeset
8 * Please read the included file COPYING for more information.
48c8e49b571c updated copyright in source files
nadvornik
parents: 452
diff changeset
9 * This software comes with no warranty of any kind, use at your own risk!
48c8e49b571c updated copyright in source files
nadvornik
parents: 452
diff changeset
10 */
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
11
686
c0dda0ffb931 configure.in was rewritten:
bruclik
parents: 677
diff changeset
12 #include "config.h"
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
13
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
14 #ifdef HAVE_EXIV2
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
15
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
16 #include <exiv2/image.hpp>
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
17 #include <exiv2/exif.hpp>
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
18 #include <iostream>
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
19
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
20 // EXIV2_TEST_VERSION is defined in Exiv2 0.15 and newer.
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
21 #ifndef EXIV2_TEST_VERSION
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
22 # define EXIV2_TEST_VERSION(major,minor,patch) \
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
23 ( EXIV2_VERSION >= EXIV2_MAKE_VERSION(major,minor,patch) )
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
24 #endif
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
25
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
26
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
27 #include <sys/types.h>
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
28 #include <sys/stat.h>
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
29 #include <unistd.h>
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
30 #include <fcntl.h>
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
31 #include <sys/mman.h>
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
32
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
33 #if !EXIV2_TEST_VERSION(0,17,90)
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
34 #include <exiv2/tiffparser.hpp>
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
35 #include <exiv2/tiffcomposite.hpp>
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
36 #include <exiv2/tiffvisitor.hpp>
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
37 #include <exiv2/tiffimage.hpp>
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
38 #include <exiv2/cr2image.hpp>
191
19df9953a5d1 crw preview support with exiv2
nadvornik
parents: 188
diff changeset
39 #include <exiv2/crwimage.hpp>
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
40 #if EXIV2_TEST_VERSION(0,16,0)
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
41 #include <exiv2/orfimage.hpp>
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
42 #endif
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
43 #if EXIV2_TEST_VERSION(0,13,0)
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
44 #include <exiv2/rafimage.hpp>
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
45 #endif
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
46 #include <exiv2/futils.hpp>
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
47 #else
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
48 #include <exiv2/preview.hpp>
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
49 #endif
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
50
1070
abf48b53216b simple synchronization XMP <-> Exif, IPTC
nadvornik
parents: 1069
diff changeset
51 #if EXIV2_TEST_VERSION(0,17,0)
abf48b53216b simple synchronization XMP <-> Exif, IPTC
nadvornik
parents: 1069
diff changeset
52 #include <exiv2/convert.hpp>
1071
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
53 #include <exiv2/xmpsidecar.hpp>
1070
abf48b53216b simple synchronization XMP <-> Exif, IPTC
nadvornik
parents: 1069
diff changeset
54 #endif
abf48b53216b simple synchronization XMP <-> Exif, IPTC
nadvornik
parents: 1069
diff changeset
55
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
56 extern "C" {
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
57 #include <glib.h>
507
135570a8bd96 Move debug macros from main.h to new debug.h.
zas_
parents: 506
diff changeset
58
281
9995c5fb202a gqview.h -> main.h
zas_
parents: 212
diff changeset
59 #include "main.h"
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
60 #include "exif.h"
507
135570a8bd96 Move debug macros from main.h to new debug.h.
zas_
parents: 506
diff changeset
61
586
905688aa2317 split filelist.c to filefilter.c and filedata.c
nadvornik
parents: 507
diff changeset
62 #include "filefilter.h"
496
a1f13fab6686 fixed a bug in opening files with non-utf8 locales in exiv2.cc
nadvornik
parents: 495
diff changeset
63 #include "ui_fileops.h"
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
64
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
65 #include "misc.h"
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
66 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
67
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
68 typedef struct _AltKey AltKey;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
69
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
70 struct _AltKey
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
71 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
72 const gchar *xmp_key;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
73 const gchar *exif_key;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
74 const gchar *iptc_key;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
75 };
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
76
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
77 /* this is a list of keys that should be converted, even with the older Exiv2 which does not support it directly */
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
78 static const AltKey alt_keys[] = {
1460
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
79 {"Xmp.tiff.Orientation", "Exif.Image.Orientation", NULL},
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
80 {"Xmp.dc.title", NULL, "Iptc.Application2.ObjectName" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
81 {"Xmp.photoshop.Urgency", NULL, "Iptc.Application2.Urgency" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
82 {"Xmp.photoshop.Category", NULL, "Iptc.Application2.Category" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
83 {"Xmp.photoshop.SupplementalCategory", NULL, "Iptc.Application2.SuppCategory" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
84 {"Xmp.dc.subject", NULL, "Iptc.Application2.Keywords" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
85 {"Xmp.iptc.Location", NULL, "Iptc.Application2.LocationName" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
86 {"Xmp.photoshop.Instruction", NULL, "Iptc.Application2.SpecialInstructions" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
87 {"Xmp.photoshop.DateCreated", NULL, "Iptc.Application2.DateCreated" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
88 {"Xmp.dc.creator", NULL, "Iptc.Application2.Byline" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
89 {"Xmp.photoshop.AuthorsPosition", NULL, "Iptc.Application2.BylineTitle" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
90 {"Xmp.photoshop.City", NULL, "Iptc.Application2.City" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
91 {"Xmp.photoshop.State", NULL, "Iptc.Application2.ProvinceState" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
92 {"Xmp.iptc.CountryCode", NULL, "Iptc.Application2.CountryCode" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
93 {"Xmp.photoshop.Country", NULL, "Iptc.Application2.CountryName" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
94 {"Xmp.photoshop.TransmissionReference", NULL, "Iptc.Application2.TransmissionReference"},
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
95 {"Xmp.photoshop.Headline", NULL, "Iptc.Application2.Headline" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
96 {"Xmp.photoshop.Credit", NULL, "Iptc.Application2.Credit" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
97 {"Xmp.photoshop.Source", NULL, "Iptc.Application2.Source" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
98 {"Xmp.dc.rights", NULL, "Iptc.Application2.Copyright" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
99 {"Xmp.dc.description", NULL, "Iptc.Application2.Caption" },
8178ef34d257 added more IPTC tags
nadvornik
parents: 1442
diff changeset
100 {"Xmp.photoshop.CaptionWriter", NULL, "Iptc.Application2.Writer" },
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
101 {NULL, NULL, NULL}
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
102 };
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
103
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
104 static void debug_exception(Exiv2::AnyError& e)
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
105 {
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
106 gchar *str = g_locale_from_utf8(e.what(), -1, NULL, NULL, NULL);
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
107 DEBUG_1("Exiv2: %s", str);
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
108 g_free(str);
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
109 }
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
110
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
111 struct _ExifData
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
112 {
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
113 Exiv2::ExifData::const_iterator exifIter; /* for exif_get_next_item */
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
114 Exiv2::IptcData::const_iterator iptcIter; /* for exif_get_next_item */
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
115 #if EXIV2_TEST_VERSION(0,16,0)
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
116 Exiv2::XmpData::const_iterator xmpIter; /* for exif_get_next_item */
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
117 #endif
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
118
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
119 virtual ~_ExifData()
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
120 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
121 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
122
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
123 virtual void writeMetadata(gchar *path = NULL)
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
124 {
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
125 g_critical("Unsupported method of writing metadata");
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
126 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
127
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
128 virtual ExifData *original()
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
129 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
130 return NULL;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
131 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
132
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
133 virtual Exiv2::Image *image() = 0;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
134
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
135 virtual Exiv2::ExifData &exifData() = 0;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
136
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
137 virtual Exiv2::IptcData &iptcData() = 0;
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
138
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
139 #if EXIV2_TEST_VERSION(0,16,0)
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
140 virtual Exiv2::XmpData &xmpData() = 0;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
141 #endif
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
142
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
143 virtual void add_jpeg_color_profile(unsigned char *cp_data, guint cp_length) = 0;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
144
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
145 virtual guchar *get_jpeg_color_profile(guint *data_len) = 0;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
146 };
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
147
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
148 // This allows read-only access to the original metadata
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
149 struct _ExifDataOriginal : public _ExifData
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
150 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
151 protected:
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
152 Exiv2::Image::AutoPtr image_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
153
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
154 /* the icc profile in jpeg is not technically exif - store it here */
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
155 unsigned char *cp_data_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
156 guint cp_length_;
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
157 gboolean valid_;
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
158
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
159 Exiv2::ExifData emptyExifData_;
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
160 Exiv2::IptcData emptyIptcData_;
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
161 #if EXIV2_TEST_VERSION(0,16,0)
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
162 Exiv2::XmpData emptyXmpData_;
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
163 #endif
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
164
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
165 public:
1071
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
166 _ExifDataOriginal(Exiv2::Image::AutoPtr image)
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
167 {
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
168 cp_data_ = NULL;
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
169 cp_length_ = 0;
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
170 image_ = image;
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
171 valid_ = TRUE;
1071
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
172 }
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
173
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
174 _ExifDataOriginal(gchar *path)
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
175 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
176 cp_data_ = NULL;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
177 cp_length_ = 0;
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
178 valid_ = TRUE;
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
179
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
180 gchar *pathl = path_from_utf8(path);
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
181 try
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
182 {
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
183 image_ = Exiv2::ImageFactory::open(pathl);
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
184 // g_assert (image.get() != 0);
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
185 image_->readMetadata();
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
186
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
187 #if EXIV2_TEST_VERSION(0,16,0)
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
188 if (image_->mimeType() == "application/rdf+xml")
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
189 {
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
190 //Exiv2 sidecar converts xmp to exif and iptc, we don't want it.
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
191 image_->clearExifData();
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
192 image_->clearIptcData();
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
193 }
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
194 #endif
449
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
195
452
0a69a779395a fixed color profile code for older versions of exiv2
nadvornik
parents: 449
diff changeset
196 #if EXIV2_TEST_VERSION(0,14,0)
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
197 if (image_->mimeType() == "image/jpeg")
1196
4fe35e07308d handle the case when io.open() fails
nadvornik
parents: 1072
diff changeset
198 {
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
199 /* try to get jpeg color profile */
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
200 Exiv2::BasicIo &io = image_->io();
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
201 gint open = io.isopen();
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
202 if (!open) io.open();
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
203 if (io.isopen())
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
204 {
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
205 unsigned char *mapped = (unsigned char*)io.mmap();
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
206 if (mapped) exif_jpeg_parse_color(this, mapped, io.size());
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
207 io.munmap();
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
208 }
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
209 if (!open) io.close();
1196
4fe35e07308d handle the case when io.open() fails
nadvornik
parents: 1072
diff changeset
210 }
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
211 #endif
449
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
212 }
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
213 catch (Exiv2::AnyError& e)
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
214 {
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
215 valid_ = FALSE;
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
216 }
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
217 g_free(pathl);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
218 }
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
219
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
220 virtual ~_ExifDataOriginal()
449
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
221 {
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
222 if (cp_data_) g_free(cp_data_);
449
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
223 }
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
224
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
225 virtual Exiv2::Image *image()
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
226 {
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
227 if (!valid_) return NULL;
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
228 return image_.get();
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
229 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
230
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
231 virtual Exiv2::ExifData &exifData ()
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
232 {
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
233 if (!valid_) return emptyExifData_;
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
234 return image_->exifData();
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
235 }
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
236
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
237 virtual Exiv2::IptcData &iptcData ()
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
238 {
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
239 if (!valid_) return emptyIptcData_;
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
240 return image_->iptcData();
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
241 }
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
242
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
243 #if EXIV2_TEST_VERSION(0,16,0)
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
244 virtual Exiv2::XmpData &xmpData ()
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
245 {
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
246 if (!valid_) return emptyXmpData_;
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
247 return image_->xmpData();
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
248 }
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
249 #endif
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
250
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
251 virtual void add_jpeg_color_profile(unsigned char *cp_data, guint cp_length)
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
252 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
253 if (cp_data_) g_free(cp_data_);
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
254 cp_data_ = cp_data;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
255 cp_length_ = cp_length;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
256 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
257
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
258 virtual guchar *get_jpeg_color_profile(guint *data_len)
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
259 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
260 if (cp_data_)
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
261 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
262 if (data_len) *data_len = cp_length_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
263 return (unsigned char *) g_memdup(cp_data_, cp_length_);
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
264 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
265 return NULL;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
266 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
267 };
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
268
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
269 extern "C" {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
270 static void _ExifDataProcessed_update_xmp(gpointer key, gpointer value, gpointer data);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
271 }
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
272
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
273 // This allows read-write access to the metadata
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
274 struct _ExifDataProcessed : public _ExifData
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
275 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
276 protected:
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
277 _ExifDataOriginal *imageData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
278 _ExifDataOriginal *sidecarData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
279
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
280 Exiv2::ExifData exifData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
281 Exiv2::IptcData iptcData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
282 #if EXIV2_TEST_VERSION(0,16,0)
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
283 Exiv2::XmpData xmpData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
284 #endif
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
285
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
286 public:
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
287 _ExifDataProcessed(gchar *path, gchar *sidecar_path, GHashTable *modified_xmp)
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
288 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
289 imageData_ = new _ExifDataOriginal(path);
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
290 sidecarData_ = NULL;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
291 #if EXIV2_TEST_VERSION(0,16,0)
1224
ebfd305d902e improved sidecar writting
nadvornik
parents: 1211
diff changeset
292 if (sidecar_path)
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
293 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
294 sidecarData_ = new _ExifDataOriginal(sidecar_path);
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
295 xmpData_ = sidecarData_->xmpData();
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
296 }
1224
ebfd305d902e improved sidecar writting
nadvornik
parents: 1211
diff changeset
297 else
ebfd305d902e improved sidecar writting
nadvornik
parents: 1211
diff changeset
298 {
ebfd305d902e improved sidecar writting
nadvornik
parents: 1211
diff changeset
299 xmpData_ = imageData_->xmpData();
ebfd305d902e improved sidecar writting
nadvornik
parents: 1211
diff changeset
300 }
ebfd305d902e improved sidecar writting
nadvornik
parents: 1211
diff changeset
301
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
302 #endif
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
303 exifData_ = imageData_->exifData();
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
304 iptcData_ = imageData_->iptcData();
1070
abf48b53216b simple synchronization XMP <-> Exif, IPTC
nadvornik
parents: 1069
diff changeset
305 #if EXIV2_TEST_VERSION(0,17,0)
abf48b53216b simple synchronization XMP <-> Exif, IPTC
nadvornik
parents: 1069
diff changeset
306 syncExifWithXmp(exifData_, xmpData_);
abf48b53216b simple synchronization XMP <-> Exif, IPTC
nadvornik
parents: 1069
diff changeset
307 #endif
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
308 if (modified_xmp)
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
309 {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
310 g_hash_table_foreach(modified_xmp, _ExifDataProcessed_update_xmp, this);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
311 }
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
312 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
313
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
314 virtual ~_ExifDataProcessed()
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
315 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
316 if (imageData_) delete imageData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
317 if (sidecarData_) delete sidecarData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
318 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
319
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
320 virtual ExifData *original()
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
321 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
322 return imageData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
323 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
324
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
325 virtual void writeMetadata(gchar *path = NULL)
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
326 {
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
327 if (!path)
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
328 {
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
329 #if EXIV2_TEST_VERSION(0,17,0)
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
330 if (options->metadata.save_legacy_IPTC)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
331 copyXmpToIptc(xmpData_, iptcData_);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
332 else
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
333 iptcData_.clear();
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
334
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
335 copyXmpToExif(xmpData_, exifData_);
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
336 #endif
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
337 Exiv2::Image *image = imageData_->image();
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
338
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
339 if (!image) Exiv2::Error(21);
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
340 image->setExifData(exifData_);
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
341 image->setIptcData(iptcData_);
1245
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
342 #if EXIV2_TEST_VERSION(0,16,0)
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
343 image->setXmpData(xmpData_);
1245
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
344 #endif
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
345 image->writeMetadata();
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
346 }
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
347 else
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
348 {
1071
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
349 #if EXIV2_TEST_VERSION(0,17,0)
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
350 gchar *pathl = path_from_utf8(path);;
1071
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
351
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
352 Exiv2::Image::AutoPtr sidecar = Exiv2::ImageFactory::create(Exiv2::ImageType::xmp, pathl);
1071
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
353
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
354 g_free(pathl);
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
355
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
356 sidecar->setXmpData(xmpData_);
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
357 sidecar->writeMetadata();
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
358 #else
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
359 throw Exiv2::Error(3, "xmp");
1071
01e743d275f2 create xmp sidecar when needed
nadvornik
parents: 1070
diff changeset
360 #endif
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
361 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
362 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
363
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
364 virtual Exiv2::Image *image()
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
365 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
366 return imageData_->image();
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
367 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
368
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
369 virtual Exiv2::ExifData &exifData ()
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
370 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
371 return exifData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
372 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
373
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
374 virtual Exiv2::IptcData &iptcData ()
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
375 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
376 return iptcData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
377 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
378
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
379 #if EXIV2_TEST_VERSION(0,16,0)
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
380 virtual Exiv2::XmpData &xmpData ()
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
381 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
382 return xmpData_;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
383 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
384 #endif
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
385
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
386 virtual void add_jpeg_color_profile(unsigned char *cp_data, guint cp_length)
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
387 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
388 imageData_->add_jpeg_color_profile(cp_data, cp_length);
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
389 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
390
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
391 virtual guchar *get_jpeg_color_profile(guint *data_len)
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
392 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
393 return imageData_->get_jpeg_color_profile(data_len);
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
394 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
395 };
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
396
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
397
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
398
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
399
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
400 extern "C" {
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
401
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
402
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
403 void exif_init(void)
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
404 {
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
405 #ifdef EXV_ENABLE_NLS
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
406 bind_textdomain_codeset (EXV_PACKAGE, "UTF-8");
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
407 #endif
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
408 }
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
409
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
410
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
411
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
412 static void _ExifDataProcessed_update_xmp(gpointer key, gpointer value, gpointer data)
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
413 {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
414 exif_update_metadata((ExifData *)data, (gchar *)key, (GList *)value);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
415 }
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
416
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
417 ExifData *exif_read(gchar *path, gchar *sidecar_path, GHashTable *modified_xmp)
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
418 {
506
fc9c8a3e1a8b Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents: 496
diff changeset
419 DEBUG_1("exif read %s, sidecar: %s", path, sidecar_path ? sidecar_path : "-");
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
420 try {
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
421 return new _ExifDataProcessed(path, sidecar_path, modified_xmp);
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
422 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
423 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
424 debug_exception(e);
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
425 return NULL;
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
426 }
179
37004d5a584a and first version that actually shows some exif data (see advanced view)
nadvornik
parents: 178
diff changeset
427
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
428 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
429
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
430 gboolean exif_write(ExifData *exif)
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
431 {
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
432 try {
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
433 exif->writeMetadata();
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
434 return TRUE;
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
435 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
436 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
437 debug_exception(e);
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
438 return FALSE;
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
439 }
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
440 }
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
441
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
442 gboolean exif_write_sidecar(ExifData *exif, gchar *path)
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
443 {
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
444 try {
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
445 exif->writeMetadata(path);
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
446 return TRUE;
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
447 }
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
448 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
449 debug_exception(e);
1211
e2bbe90b0dcd most of the metadata options now works
nadvornik
parents: 1207
diff changeset
450 return FALSE;
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
451 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
452
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
453 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
454
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
455
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
456 void exif_free(ExifData *exif)
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
457 {
1072
4ae9461e88ca fixed failed assertion in exif_free
nadvornik
parents: 1071
diff changeset
458 if (!exif) return;
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
459 g_assert(dynamic_cast<_ExifDataProcessed *>(exif)); // this should not be called on ExifDataOriginal
182
8a417f10ba09 more exiv2 fixes
nadvornik
parents: 180
diff changeset
460 delete exif;
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
461 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
462
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
463 ExifData *exif_get_original(ExifData *exif)
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
464 {
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
465 return exif->original();
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
466 }
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
467
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
468
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
469 ExifItem *exif_get_item(ExifData *exif, const gchar *key)
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
470 {
183
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
471 try {
452
0a69a779395a fixed color profile code for older versions of exiv2
nadvornik
parents: 449
diff changeset
472 Exiv2::Metadatum *item = NULL;
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
473 try {
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
474 Exiv2::ExifKey ekey(key);
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
475 Exiv2::ExifData::iterator pos = exif->exifData().findKey(ekey);
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
476 if (pos == exif->exifData().end()) return NULL;
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
477 item = &*pos;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
478 }
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
479 catch (Exiv2::AnyError& e) {
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
480 try {
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
481 Exiv2::IptcKey ekey(key);
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
482 Exiv2::IptcData::iterator pos = exif->iptcData().findKey(ekey);
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
483 if (pos == exif->iptcData().end()) return NULL;
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
484 item = &*pos;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
485 }
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
486 catch (Exiv2::AnyError& e) {
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
487 #if EXIV2_TEST_VERSION(0,16,0)
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
488 Exiv2::XmpKey ekey(key);
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
489 Exiv2::XmpData::iterator pos = exif->xmpData().findKey(ekey);
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
490 if (pos == exif->xmpData().end()) return NULL;
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
491 item = &*pos;
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
492 #endif
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
493 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
494 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
495 return (ExifItem *)item;
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
496 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
497 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
498 debug_exception(e);
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
499 return NULL;
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
500 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
501 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
502
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
503 ExifItem *exif_add_item(ExifData *exif, const gchar *key)
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
504 {
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
505 try {
452
0a69a779395a fixed color profile code for older versions of exiv2
nadvornik
parents: 449
diff changeset
506 Exiv2::Metadatum *item = NULL;
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
507 try {
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
508 Exiv2::ExifKey ekey(key);
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
509 exif->exifData().add(ekey, NULL);
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
510 Exiv2::ExifData::iterator pos = exif->exifData().end(); // a hack, there should be a better way to get the currently added item
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
511 pos--;
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
512 item = &*pos;
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
513 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
514 catch (Exiv2::AnyError& e) {
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
515 try {
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
516 Exiv2::IptcKey ekey(key);
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
517 exif->iptcData().add(ekey, NULL);
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
518 Exiv2::IptcData::iterator pos = exif->iptcData().end();
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
519 pos--;
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
520 item = &*pos;
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
521 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
522 catch (Exiv2::AnyError& e) {
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
523 #if EXIV2_TEST_VERSION(0,16,0)
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
524 Exiv2::XmpKey ekey(key);
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
525 exif->xmpData().add(ekey, NULL);
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
526 Exiv2::XmpData::iterator pos = exif->xmpData().end();
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
527 pos--;
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
528 item = &*pos;
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
529 #endif
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
530 }
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
531 }
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
532 return (ExifItem *)item;
183
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
533 }
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
534 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
535 debug_exception(e);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
536 return NULL;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
537 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
538 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
539
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
540
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
541 ExifItem *exif_get_first_item(ExifData *exif)
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
542 {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
543 try {
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
544 exif->exifIter = exif->exifData().begin();
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
545 exif->iptcIter = exif->iptcData().begin();
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
546 #if EXIV2_TEST_VERSION(0,16,0)
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
547 exif->xmpIter = exif->xmpData().begin();
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
548 #endif
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
549 if (exif->exifIter != exif->exifData().end())
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
550 {
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
551 const Exiv2::Metadatum *item = &*exif->exifIter;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
552 exif->exifIter++;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
553 return (ExifItem *)item;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
554 }
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
555 if (exif->iptcIter != exif->iptcData().end())
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
556 {
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
557 const Exiv2::Metadatum *item = &*exif->iptcIter;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
558 exif->iptcIter++;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
559 return (ExifItem *)item;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
560 }
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
561 #if EXIV2_TEST_VERSION(0,16,0)
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
562 if (exif->xmpIter != exif->xmpData().end())
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
563 {
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
564 const Exiv2::Metadatum *item = &*exif->xmpIter;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
565 exif->xmpIter++;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
566 return (ExifItem *)item;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
567 }
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
568 #endif
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
569 return NULL;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
570
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
571 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
572 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
573 debug_exception(e);
183
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
574 return NULL;
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
575 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
576 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
577
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
578 ExifItem *exif_get_next_item(ExifData *exif)
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
579 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
580 try {
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
581 if (exif->exifIter != exif->exifData().end())
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
582 {
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
583 const Exiv2::Metadatum *item = &*exif->exifIter;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
584 exif->exifIter++;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
585 return (ExifItem *)item;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
586 }
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
587 if (exif->iptcIter != exif->iptcData().end())
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
588 {
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
589 const Exiv2::Metadatum *item = &*exif->iptcIter;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
590 exif->iptcIter++;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
591 return (ExifItem *)item;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
592 }
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
593 #if EXIV2_TEST_VERSION(0,16,0)
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
594 if (exif->xmpIter != exif->xmpData().end())
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
595 {
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
596 const Exiv2::Metadatum *item = &*exif->xmpIter;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
597 exif->xmpIter++;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
598 return (ExifItem *)item;
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
599 }
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
600 #endif
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
601 return NULL;
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
602 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
603 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
604 debug_exception(e);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
605 return NULL;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
606 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
607 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
608
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
609 char *exif_item_get_tag_name(ExifItem *item)
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
610 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
611 try {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
612 if (!item) return NULL;
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
613 return g_strdup(((Exiv2::Metadatum *)item)->key().c_str());
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
614 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
615 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
616 debug_exception(e);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
617 return NULL;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
618 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
619 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
620
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
621 guint exif_item_get_tag_id(ExifItem *item)
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
622 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
623 try {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
624 if (!item) return 0;
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
625 return ((Exiv2::Metadatum *)item)->tag();
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
626 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
627 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
628 debug_exception(e);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
629 return 0;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
630 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
631 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
632
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
633 guint exif_item_get_elements(ExifItem *item)
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
634 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
635 try {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
636 if (!item) return 0;
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
637 return ((Exiv2::Metadatum *)item)->count();
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
638 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
639 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
640 debug_exception(e);
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
641 return 0;
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
642 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
643 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
644
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
645 char *exif_item_get_data(ExifItem *item, guint *data_len)
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
646 {
414
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
647 try {
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
648 if (!item) return 0;
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
649 Exiv2::Metadatum *md = (Exiv2::Metadatum *)item;
855
0c3f6ef17d18 Tidy up.
zas_
parents: 686
diff changeset
650 if (data_len) *data_len = md->size();
414
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
651 char *data = (char *)g_malloc(md->size());
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
652 long res = md->copy((Exiv2::byte *)data, Exiv2::littleEndian /* should not matter */);
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
653 g_assert(res == md->size());
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
654 return data;
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
655 }
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
656 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
657 debug_exception(e);
414
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
658 return NULL;
49c1cbe058ae partially fixed reading embedded color profiles with exiv2
nadvornik
parents: 304
diff changeset
659 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
660 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
661
182
8a417f10ba09 more exiv2 fixes
nadvornik
parents: 180
diff changeset
662 char *exif_item_get_description(ExifItem *item)
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
663 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
664 try {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
665 if (!item) return NULL;
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
666 return utf8_validate_or_convert(((Exiv2::Metadatum *)item)->tagLabel().c_str());
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
667 }
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
668 catch (std::exception& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
669 // debug_exception(e);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
670 return NULL;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
671 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
672 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
673
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
674 /*
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
675 invalidTypeId, unsignedByte, asciiString, unsignedShort,
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
676 unsignedLong, unsignedRational, signedByte, undefined,
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
677 signedShort, signedLong, signedRational, string,
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
678 date, time, comment, directory,
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
679 xmpText, xmpAlt, xmpBag, xmpSeq,
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
680 langAlt, lastTypeId
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
681 */
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
682
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
683 static guint format_id_trans_tbl [] = {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
684 EXIF_FORMAT_UNKNOWN,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
685 EXIF_FORMAT_BYTE_UNSIGNED,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
686 EXIF_FORMAT_STRING,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
687 EXIF_FORMAT_SHORT_UNSIGNED,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
688 EXIF_FORMAT_LONG_UNSIGNED,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
689 EXIF_FORMAT_RATIONAL_UNSIGNED,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
690 EXIF_FORMAT_BYTE,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
691 EXIF_FORMAT_UNDEFINED,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
692 EXIF_FORMAT_SHORT,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
693 EXIF_FORMAT_LONG,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
694 EXIF_FORMAT_RATIONAL,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
695 EXIF_FORMAT_STRING,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
696 EXIF_FORMAT_STRING,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
697 EXIF_FORMAT_STRING,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
698 EXIF_FORMAT_UNDEFINED,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
699 EXIF_FORMAT_STRING,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
700 EXIF_FORMAT_STRING,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
701 EXIF_FORMAT_STRING,
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
702 EXIF_FORMAT_STRING
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
703 };
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
704
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
705
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
706
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
707 guint exif_item_get_format_id(ExifItem *item)
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
708 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
709 try {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
710 if (!item) return EXIF_FORMAT_UNKNOWN;
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
711 guint id = ((Exiv2::Metadatum *)item)->typeId();
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
712 if (id >= (sizeof(format_id_trans_tbl) / sizeof(format_id_trans_tbl[0])) ) return EXIF_FORMAT_UNKNOWN;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
713 return format_id_trans_tbl[id];
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
714 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
715 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
716 debug_exception(e);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
717 return EXIF_FORMAT_UNKNOWN;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
718 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
719 }
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
720
1422
91bed0d66cf2 gint -> gboolean and tidy up.
zas_
parents: 1288
diff changeset
721 const char *exif_item_get_format_name(ExifItem *item, gboolean brief)
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
722 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
723 try {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
724 if (!item) return NULL;
185
354da67a7ca2 read also iptc and xmp
nadvornik
parents: 184
diff changeset
725 return ((Exiv2::Metadatum *)item)->typeName();
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
726 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
727 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
728 debug_exception(e);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
729 return NULL;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
730 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
731 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
732
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
733
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
734 gchar *exif_item_get_data_as_text(ExifItem *item)
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
735 {
183
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
736 try {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
737 if (!item) return NULL;
676
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
738 Exiv2::Metadatum *metadatum = (Exiv2::Metadatum *)item;
677
6304ba358850 fixed exiv2 version test
nadvornik
parents: 676
diff changeset
739 #if EXIV2_TEST_VERSION(0,17,0)
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
740 return utf8_validate_or_convert(metadatum->print().c_str());
676
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
741 #else
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
742 std::stringstream str;
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
743 Exiv2::Exifdatum *exifdatum;
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
744 Exiv2::Iptcdatum *iptcdatum;
686
c0dda0ffb931 configure.in was rewritten:
bruclik
parents: 677
diff changeset
745 #if EXIV2_TEST_VERSION(0,16,0)
676
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
746 Exiv2::Xmpdatum *xmpdatum;
686
c0dda0ffb931 configure.in was rewritten:
bruclik
parents: 677
diff changeset
747 #endif
855
0c3f6ef17d18 Tidy up.
zas_
parents: 686
diff changeset
748 if ((exifdatum = dynamic_cast<Exiv2::Exifdatum *>(metadatum)))
676
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
749 str << *exifdatum;
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
750 else if ((iptcdatum = dynamic_cast<Exiv2::Iptcdatum *>(metadatum)))
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
751 str << *iptcdatum;
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
752 #if EXIV2_TEST_VERSION(0,16,0)
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
753 else if ((xmpdatum = dynamic_cast<Exiv2::Xmpdatum *>(metadatum)))
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
754 str << *xmpdatum;
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
755 #endif
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
756
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
757 return utf8_validate_or_convert(str.str().c_str());
676
3a4a7385997c get processed values from exiv2
nadvornik
parents: 673
diff changeset
758 #endif
183
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
759 }
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
760 catch (Exiv2::AnyError& e) {
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
761 return NULL;
3962c9d3d6fd more exiv2 fixes
nadvornik
parents: 182
diff changeset
762 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
763 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
764
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
765 gchar *exif_item_get_string(ExifItem *item, int idx)
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
766 {
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
767 try {
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
768 if (!item) return NULL;
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
769 Exiv2::Metadatum *em = (Exiv2::Metadatum *)item;
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
770 #if EXIV2_TEST_VERSION(0,16,0)
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
771 std::string str = em->toString(idx);
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
772 #else
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
773 std::string str = em->toString(); // FIXME
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
774 #endif
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
775 if (idx == 0 && str == "") str = em->toString();
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
776 if (str.length() > 5 && str.substr(0, 5) == "lang=")
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
777 {
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
778 std::string::size_type pos = str.find_first_of(' ');
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
779 if (pos != std::string::npos) str = str.substr(pos+1);
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
780 }
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
781
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
782 return utf8_validate_or_convert(str.c_str());
188
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
783 }
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
784 catch (Exiv2::AnyError& e) {
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
785 return NULL;
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
786 }
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
787 }
0584cb78aa14 write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents: 187
diff changeset
788
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
789
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
790 gint exif_item_get_integer(ExifItem *item, gint *value)
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
791 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
792 try {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
793 if (!item) return 0;
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
794 *value = ((Exiv2::Metadatum *)item)->toLong();
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
795 return 1;
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
796 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
797 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
798 debug_exception(e);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
799 return 0;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
800 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
801 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
802
1058
b600689a677e Fix up few signed vs unsigned warnings: exif_item_get_rational() last parameter is now of guint type.
zas_
parents: 1055
diff changeset
803 ExifRational *exif_item_get_rational(ExifItem *item, gint *sign, guint n)
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
804 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
805 try {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
806 if (!item) return NULL;
1052
338c21c87ff5 Add support for GPSInfo - patch by Klaus Ethgen
nadvornik
parents: 1048
diff changeset
807 if (n >= exif_item_get_elements(item)) return NULL;
338c21c87ff5 Add support for GPSInfo - patch by Klaus Ethgen
nadvornik
parents: 1048
diff changeset
808 Exiv2::Rational v = ((Exiv2::Metadatum *)item)->toRational(n);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
809 static ExifRational ret;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
810 ret.num = v.first;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
811 ret.den = v.second;
485
2fef42c958bb fixed reading of signed rational type with Exiv2
nadvornik
parents: 475
diff changeset
812 if (sign) *sign = (((Exiv2::Metadatum *)item)->typeId() == Exiv2::signedRational);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
813 return &ret;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
814 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
815 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
816 debug_exception(e);
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
817 return NULL;
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
818 }
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
819 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
820
1053
77ca9a5d42be fixed charset of exiv2 strings in non-utf8 locales
nadvornik
parents: 1052
diff changeset
821 gchar *exif_get_tag_description_by_key(const gchar *key)
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
822 {
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
823 try {
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
824 Exiv2::ExifKey ekey(key);
1442
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
825 return utf8_validate_or_convert(ekey.tagLabel().c_str());
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
826 }
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
827 catch (Exiv2::AnyError& e) {
1442
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
828 try {
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
829 Exiv2::IptcKey ikey(key);
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
830 return utf8_validate_or_convert(ikey.tagLabel().c_str());
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
831 }
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
832 catch (Exiv2::AnyError& e) {
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
833 try {
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
834 #if EXIV2_TEST_VERSION(0,16,0)
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
835 Exiv2::XmpKey xkey(key);
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
836 return utf8_validate_or_convert(xkey.tagLabel().c_str());
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
837 #endif
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
838 }
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
839 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
840 debug_exception(e);
1442
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
841 return NULL;
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
842 }
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
843 }
184
2507418ab7a2 more exiv2 fixes
nadvornik
parents: 183
diff changeset
844 }
1442
e37cde2857c1 fixed XMP and IPTC entry names in exif pane
nadvornik
parents: 1426
diff changeset
845 return NULL;
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
846 }
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
847
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
848 static const AltKey *find_alt_key(const gchar *xmp_key)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
849 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
850 gint i = 0;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
851
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
852 while (alt_keys[i].xmp_key)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
853 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
854 if (strcmp(xmp_key, alt_keys[i].xmp_key) == 0) return &alt_keys[i];
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
855 i++;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
856 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
857 return NULL;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
858 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
859
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
860 static gint exif_update_metadata_simple(ExifData *exif, const gchar *key, const GList *values)
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
861 {
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
862 try {
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
863 const GList *work = values;
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
864
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
865 try {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
866 Exiv2::ExifKey ekey(key);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
867
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
868 Exiv2::ExifData::iterator pos = exif->exifData().findKey(ekey);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
869 while (pos != exif->exifData().end())
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
870 {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
871 exif->exifData().erase(pos);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
872 pos = exif->exifData().findKey(ekey);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
873 }
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
874
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
875 while (work)
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
876 {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
877 exif->exifData()[key] = (gchar *)work->data;
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
878 work = work->next;
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
879 }
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
880 }
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
881 catch (Exiv2::AnyError& e) {
1245
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
882 #if EXIV2_TEST_VERSION(0,16,0)
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
883 try
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
884 #endif
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
885 {
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
886 Exiv2::IptcKey ekey(key);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
887 Exiv2::IptcData::iterator pos = exif->iptcData().findKey(ekey);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
888 while (pos != exif->iptcData().end())
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
889 {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
890 exif->iptcData().erase(pos);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
891 pos = exif->iptcData().findKey(ekey);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
892 }
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
893
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
894 while (work)
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
895 {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
896 exif->iptcData()[key] = (gchar *)work->data;
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
897 work = work->next;
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
898 }
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
899 }
1245
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
900 #if EXIV2_TEST_VERSION(0,16,0)
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
901 catch (Exiv2::AnyError& e) {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
902 Exiv2::XmpKey ekey(key);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
903 Exiv2::XmpData::iterator pos = exif->xmpData().findKey(ekey);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
904 while (pos != exif->xmpData().end())
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
905 {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
906 exif->xmpData().erase(pos);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
907 pos = exif->xmpData().findKey(ekey);
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
908 }
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
909
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
910 while (work)
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
911 {
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
912 exif->xmpData()[key] = (gchar *)work->data;
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
913 work = work->next;
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
914 }
1245
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
915 }
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
916 #endif
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
917 }
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
918 return 1;
1203
43bfcbb62cd6 prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents: 1196
diff changeset
919 }
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
920 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
921 debug_exception(e);
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
922 return 0;
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
923 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
924 }
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
925
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
926 gint exif_update_metadata(ExifData *exif, const gchar *key, const GList *values)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
927 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
928 gint ret = exif_update_metadata_simple(exif, key, values);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
929
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
930 if (
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
931 #if !EXIV2_TEST_VERSION(0,17,0)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
932 TRUE || /* no conversion support */
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
933 #endif
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
934 !values || /* deleting item */
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
935 !ret /* writing to the explicitely given xmp tag failed */
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
936 )
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
937 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
938 /* deleted xmp metadatum can't be converted, we have to delete also the corresponding legacy tag */
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
939 /* if we can't write xmp, update at least the legacy tag */
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
940 const AltKey *alt_key = find_alt_key(key);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
941 if (alt_key && alt_key->iptc_key)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
942 ret = exif_update_metadata_simple(exif, alt_key->iptc_key, values);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
943
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
944 if (alt_key && alt_key->exif_key)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
945 ret = exif_update_metadata_simple(exif, alt_key->exif_key, values);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
946 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
947 return ret;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
948 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
949
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
950
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
951 static GList *exif_add_value_to_glist(GList *list, Exiv2::Metadatum &item, MetadataFormat format, const Exiv2::ExifData *metadata)
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
952 {
1245
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
953 #if EXIV2_TEST_VERSION(0,16,0)
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
954 Exiv2::TypeId id = item.typeId();
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
955 if (format == METADATA_FORMATTED ||
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
956 id == Exiv2::asciiString ||
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
957 id == Exiv2::undefined ||
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
958 id == Exiv2::string ||
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
959 id == Exiv2::date ||
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
960 id == Exiv2::time ||
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
961 id == Exiv2::xmpText ||
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
962 id == Exiv2::langAlt ||
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
963 id == Exiv2::comment
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
964 )
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
965 {
1245
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
966 #endif
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
967 /* read as a single entry */
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
968 std::string str;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
969
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
970 if (format == METADATA_FORMATTED)
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
971 {
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
972 #if EXIV2_TEST_VERSION(0,17,0)
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
973 str = item.print(
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
974 #if EXIV2_TEST_VERSION(0,18,0)
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
975 metadata
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
976 #endif
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
977 );
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
978 #else
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
979 std::stringstream stream;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
980 Exiv2::Exifdatum *exifdatum;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
981 Exiv2::Iptcdatum *iptcdatum;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
982 #if EXIV2_TEST_VERSION(0,16,0)
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
983 Exiv2::Xmpdatum *xmpdatum;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
984 #endif
1572
df4e69170f2b compilation fixes
nadvornik
parents: 1528
diff changeset
985 if ((exifdatum = dynamic_cast<Exiv2::Exifdatum *>(&item)))
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
986 stream << *exifdatum;
1572
df4e69170f2b compilation fixes
nadvornik
parents: 1528
diff changeset
987 else if ((iptcdatum = dynamic_cast<Exiv2::Iptcdatum *>(&item)))
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
988 stream << *iptcdatum;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
989 #if EXIV2_TEST_VERSION(0,16,0)
1572
df4e69170f2b compilation fixes
nadvornik
parents: 1528
diff changeset
990 else if ((xmpdatum = dynamic_cast<Exiv2::Xmpdatum *>(&item)))
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
991 stream << *xmpdatum;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
992 #endif
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
993 str = stream.str();
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
994 #endif
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
995 if (str.length() > 1024)
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
996 {
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
997 /* truncate very long strings, they cause problems in gui */
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
998 str.erase(1024);
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
999 str.append("...");
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1000 }
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1001 }
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1002 else
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1003 {
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1004 str = item.toString();
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1005 if (str.length() > 5 && str.substr(0, 5) == "lang=")
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1006 {
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1007 std::string::size_type pos = str.find_first_of(' ');
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1008 if (pos != std::string::npos) str = str.substr(pos+1);
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1009 }
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1010 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1011 list = g_list_append(list, utf8_validate_or_convert(str.c_str()));
1245
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
1012 #if EXIV2_TEST_VERSION(0,16,0)
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1013 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1014 else
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1015 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1016 /* read as a list */
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1017 gint i;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1018 for (i = 0; i < item.count(); i++)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1019 list = g_list_append(list, utf8_validate_or_convert(item.toString(i).c_str()));
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1020 }
1245
13d4501bfa7a compilation fixes for older exiv2
nadvornik
parents: 1238
diff changeset
1021 #endif
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1022 return list;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1023 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1024
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1025 static GList *exif_get_metadata_simple(ExifData *exif, const gchar *key, MetadataFormat format)
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1026 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1027 GList *list = NULL;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1028 try {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1029 try {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1030 Exiv2::ExifKey ekey(key);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1031 Exiv2::ExifData::iterator pos = exif->exifData().findKey(ekey);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1032 if (pos != exif->exifData().end())
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1033 list = exif_add_value_to_glist(list, *pos, format, &exif->exifData());
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1034
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1035 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1036 catch (Exiv2::AnyError& e) {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1037 try {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1038 Exiv2::IptcKey ekey(key);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1039 Exiv2::IptcData::iterator pos = exif->iptcData().begin();
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1040 while (pos != exif->iptcData().end())
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1041 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1042 if (pos->key() == key)
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1043 list = exif_add_value_to_glist(list, *pos, format, NULL);
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1044 ++pos;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1045 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1046
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1047 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1048 catch (Exiv2::AnyError& e) {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1049 #if EXIV2_TEST_VERSION(0,16,0)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1050 Exiv2::XmpKey ekey(key);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1051 Exiv2::XmpData::iterator pos = exif->xmpData().findKey(ekey);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1052 if (pos != exif->xmpData().end())
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1053 list = exif_add_value_to_glist(list, *pos, format, NULL);
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1054 #endif
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1055 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1056 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1057 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1058 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
1059 debug_exception(e);
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1060 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1061 return list;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1062 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1063
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1064 GList *exif_get_metadata(ExifData *exif, const gchar *key, MetadataFormat format)
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1065 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1066 GList *list = NULL;
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1067
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1068 if (!key) return NULL;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1069
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1070 if (format == METADATA_FORMATTED)
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1071 {
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1072 gchar *text;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1073 gint key_valid;
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1074 text = exif_get_formatted_by_key(exif, key, &key_valid);
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1075 if (key_valid) return g_list_append(NULL, text);
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1076 }
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1077
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1078 list = exif_get_metadata_simple(exif, key, format);
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1079
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1080 /* the following code can be ifdefed out as soon as Exiv2 supports it */
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1081 if (!list)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1082 {
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1083 const AltKey *alt_key = find_alt_key(key);
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1084 if (alt_key && alt_key->iptc_key)
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1085 list = exif_get_metadata_simple(exif, alt_key->iptc_key, format);
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1086
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1087 #if !EXIV2_TEST_VERSION(0,17,0)
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1088 /* with older Exiv2 versions exif is not synced */
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1089 if (!list && alt_key && alt_key->exif_key)
1288
10073464e6aa use metadata_read_* functions where possible
nadvornik
parents: 1284
diff changeset
1090 list = exif_get_metadata_simple(exif, alt_key->exif_key, format);
1238
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1091 #endif
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1092 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1093 return list;
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1094 }
947e603a52c6 simplified metadata interface, dropped metadata_read,
nadvornik
parents: 1224
diff changeset
1095
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
1096
449
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
1097 void exif_add_jpeg_color_profile(ExifData *exif, unsigned char *cp_data, guint cp_length)
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
1098 {
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1099 exif->add_jpeg_color_profile(cp_data, cp_length);
449
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
1100 }
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
1101
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1102 guchar *exif_get_color_profile(ExifData *exif, guint *data_len)
449
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
1103 {
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1104 guchar *ret = exif->get_jpeg_color_profile(data_len);
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1105 if (ret) return ret;
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1106
449
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
1107 ExifItem *prof_item = exif_get_item(exif, "Exif.Image.InterColorProfile");
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
1108 if (prof_item && exif_item_get_format_id(prof_item) == EXIF_FORMAT_UNDEFINED)
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1109 ret = (guchar *)exif_item_get_data(prof_item, data_len);
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1110 return ret;
449
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
1111 }
115db540bd0c read color profiles from jpeg also with Exiv2
nadvornik
parents: 414
diff changeset
1112
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1113 #if EXIV2_TEST_VERSION(0,17,90)
187
9eafc4957f1a write support in Exiv2 wrapper; for now only string values
nadvornik
parents: 186
diff changeset
1114
1060
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1115 guchar *exif_get_preview(ExifData *exif, guint *data_len, gint requested_width, gint requested_height)
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1116 {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1117 if (!exif) return NULL;
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1118
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
1119 if (!exif->image()) return NULL;
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
1120
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1121 const char* path = exif->image()->io().path().c_str();
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1122 /* given image pathname, first do simple (and fast) file extension test */
1060
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1123 gboolean is_raw = filter_file_class(path, FORMAT_CLASS_RAWIMAGE);
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1124
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1125 if (!is_raw && requested_width == 0) return NULL;
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1126
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1127 try {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1128
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1129 Exiv2::PreviewManager pm(*exif->image());
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1130
1064
90dcc0060e22 follow Exiv2 SVN changes
nadvornik
parents: 1060
diff changeset
1131 Exiv2::PreviewPropertiesList list = pm.getPreviewProperties();
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1132
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1133 if (!list.empty())
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1134 {
1060
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1135 Exiv2::PreviewPropertiesList::iterator pos;
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1136 Exiv2::PreviewPropertiesList::iterator last = --list.end();
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1137
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1138 if (requested_width == 0)
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1139 {
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1140 pos = last; // the largest
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1141 }
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1142 else
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1143 {
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1144 pos = list.begin();
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1145 while (pos != last)
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1146 {
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1147 if (pos->width_ >= (uint32_t)requested_width &&
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1148 pos->height_ >= (uint32_t)requested_height) break;
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1149 ++pos;
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1150 }
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1151
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1152 // we are not interested in smaller thumbnails in normal image formats - we can use full image instead
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1153 if (!is_raw)
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1154 {
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1155 if (pos->width_ < (uint32_t)requested_width || pos->height_ < (uint32_t)requested_height) return NULL;
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1156 }
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1157 }
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1158
1064
90dcc0060e22 follow Exiv2 SVN changes
nadvornik
parents: 1060
diff changeset
1159 Exiv2::PreviewImage image = pm.getPreviewImage(*pos);
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1160
1064
90dcc0060e22 follow Exiv2 SVN changes
nadvornik
parents: 1060
diff changeset
1161 Exiv2::DataBuf buf = image.copy();
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1162 std::pair<Exiv2::byte*, long> p = buf.release();
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1163
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1164 *data_len = p.second;
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1165 return p.first;
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1166 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1167 return NULL;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1168 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1169 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
1170 debug_exception(e);
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1171 return NULL;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1172 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1173 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1174
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1175 void exif_free_preview(guchar *buf)
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1176 {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1177 delete[] (Exiv2::byte*)buf;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1178 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1179 #endif
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1180
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1181 }
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1182 #if !EXIV2_TEST_VERSION(0,17,90)
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1183
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1184 /* This is a dirty hack to support raw file preview, bassed on
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1185 tiffparse.cpp from Exiv2 examples */
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1187 class RawFile {
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1188 public:
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1189
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1190 RawFile(Exiv2::BasicIo &io);
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1191 ~RawFile();
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1192
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1193 const Exiv2::Value *find(uint16_t tag, uint16_t group);
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1194
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1195 unsigned long preview_offset();
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1196
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1197 private:
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1198 int type;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1199 Exiv2::TiffComponent::AutoPtr rootDir;
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1200 Exiv2::BasicIo &io_;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1201 const Exiv2::byte *map_data;
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1202 size_t map_len;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1203 unsigned long offset;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1204 };
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1205
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1206 typedef struct _UnmapData UnmapData;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1207 struct _UnmapData
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1208 {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1209 guchar *ptr;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1210 guchar *map_data;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1211 size_t map_len;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1212 };
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1213
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1214 static GList *exif_unmap_list = 0;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1215
1060
1e2de04c6fc4 added option to use exif thumbnails
nadvornik
parents: 1058
diff changeset
1216 extern "C" guchar *exif_get_preview(ExifData *exif, guint *data_len, gint requested_width, gint requested_height)
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1217 {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1218 unsigned long offset;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1219
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1220 if (!exif) return NULL;
1426
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
1221 if (!exif->image()) return NULL;
cd88fe4e5588 handle sidecar files for raw formats that are not known to exiv2
nadvornik
parents: 1422
diff changeset
1222
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1223 const char* path = exif->image()->io().path().c_str();
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1224
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1225 /* given image pathname, first do simple (and fast) file extension test */
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1226 if (!filter_file_class(path, FORMAT_CLASS_RAWIMAGE)) return NULL;
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1227
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1228 try {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1229 struct stat st;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1230 guchar *map_data;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1231 size_t map_len;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1232 UnmapData *ud;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1233 int fd;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1234
1069
aeae25d5d50d infrastructure for preprocessing of metadata
nadvornik
parents: 1064
diff changeset
1235 RawFile rf(exif->image()->io());
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1236 offset = rf.preview_offset();
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1237 DEBUG_1("%s: offset %lu", path, offset);
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1238
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1239 fd = open(path, O_RDONLY);
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1240 if (fd == -1)
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1241 {
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1242 return NULL;
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1243 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1244
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1245 if (fstat(fd, &st) == -1)
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1246 {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1247 close(fd);
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1248 return NULL;
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1249 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1250 map_len = st.st_size;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1251 map_data = (guchar *) mmap(0, map_len, PROT_READ, MAP_PRIVATE, fd, 0);
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1252 close(fd);
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1253 if (map_data == MAP_FAILED)
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1254 {
1048
95c418661be8 updated preview loader to work with current svn version of libexiv2
nadvornik
parents: 1025
diff changeset
1255 return NULL;
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1256 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1257 *data_len = map_len - offset;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1258 ud = g_new(UnmapData, 1);
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1259 ud->ptr = map_data + offset;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1260 ud->map_data = map_data;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1261 ud->map_len = map_len;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1262
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1263 exif_unmap_list = g_list_prepend(exif_unmap_list, ud);
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1264 return ud->ptr;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1265
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1266 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1267 catch (Exiv2::AnyError& e) {
1528
6fdb447d87b7 improved Exiv2 error reporting:
nadvornik
parents: 1460
diff changeset
1268 debug_exception(e);
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1269 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1270 return NULL;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1271
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1272 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1273
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1274 void exif_free_preview(guchar *buf)
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1275 {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1276 GList *work = exif_unmap_list;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1277
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1278 while (work)
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1279 {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1280 UnmapData *ud = (UnmapData *)work->data;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1281 if (ud->ptr == buf)
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1282 {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1283 munmap(ud->map_data, ud->map_len);
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1284 exif_unmap_list = g_list_remove_link(exif_unmap_list, work);
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1285 g_free(ud);
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1286 return;
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1287 }
1025
448d174454e1 fixed possible endless loop
nadvornik
parents: 1016
diff changeset
1288 work = work->next;
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1289 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1290 g_assert_not_reached();
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1291 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1292
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1293 using namespace Exiv2;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1294
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1295 RawFile::RawFile(BasicIo &io) : io_(io), map_data(NULL), map_len(0), offset(0)
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1296 {
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1297 /*
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1298 struct stat st;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1299 if (fstat(fd, &st) == -1)
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1300 {
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1301 throw Error(14);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1302 }
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1303 map_len = st.st_size;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1304 map_data = (Exiv2::byte *) mmap(0, map_len, PROT_READ, MAP_PRIVATE, fd, 0);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1305 if (map_data == MAP_FAILED)
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1306 {
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1307 throw Error(14);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1308 }
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1309 */
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1310 if (io.open() != 0) {
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1311 throw Error(9, io.path(), strError());
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1312 }
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1313
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1314 map_data = io.mmap();
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1315 map_len = io.size();
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1316
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1317
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1318 type = Exiv2::ImageFactory::getType(map_data, map_len);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1319
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1320 #if EXIV2_TEST_VERSION(0,16,0)
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1321 TiffHeaderBase *tiffHeader = NULL;
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1322 #else
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1323 TiffHeade2 *tiffHeader = NULL;
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1324 #endif
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1325 Cr2Header *cr2Header = NULL;
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1326
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1327 switch (type) {
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1328 case Exiv2::ImageType::tiff:
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1329 tiffHeader = new TiffHeade2();
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1330 break;
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1331 case Exiv2::ImageType::cr2:
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1332 cr2Header = new Cr2Header();
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1333 break;
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1334 #if EXIV2_TEST_VERSION(0,16,0)
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1335 case Exiv2::ImageType::orf:
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1336 tiffHeader = new OrfHeader();
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1337 break;
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1338 #endif
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1339 #if EXIV2_TEST_VERSION(0,13,0)
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1340 case Exiv2::ImageType::raf:
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1341 if (map_len < 84 + 4) throw Error(14);
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1342 offset = getULong(map_data + 84, bigEndian);
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1343 return;
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1344 #endif
191
19df9953a5d1 crw preview support with exiv2
nadvornik
parents: 188
diff changeset
1345 case Exiv2::ImageType::crw:
19df9953a5d1 crw preview support with exiv2
nadvornik
parents: 188
diff changeset
1346 {
19df9953a5d1 crw preview support with exiv2
nadvornik
parents: 188
diff changeset
1347 // Parse the image, starting with a CIFF header component
19df9953a5d1 crw preview support with exiv2
nadvornik
parents: 188
diff changeset
1348 Exiv2::CiffHeader::AutoPtr parseTree(new Exiv2::CiffHeader);
19df9953a5d1 crw preview support with exiv2
nadvornik
parents: 188
diff changeset
1349 parseTree->read(map_data, map_len);
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1350 CiffComponent *entry = parseTree->findComponent(0x2007, 0);
191
19df9953a5d1 crw preview support with exiv2
nadvornik
parents: 188
diff changeset
1351 if (entry) offset = entry->pData() - map_data;
19df9953a5d1 crw preview support with exiv2
nadvornik
parents: 188
diff changeset
1352 return;
19df9953a5d1 crw preview support with exiv2
nadvornik
parents: 188
diff changeset
1353 }
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1354
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1355 default:
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1356 throw Error(3, "RAW");
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1357 }
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1358
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1359 // process tiff-like formats
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1360
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1361 TiffCompFactoryFct createFct = TiffCreator::create;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1362
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1363 rootDir = createFct(Tag::root, Group::none);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1364 if (0 == rootDir.get()) {
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1365 throw Error(1, "No root element defined in TIFF structure");
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1366 }
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1367
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1368 if (tiffHeader)
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1369 {
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1370 if (!tiffHeader->read(map_data, map_len)) throw Error(3, "TIFF");
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1371 #if EXIV2_TEST_VERSION(0,16,0)
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1372 rootDir->setStart(map_data + tiffHeader->offset());
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1373 #else
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1374 rootDir->setStart(map_data + tiffHeader->ifdOffset());
200
1a38eef1129a exiv2 version checks
nadvornik
parents: 194
diff changeset
1375 #endif
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1376 }
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1377
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1378 if (cr2Header)
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1379 {
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1380 rootDir->setStart(map_data + cr2Header->offset());
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1381 }
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1382
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1383 TiffRwState::AutoPtr state(new TiffRwState(tiffHeader ? tiffHeader->byteOrder() : littleEndian, 0, createFct));
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1384
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1385 TiffReader reader(map_data,
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1386 map_len,
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1387 rootDir.get(),
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1388 state);
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1389
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1390 rootDir->accept(reader);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1391
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1392 if (tiffHeader)
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1393 delete tiffHeader;
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1394 if (cr2Header)
201
0ca12db715b7 improved support for older exiv2 versions
nadvornik
parents: 200
diff changeset
1395 delete cr2Header;
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1396 }
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1397
609
b690cecbf5b8 Use function(void) instead of function() for declaring functions which
zas_
parents: 586
diff changeset
1398 RawFile::~RawFile(void)
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1399 {
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1400 io_.munmap();
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1401 io_.close();
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1402 }
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1403
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1404 const Value * RawFile::find(uint16_t tag, uint16_t group)
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1405 {
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1406 TiffFinder finder(tag, group);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1407 rootDir->accept(finder);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1408 TiffEntryBase* te = dynamic_cast<TiffEntryBase*>(finder.result());
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1409 if (te)
194
889cfa008789 raw related fixes
nadvornik
parents: 191
diff changeset
1410 {
495
c7a2471e5c4e Introduce macros to display debug messages.
zas_
parents: 485
diff changeset
1411 DEBUG_1("(tag: %04x %04x) ", tag, group);
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1412 return te->pValue();
194
889cfa008789 raw related fixes
nadvornik
parents: 191
diff changeset
1413 }
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1414 else
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1415 return NULL;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1416 }
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1417
609
b690cecbf5b8 Use function(void) instead of function() for declaring functions which
zas_
parents: 586
diff changeset
1418 unsigned long RawFile::preview_offset(void)
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1419 {
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1420 const Value *val;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1421 if (offset) return offset;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1422
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1423 if (type == Exiv2::ImageType::cr2)
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1424 {
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1425 val = find(0x111, Group::ifd0);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1426 if (val) return val->toLong();
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1427
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1428 return 0;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1429 }
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1430
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1431 val = find(0x201, Group::sub0_0);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1432 if (val) return val->toLong();
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1433
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1434 val = find(0x201, Group::ifd0);
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1435 if (val) return val->toLong();
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1436
186
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1437 val = find(0x201, Group::ignr); // for PEF files, originally it was probably ifd2
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1438 if (val) return val->toLong();
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1439
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1440 val = find(0x111, Group::sub0_1); // dng
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1441 if (val) return val->toLong();
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1442
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1443 return 0;
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1444 }
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1445
bd3fc1aa7fe9 a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents: 185
diff changeset
1446
1008
68b0cb6ca8f0 use mmaped files image loader
nadvornik
parents: 995
diff changeset
1447 #endif
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
1448
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
1449
995
6ca2c5fd7b13 Whitespaces cleanup.
zas_
parents: 855
diff changeset
1450 #endif
178
9dc8bc9b2bb9 first exiv2 support that does not crash immediately
nadvornik
parents:
diff changeset
1451 /* HAVE_EXIV2 */
1055
1646720364cf Adding a vim modeline to all files - patch by Klaus Ethgen
nadvornik
parents: 1053
diff changeset
1452 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */