Mercurial > geeqie
annotate src/exiv2.cc @ 1224:ebfd305d902e
improved sidecar writting
private metadata can be saved in xmp format
author | nadvornik |
---|---|
date | Fri, 26 Dec 2008 14:12:36 +0000 |
parents | e2bbe90b0dcd |
children | 947e603a52c6 |
rev | line source |
---|---|
475 | 1 /* |
2 * Geeqie | |
3 * Copyright (C) 2008 The Geeqie Team | |
4 * | |
5 * Author: Vladimir Nadvornik | |
6 * | |
7 * This software is released under the GNU General Public License (GNU GPL). | |
8 * Please read the included file COPYING for more information. | |
9 * This software comes with no warranty of any kind, use at your own risk! | |
10 */ | |
178 | 11 |
686 | 12 #include "config.h" |
178 | 13 |
14 #ifdef HAVE_EXIV2 | |
15 | |
16 #include <exiv2/image.hpp> | |
17 #include <exiv2/exif.hpp> | |
18 #include <iostream> | |
19 | |
200 | 20 // EXIV2_TEST_VERSION is defined in Exiv2 0.15 and newer. |
21 #ifndef EXIV2_TEST_VERSION | |
22 # define EXIV2_TEST_VERSION(major,minor,patch) \ | |
23 ( EXIV2_VERSION >= EXIV2_MAKE_VERSION(major,minor,patch) ) | |
24 #endif | |
25 | |
26 | |
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 | 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 | 39 #include <exiv2/crwimage.hpp> |
200 | 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 | 42 #endif |
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 | 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 | 47 #else |
48 #include <exiv2/preview.hpp> | |
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 | 51 #if EXIV2_TEST_VERSION(0,17,0) |
52 #include <exiv2/convert.hpp> | |
1071 | 53 #include <exiv2/xmpsidecar.hpp> |
1070 | 54 #endif |
55 | |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
56 |
178 | 57 extern "C" { |
995 | 58 #include <glib.h> |
507 | 59 |
281 | 60 #include "main.h" |
178 | 61 #include "exif.h" |
507 | 62 |
586 | 63 #include "filefilter.h" |
496
a1f13fab6686
fixed a bug in opening files with non-utf8 locales in exiv2.cc
nadvornik
parents:
495
diff
changeset
|
64 #include "ui_fileops.h" |
184 | 65 } |
178 | 66 |
67 struct _ExifData | |
68 { | |
185 | 69 Exiv2::ExifData::const_iterator exifIter; /* for exif_get_next_item */ |
70 Exiv2::IptcData::const_iterator iptcIter; /* for exif_get_next_item */ | |
200 | 71 #if EXIV2_TEST_VERSION(0,16,0) |
185 | 72 Exiv2::XmpData::const_iterator xmpIter; /* for exif_get_next_item */ |
200 | 73 #endif |
184 | 74 |
1069 | 75 virtual ~_ExifData() |
76 { | |
77 } | |
78 | |
1211 | 79 virtual void writeMetadata(gchar *path = NULL) |
184 | 80 { |
1069 | 81 g_critical("Unsupported method of writing metadata"); |
82 } | |
83 | |
84 virtual ExifData *original() | |
85 { | |
86 return NULL; | |
87 } | |
88 | |
89 virtual Exiv2::Image *image() = 0; | |
90 | |
91 virtual Exiv2::ExifData &exifData() = 0; | |
92 | |
93 virtual Exiv2::IptcData &iptcData() = 0; | |
200 | 94 |
95 #if EXIV2_TEST_VERSION(0,16,0) | |
1069 | 96 virtual Exiv2::XmpData &xmpData() = 0; |
97 #endif | |
98 | |
99 virtual void add_jpeg_color_profile(unsigned char *cp_data, guint cp_length) = 0; | |
100 | |
101 virtual guchar *get_jpeg_color_profile(guint *data_len) = 0; | |
102 }; | |
103 | |
104 // This allows read-only access to the original metadata | |
105 struct _ExifDataOriginal : public _ExifData | |
106 { | |
107 protected: | |
108 Exiv2::Image::AutoPtr image_; | |
109 | |
110 /* the icc profile in jpeg is not technically exif - store it here */ | |
111 unsigned char *cp_data_; | |
112 guint cp_length_; | |
113 | |
114 public: | |
1071 | 115 _ExifDataOriginal(Exiv2::Image::AutoPtr image) |
116 { | |
117 cp_data_ = NULL; | |
118 cp_length_ = 0; | |
119 image_ = image; | |
120 } | |
1069 | 121 |
122 _ExifDataOriginal(gchar *path) | |
123 { | |
124 cp_data_ = NULL; | |
125 cp_length_ = 0; | |
126 gchar *pathl = path_from_utf8(path); | |
127 image_ = Exiv2::ImageFactory::open(pathl); | |
128 g_free(pathl); | |
129 // g_assert (image.get() != 0); | |
130 image_->readMetadata(); | |
131 | |
132 #if EXIV2_TEST_VERSION(0,16,0) | |
133 if (image_->mimeType() == "application/rdf+xml") | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
134 { |
1069 | 135 //Exiv2 sidecar converts xmp to exif and iptc, we don't want it. |
136 image_->clearExifData(); | |
137 image_->clearIptcData(); | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
138 } |
1069 | 139 #endif |
449 | 140 |
452
0a69a779395a
fixed color profile code for older versions of exiv2
nadvornik
parents:
449
diff
changeset
|
141 #if EXIV2_TEST_VERSION(0,14,0) |
1069 | 142 if (image_->mimeType() == "image/jpeg") |
449 | 143 { |
144 /* try to get jpeg color profile */ | |
1069 | 145 Exiv2::BasicIo &io = image_->io(); |
449 | 146 gint open = io.isopen(); |
147 if (!open) io.open(); | |
1196 | 148 if (io.isopen()) |
149 { | |
150 unsigned char *mapped = (unsigned char*)io.mmap(); | |
151 if (mapped) exif_jpeg_parse_color(this, mapped, io.size()); | |
152 io.munmap(); | |
153 } | |
449 | 154 if (!open) io.close(); |
155 } | |
995 | 156 #endif |
184 | 157 } |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
158 |
1069 | 159 virtual ~_ExifDataOriginal() |
449 | 160 { |
1069 | 161 if (cp_data_) g_free(cp_data_); |
449 | 162 } |
163 | |
1069 | 164 virtual Exiv2::Image *image() |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
165 { |
1069 | 166 return image_.get(); |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
167 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
168 |
1069 | 169 virtual Exiv2::ExifData &exifData () |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
170 { |
1069 | 171 return image_->exifData(); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
172 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
173 |
1069 | 174 virtual Exiv2::IptcData &iptcData () |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
175 { |
1069 | 176 return image_->iptcData(); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
177 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
178 |
200 | 179 #if EXIV2_TEST_VERSION(0,16,0) |
1069 | 180 virtual Exiv2::XmpData &xmpData () |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
181 { |
1069 | 182 return image_->xmpData(); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
183 } |
200 | 184 #endif |
184 | 185 |
1069 | 186 virtual void add_jpeg_color_profile(unsigned char *cp_data, guint cp_length) |
187 { | |
188 if (cp_data_) g_free(cp_data_); | |
189 cp_data_ = cp_data; | |
190 cp_length_ = cp_length; | |
191 } | |
192 | |
193 virtual guchar *get_jpeg_color_profile(guint *data_len) | |
194 { | |
195 if (cp_data_) | |
196 { | |
197 if (data_len) *data_len = cp_length_; | |
198 return (unsigned char *) g_memdup(cp_data_, cp_length_); | |
199 } | |
200 return NULL; | |
201 } | |
178 | 202 }; |
203 | |
1203
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
204 extern "C" { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
205 static void _ExifDataProcessed_update_xmp(gpointer key, gpointer value, gpointer data); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
206 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
207 |
1069 | 208 // This allows read-write access to the metadata |
209 struct _ExifDataProcessed : public _ExifData | |
210 { | |
211 protected: | |
212 _ExifDataOriginal *imageData_; | |
213 _ExifDataOriginal *sidecarData_; | |
214 | |
215 Exiv2::ExifData exifData_; | |
216 Exiv2::IptcData iptcData_; | |
217 #if EXIV2_TEST_VERSION(0,16,0) | |
218 Exiv2::XmpData xmpData_; | |
219 #endif | |
220 | |
221 public: | |
1203
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
222 _ExifDataProcessed(gchar *path, gchar *sidecar_path, GHashTable *modified_xmp) |
1069 | 223 { |
224 imageData_ = new _ExifDataOriginal(path); | |
225 sidecarData_ = NULL; | |
226 #if EXIV2_TEST_VERSION(0,16,0) | |
1224 | 227 if (sidecar_path) |
1069 | 228 { |
229 sidecarData_ = new _ExifDataOriginal(sidecar_path); | |
230 xmpData_ = sidecarData_->xmpData(); | |
231 } | |
1224 | 232 else |
233 { | |
234 xmpData_ = imageData_->xmpData(); | |
235 } | |
236 | |
1069 | 237 #endif |
238 exifData_ = imageData_->exifData(); | |
239 iptcData_ = imageData_->iptcData(); | |
1070 | 240 #if EXIV2_TEST_VERSION(0,17,0) |
241 syncExifWithXmp(exifData_, xmpData_); | |
242 #endif | |
1203
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
243 if (modified_xmp) |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
244 { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
245 g_hash_table_foreach(modified_xmp, _ExifDataProcessed_update_xmp, this); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
246 } |
1069 | 247 } |
248 | |
249 virtual ~_ExifDataProcessed() | |
250 { | |
251 if (imageData_) delete imageData_; | |
252 if (sidecarData_) delete sidecarData_; | |
253 } | |
254 | |
255 virtual ExifData *original() | |
256 { | |
257 return imageData_; | |
258 } | |
259 | |
1211 | 260 virtual void writeMetadata(gchar *path = NULL) |
1069 | 261 { |
1070 | 262 #if EXIV2_TEST_VERSION(0,17,0) |
263 syncExifWithXmp(exifData_, xmpData_); | |
264 #endif | |
1211 | 265 if (!path) |
1069 | 266 { |
1211 | 267 #if EXIV2_TEST_VERSION(0,17,0) |
268 if (options->metadata.save_legacy_IPTC) copyXmpToIptc(xmpData_, iptcData_); | |
269 #endif | |
270 imageData_->image()->setExifData(exifData_); | |
271 imageData_->image()->setIptcData(iptcData_); | |
272 imageData_->image()->setXmpData(xmpData_); | |
273 imageData_->image()->writeMetadata(); | |
274 } | |
1069 | 275 else |
276 { | |
1071 | 277 #if EXIV2_TEST_VERSION(0,17,0) |
1211 | 278 gchar *pathl = path_from_utf8(path);; |
1071 | 279 |
1211 | 280 Exiv2::Image::AutoPtr sidecar = Exiv2::ImageFactory::create(Exiv2::ImageType::xmp, pathl); |
1071 | 281 |
1211 | 282 g_free(pathl); |
283 | |
284 sidecar->setXmpData(xmpData_); | |
285 sidecar->writeMetadata(); | |
286 #else | |
287 throw Exiv2::Error(3, "xmp"); | |
1071 | 288 #endif |
1069 | 289 } |
290 } | |
291 | |
292 virtual Exiv2::Image *image() | |
293 { | |
294 return imageData_->image(); | |
295 } | |
296 | |
297 virtual Exiv2::ExifData &exifData () | |
298 { | |
299 return exifData_; | |
300 } | |
301 | |
302 virtual Exiv2::IptcData &iptcData () | |
303 { | |
304 return iptcData_; | |
305 } | |
306 | |
307 #if EXIV2_TEST_VERSION(0,16,0) | |
308 virtual Exiv2::XmpData &xmpData () | |
309 { | |
310 return xmpData_; | |
311 } | |
312 #endif | |
313 | |
314 virtual void add_jpeg_color_profile(unsigned char *cp_data, guint cp_length) | |
315 { | |
316 imageData_->add_jpeg_color_profile(cp_data, cp_length); | |
317 } | |
318 | |
319 virtual guchar *get_jpeg_color_profile(guint *data_len) | |
320 { | |
321 return imageData_->get_jpeg_color_profile(data_len); | |
322 } | |
323 }; | |
324 | |
325 | |
326 | |
327 | |
184 | 328 extern "C" { |
178 | 329 |
1203
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
330 static void _ExifDataProcessed_update_xmp(gpointer key, gpointer value, gpointer data) |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
331 { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
332 exif_update_metadata((ExifData *)data, (gchar *)key, (GList *)value); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
333 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
334 |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
335 ExifData *exif_read(gchar *path, gchar *sidecar_path, GHashTable *modified_xmp) |
178 | 336 { |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
496
diff
changeset
|
337 DEBUG_1("exif read %s, sidecar: %s", path, sidecar_path ? sidecar_path : "-"); |
178 | 338 try { |
1203
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
339 return new _ExifDataProcessed(path, sidecar_path, modified_xmp); |
178 | 340 } |
341 catch (Exiv2::AnyError& e) { | |
342 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
343 return NULL; |
178 | 344 } |
179
37004d5a584a
and first version that actually shows some exif data (see advanced view)
nadvornik
parents:
178
diff
changeset
|
345 |
178 | 346 } |
347 | |
1211 | 348 gboolean exif_write(ExifData *exif) |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
349 { |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
350 try { |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
351 exif->writeMetadata(); |
1211 | 352 return TRUE; |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
353 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
354 catch (Exiv2::AnyError& e) { |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
355 std::cout << "Caught Exiv2 exception '" << e << "'\n"; |
1211 | 356 return FALSE; |
357 } | |
358 } | |
359 | |
360 gboolean exif_write_sidecar(ExifData *exif, gchar *path) | |
361 { | |
362 try { | |
363 exif->writeMetadata(path); | |
364 return TRUE; | |
365 } | |
366 catch (Exiv2::AnyError& e) { | |
367 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
368 return FALSE; | |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
369 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
370 |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
371 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
372 |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
373 |
178 | 374 void exif_free(ExifData *exif) |
375 { | |
1072 | 376 if (!exif) return; |
1069 | 377 g_assert(dynamic_cast<_ExifDataProcessed *>(exif)); // this should not be called on ExifDataOriginal |
182 | 378 delete exif; |
178 | 379 } |
380 | |
1069 | 381 ExifData *exif_get_original(ExifData *exif) |
382 { | |
383 return exif->original(); | |
384 } | |
385 | |
386 | |
184 | 387 ExifItem *exif_get_item(ExifData *exif, const gchar *key) |
178 | 388 { |
183 | 389 try { |
452
0a69a779395a
fixed color profile code for older versions of exiv2
nadvornik
parents:
449
diff
changeset
|
390 Exiv2::Metadatum *item = NULL; |
185 | 391 try { |
392 Exiv2::ExifKey ekey(key); | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
393 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
|
394 if (pos == exif->exifData().end()) return NULL; |
185 | 395 item = &*pos; |
396 } | |
397 catch (Exiv2::AnyError& e) { | |
398 try { | |
399 Exiv2::IptcKey ekey(key); | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
400 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
|
401 if (pos == exif->iptcData().end()) return NULL; |
185 | 402 item = &*pos; |
403 } | |
404 catch (Exiv2::AnyError& e) { | |
200 | 405 #if EXIV2_TEST_VERSION(0,16,0) |
185 | 406 Exiv2::XmpKey ekey(key); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
407 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
|
408 if (pos == exif->xmpData().end()) return NULL; |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
409 item = &*pos; |
200 | 410 #endif |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
411 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
412 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
413 return (ExifItem *)item; |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
414 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
415 catch (Exiv2::AnyError& e) { |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
416 std::cout << "Caught Exiv2 exception '" << e << "'\n"; |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
417 return NULL; |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
418 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
419 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
420 |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
421 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
|
422 { |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
423 try { |
452
0a69a779395a
fixed color profile code for older versions of exiv2
nadvornik
parents:
449
diff
changeset
|
424 Exiv2::Metadatum *item = NULL; |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
425 try { |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
426 Exiv2::ExifKey ekey(key); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
427 exif->exifData().add(ekey, NULL); |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
428 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
|
429 pos--; |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
430 item = &*pos; |
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 catch (Exiv2::AnyError& e) { |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
433 try { |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
434 Exiv2::IptcKey ekey(key); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
435 exif->iptcData().add(ekey, NULL); |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
436 Exiv2::IptcData::iterator pos = exif->iptcData().end(); |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
437 pos--; |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
438 item = &*pos; |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
439 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
440 catch (Exiv2::AnyError& e) { |
200 | 441 #if EXIV2_TEST_VERSION(0,16,0) |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
442 Exiv2::XmpKey ekey(key); |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
443 exif->xmpData().add(ekey, NULL); |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
444 Exiv2::XmpData::iterator pos = exif->xmpData().end(); |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
445 pos--; |
185 | 446 item = &*pos; |
200 | 447 #endif |
185 | 448 } |
449 } | |
184 | 450 return (ExifItem *)item; |
183 | 451 } |
452 catch (Exiv2::AnyError& e) { | |
184 | 453 std::cout << "Caught Exiv2 exception '" << e << "'\n"; |
454 return NULL; | |
455 } | |
456 } | |
457 | |
458 | |
459 ExifItem *exif_get_first_item(ExifData *exif) | |
460 { | |
461 try { | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
462 exif->exifIter = exif->exifData().begin(); |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
463 exif->iptcIter = exif->iptcData().begin(); |
200 | 464 #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
|
465 exif->xmpIter = exif->xmpData().begin(); |
200 | 466 #endif |
995 | 467 if (exif->exifIter != exif->exifData().end()) |
185 | 468 { |
469 const Exiv2::Metadatum *item = &*exif->exifIter; | |
470 exif->exifIter++; | |
471 return (ExifItem *)item; | |
472 } | |
995 | 473 if (exif->iptcIter != exif->iptcData().end()) |
185 | 474 { |
475 const Exiv2::Metadatum *item = &*exif->iptcIter; | |
476 exif->iptcIter++; | |
477 return (ExifItem *)item; | |
478 } | |
200 | 479 #if EXIV2_TEST_VERSION(0,16,0) |
995 | 480 if (exif->xmpIter != exif->xmpData().end()) |
185 | 481 { |
482 const Exiv2::Metadatum *item = &*exif->xmpIter; | |
483 exif->xmpIter++; | |
484 return (ExifItem *)item; | |
485 } | |
200 | 486 #endif |
185 | 487 return NULL; |
488 | |
184 | 489 } |
490 catch (Exiv2::AnyError& e) { | |
491 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
183 | 492 return NULL; |
493 } | |
178 | 494 } |
495 | |
496 ExifItem *exif_get_next_item(ExifData *exif) | |
497 { | |
184 | 498 try { |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
499 if (exif->exifIter != exif->exifData().end()) |
185 | 500 { |
501 const Exiv2::Metadatum *item = &*exif->exifIter; | |
502 exif->exifIter++; | |
503 return (ExifItem *)item; | |
504 } | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
505 if (exif->iptcIter != exif->iptcData().end()) |
185 | 506 { |
507 const Exiv2::Metadatum *item = &*exif->iptcIter; | |
508 exif->iptcIter++; | |
509 return (ExifItem *)item; | |
510 } | |
200 | 511 #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
|
512 if (exif->xmpIter != exif->xmpData().end()) |
185 | 513 { |
514 const Exiv2::Metadatum *item = &*exif->xmpIter; | |
515 exif->xmpIter++; | |
516 return (ExifItem *)item; | |
517 } | |
200 | 518 #endif |
185 | 519 return NULL; |
184 | 520 } |
521 catch (Exiv2::AnyError& e) { | |
522 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
523 return NULL; | |
524 } | |
178 | 525 } |
526 | |
185 | 527 char *exif_item_get_tag_name(ExifItem *item) |
178 | 528 { |
184 | 529 try { |
530 if (!item) return NULL; | |
185 | 531 return g_strdup(((Exiv2::Metadatum *)item)->key().c_str()); |
184 | 532 } |
533 catch (Exiv2::AnyError& e) { | |
534 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
535 return NULL; | |
536 } | |
178 | 537 } |
538 | |
539 guint exif_item_get_tag_id(ExifItem *item) | |
540 { | |
184 | 541 try { |
542 if (!item) return 0; | |
185 | 543 return ((Exiv2::Metadatum *)item)->tag(); |
184 | 544 } |
545 catch (Exiv2::AnyError& e) { | |
546 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
547 return 0; | |
548 } | |
178 | 549 } |
550 | |
551 guint exif_item_get_elements(ExifItem *item) | |
552 { | |
184 | 553 try { |
554 if (!item) return 0; | |
185 | 555 return ((Exiv2::Metadatum *)item)->count(); |
184 | 556 } |
557 catch (Exiv2::AnyError& e) { | |
558 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
185 | 559 return 0; |
184 | 560 } |
178 | 561 } |
562 | |
563 char *exif_item_get_data(ExifItem *item, guint *data_len) | |
564 { | |
414
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
565 try { |
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
566 if (!item) return 0; |
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
567 Exiv2::Metadatum *md = (Exiv2::Metadatum *)item; |
855 | 568 if (data_len) *data_len = md->size(); |
414
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
569 char *data = (char *)g_malloc(md->size()); |
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
570 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
|
571 g_assert(res == md->size()); |
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
572 return data; |
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
573 } |
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
574 catch (Exiv2::AnyError& e) { |
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
575 std::cout << "Caught Exiv2 exception '" << e << "'\n"; |
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
576 return NULL; |
49c1cbe058ae
partially fixed reading embedded color profiles with exiv2
nadvornik
parents:
304
diff
changeset
|
577 } |
178 | 578 } |
579 | |
182 | 580 char *exif_item_get_description(ExifItem *item) |
178 | 581 { |
184 | 582 try { |
583 if (!item) return NULL; | |
1053
77ca9a5d42be
fixed charset of exiv2 strings in non-utf8 locales
nadvornik
parents:
1052
diff
changeset
|
584 return g_locale_to_utf8(((Exiv2::Metadatum *)item)->tagLabel().c_str(), -1, NULL, NULL, NULL); |
184 | 585 } |
185 | 586 catch (std::exception& e) { |
587 // std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
184 | 588 return NULL; |
589 } | |
178 | 590 } |
591 | |
592 /* | |
593 invalidTypeId, unsignedByte, asciiString, unsignedShort, | |
594 unsignedLong, unsignedRational, signedByte, undefined, | |
595 signedShort, signedLong, signedRational, string, | |
596 date, time, comment, directory, | |
597 xmpText, xmpAlt, xmpBag, xmpSeq, | |
995 | 598 langAlt, lastTypeId |
178 | 599 */ |
600 | |
184 | 601 static guint format_id_trans_tbl [] = { |
602 EXIF_FORMAT_UNKNOWN, | |
603 EXIF_FORMAT_BYTE_UNSIGNED, | |
604 EXIF_FORMAT_STRING, | |
605 EXIF_FORMAT_SHORT_UNSIGNED, | |
606 EXIF_FORMAT_LONG_UNSIGNED, | |
607 EXIF_FORMAT_RATIONAL_UNSIGNED, | |
608 EXIF_FORMAT_BYTE, | |
609 EXIF_FORMAT_UNDEFINED, | |
610 EXIF_FORMAT_SHORT, | |
611 EXIF_FORMAT_LONG, | |
612 EXIF_FORMAT_RATIONAL, | |
613 EXIF_FORMAT_STRING, | |
614 EXIF_FORMAT_STRING, | |
615 EXIF_FORMAT_STRING, | |
616 EXIF_FORMAT_UNDEFINED, | |
617 EXIF_FORMAT_STRING, | |
618 EXIF_FORMAT_STRING, | |
619 EXIF_FORMAT_STRING, | |
620 EXIF_FORMAT_STRING | |
621 }; | |
622 | |
623 | |
178 | 624 |
625 guint exif_item_get_format_id(ExifItem *item) | |
626 { | |
184 | 627 try { |
628 if (!item) return EXIF_FORMAT_UNKNOWN; | |
185 | 629 guint id = ((Exiv2::Metadatum *)item)->typeId(); |
184 | 630 if (id >= (sizeof(format_id_trans_tbl) / sizeof(format_id_trans_tbl[0])) ) return EXIF_FORMAT_UNKNOWN; |
631 return format_id_trans_tbl[id]; | |
632 } | |
633 catch (Exiv2::AnyError& e) { | |
634 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
635 return EXIF_FORMAT_UNKNOWN; | |
636 } | |
178 | 637 } |
184 | 638 |
178 | 639 const char *exif_item_get_format_name(ExifItem *item, gint brief) |
640 { | |
184 | 641 try { |
642 if (!item) return NULL; | |
185 | 643 return ((Exiv2::Metadatum *)item)->typeName(); |
184 | 644 } |
645 catch (Exiv2::AnyError& e) { | |
646 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
647 return NULL; | |
648 } | |
178 | 649 } |
650 | |
651 | |
652 gchar *exif_item_get_data_as_text(ExifItem *item) | |
653 { | |
183 | 654 try { |
184 | 655 if (!item) return NULL; |
676 | 656 Exiv2::Metadatum *metadatum = (Exiv2::Metadatum *)item; |
677 | 657 #if EXIV2_TEST_VERSION(0,17,0) |
1053
77ca9a5d42be
fixed charset of exiv2 strings in non-utf8 locales
nadvornik
parents:
1052
diff
changeset
|
658 return g_locale_to_utf8(metadatum->print().c_str(), -1, NULL, NULL, NULL); |
676 | 659 #else |
660 std::stringstream str; | |
661 Exiv2::Exifdatum *exifdatum; | |
662 Exiv2::Iptcdatum *iptcdatum; | |
686 | 663 #if EXIV2_TEST_VERSION(0,16,0) |
676 | 664 Exiv2::Xmpdatum *xmpdatum; |
686 | 665 #endif |
855 | 666 if ((exifdatum = dynamic_cast<Exiv2::Exifdatum *>(metadatum))) |
676 | 667 str << *exifdatum; |
668 else if ((iptcdatum = dynamic_cast<Exiv2::Iptcdatum *>(metadatum))) | |
669 str << *iptcdatum; | |
670 #if EXIV2_TEST_VERSION(0,16,0) | |
671 else if ((xmpdatum = dynamic_cast<Exiv2::Xmpdatum *>(metadatum))) | |
672 str << *xmpdatum; | |
673 #endif | |
674 | |
1053
77ca9a5d42be
fixed charset of exiv2 strings in non-utf8 locales
nadvornik
parents:
1052
diff
changeset
|
675 return g_locale_to_utf8(str.str().c_str(), -1, NULL, NULL, NULL); |
676 | 676 #endif |
183 | 677 } |
678 catch (Exiv2::AnyError& e) { | |
679 return NULL; | |
680 } | |
178 | 681 } |
682 | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
683 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
|
684 { |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
685 try { |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
686 if (!item) return NULL; |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
687 Exiv2::Metadatum *em = (Exiv2::Metadatum *)item; |
200 | 688 #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
|
689 std::string str = em->toString(idx); |
200 | 690 #else |
691 std::string str = em->toString(); // FIXME | |
692 #endif | |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
693 if (idx == 0 && str == "") str = em->toString(); |
995 | 694 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
|
695 { |
995 | 696 std::string::size_type pos = str.find_first_of(' '); |
697 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
|
698 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
699 |
1053
77ca9a5d42be
fixed charset of exiv2 strings in non-utf8 locales
nadvornik
parents:
1052
diff
changeset
|
700 // return g_locale_to_utf8(str.c_str(), -1, NULL, NULL, NULL); // FIXME |
188
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
701 return g_strdup(str.c_str()); |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
702 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
703 catch (Exiv2::AnyError& e) { |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
704 return NULL; |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
705 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
706 } |
0584cb78aa14
write comment and keywords to xmp, sidecars are used if exist
nadvornik
parents:
187
diff
changeset
|
707 |
178 | 708 |
709 gint exif_item_get_integer(ExifItem *item, gint *value) | |
710 { | |
184 | 711 try { |
712 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
|
713 *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
|
714 return 1; |
184 | 715 } |
716 catch (Exiv2::AnyError& e) { | |
717 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
718 return 0; | |
719 } | |
178 | 720 } |
721 | |
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
|
722 ExifRational *exif_item_get_rational(ExifItem *item, gint *sign, guint n) |
178 | 723 { |
184 | 724 try { |
725 if (!item) return NULL; | |
1052 | 726 if (n >= exif_item_get_elements(item)) return NULL; |
727 Exiv2::Rational v = ((Exiv2::Metadatum *)item)->toRational(n); | |
184 | 728 static ExifRational ret; |
729 ret.num = v.first; | |
730 ret.den = v.second; | |
485 | 731 if (sign) *sign = (((Exiv2::Metadatum *)item)->typeId() == Exiv2::signedRational); |
184 | 732 return &ret; |
733 } | |
734 catch (Exiv2::AnyError& e) { | |
735 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
736 return NULL; | |
737 } | |
178 | 738 } |
739 | |
1053
77ca9a5d42be
fixed charset of exiv2 strings in non-utf8 locales
nadvornik
parents:
1052
diff
changeset
|
740 gchar *exif_get_tag_description_by_key(const gchar *key) |
178 | 741 { |
184 | 742 try { |
743 Exiv2::ExifKey ekey(key); | |
1053
77ca9a5d42be
fixed charset of exiv2 strings in non-utf8 locales
nadvornik
parents:
1052
diff
changeset
|
744 return g_locale_to_utf8(Exiv2::ExifTags::tagLabel(ekey.tag(), ekey.ifdId ()), -1, NULL, NULL, NULL); |
184 | 745 } |
746 catch (Exiv2::AnyError& e) { | |
747 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
748 return NULL; | |
749 } | |
178 | 750 } |
751 | |
1203
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
752 gint exif_update_metadata(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
|
753 { |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
754 try { |
1203
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
755 const GList *work = values; |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
756 |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
757 try { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
758 Exiv2::ExifKey ekey(key); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
759 |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
760 Exiv2::ExifData::iterator pos = exif->exifData().findKey(ekey); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
761 while (pos != exif->exifData().end()) |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
762 { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
763 exif->exifData().erase(pos); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
764 pos = exif->exifData().findKey(ekey); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
765 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
766 |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
767 while (work) |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
768 { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
769 exif->exifData()[key] = (gchar *)work->data; |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
770 work = work->next; |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
771 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
772 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
773 catch (Exiv2::AnyError& e) { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
774 try { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
775 Exiv2::IptcKey ekey(key); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
776 Exiv2::IptcData::iterator pos = exif->iptcData().findKey(ekey); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
777 while (pos != exif->iptcData().end()) |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
778 { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
779 exif->iptcData().erase(pos); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
780 pos = exif->iptcData().findKey(ekey); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
781 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
782 |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
783 while (work) |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
784 { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
785 exif->iptcData()[key] = (gchar *)work->data; |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
786 work = work->next; |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
787 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
788 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
789 catch (Exiv2::AnyError& e) { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
790 #if EXIV2_TEST_VERSION(0,16,0) |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
791 Exiv2::XmpKey ekey(key); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
792 Exiv2::XmpData::iterator pos = exif->xmpData().findKey(ekey); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
793 while (pos != exif->xmpData().end()) |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
794 { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
795 exif->xmpData().erase(pos); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
796 pos = exif->xmpData().findKey(ekey); |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
797 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
798 |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
799 while (work) |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
800 { |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
801 exif->xmpData()[key] = (gchar *)work->data; |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
802 work = work->next; |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
803 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
804 #endif |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
805 } |
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
806 } |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
807 return 1; |
1203
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
808 } |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
809 catch (Exiv2::AnyError& e) { |
1203
43bfcbb62cd6
prepared infrastructure for delayed metadata writting - refreshing
nadvornik
parents:
1196
diff
changeset
|
810 std::cout << "Caught Exiv2 exception '" << e << "'\n"; |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
811 return 0; |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
812 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
813 } |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
814 |
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
815 |
449 | 816 void exif_add_jpeg_color_profile(ExifData *exif, unsigned char *cp_data, guint cp_length) |
817 { | |
1069 | 818 exif->add_jpeg_color_profile(cp_data, cp_length); |
449 | 819 } |
820 | |
1008 | 821 guchar *exif_get_color_profile(ExifData *exif, guint *data_len) |
449 | 822 { |
1069 | 823 guchar *ret = exif->get_jpeg_color_profile(data_len); |
824 if (ret) return ret; | |
825 | |
449 | 826 ExifItem *prof_item = exif_get_item(exif, "Exif.Image.InterColorProfile"); |
827 if (prof_item && exif_item_get_format_id(prof_item) == EXIF_FORMAT_UNDEFINED) | |
1069 | 828 ret = (guchar *)exif_item_get_data(prof_item, data_len); |
829 return ret; | |
449 | 830 } |
831 | |
1008 | 832 #if EXIV2_TEST_VERSION(0,17,90) |
187
9eafc4957f1a
write support in Exiv2 wrapper; for now only string values
nadvornik
parents:
186
diff
changeset
|
833 |
1060 | 834 guchar *exif_get_preview(ExifData *exif, guint *data_len, gint requested_width, gint requested_height) |
1008 | 835 { |
836 if (!exif) return NULL; | |
1048
95c418661be8
updated preview loader to work with current svn version of libexiv2
nadvornik
parents:
1025
diff
changeset
|
837 |
1069 | 838 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
|
839 /* given image pathname, first do simple (and fast) file extension test */ |
1060 | 840 gboolean is_raw = filter_file_class(path, FORMAT_CLASS_RAWIMAGE); |
841 | |
842 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
|
843 |
1008 | 844 try { |
845 | |
1069 | 846 Exiv2::PreviewManager pm(*exif->image()); |
1048
95c418661be8
updated preview loader to work with current svn version of libexiv2
nadvornik
parents:
1025
diff
changeset
|
847 |
1064 | 848 Exiv2::PreviewPropertiesList list = pm.getPreviewProperties(); |
1008 | 849 |
1048
95c418661be8
updated preview loader to work with current svn version of libexiv2
nadvornik
parents:
1025
diff
changeset
|
850 if (!list.empty()) |
1008 | 851 { |
1060 | 852 Exiv2::PreviewPropertiesList::iterator pos; |
853 Exiv2::PreviewPropertiesList::iterator last = --list.end(); | |
854 | |
855 if (requested_width == 0) | |
856 { | |
857 pos = last; // the largest | |
858 } | |
859 else | |
860 { | |
861 pos = list.begin(); | |
862 while (pos != last) | |
863 { | |
864 if (pos->width_ >= (uint32_t)requested_width && | |
865 pos->height_ >= (uint32_t)requested_height) break; | |
866 ++pos; | |
867 } | |
868 | |
869 // we are not interested in smaller thumbnails in normal image formats - we can use full image instead | |
870 if (!is_raw) | |
871 { | |
872 if (pos->width_ < (uint32_t)requested_width || pos->height_ < (uint32_t)requested_height) return NULL; | |
873 } | |
874 } | |
1048
95c418661be8
updated preview loader to work with current svn version of libexiv2
nadvornik
parents:
1025
diff
changeset
|
875 |
1064 | 876 Exiv2::PreviewImage image = pm.getPreviewImage(*pos); |
1048
95c418661be8
updated preview loader to work with current svn version of libexiv2
nadvornik
parents:
1025
diff
changeset
|
877 |
1064 | 878 Exiv2::DataBuf buf = image.copy(); |
1008 | 879 std::pair<Exiv2::byte*, long> p = buf.release(); |
880 | |
881 *data_len = p.second; | |
1048
95c418661be8
updated preview loader to work with current svn version of libexiv2
nadvornik
parents:
1025
diff
changeset
|
882 return p.first; |
1008 | 883 } |
884 return NULL; | |
885 } | |
886 catch (Exiv2::AnyError& e) { | |
887 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
888 return NULL; | |
889 } | |
890 } | |
891 | |
892 void exif_free_preview(guchar *buf) | |
893 { | |
894 delete[] (Exiv2::byte*)buf; | |
895 } | |
896 #endif | |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
897 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
898 } |
1008 | 899 #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
|
900 |
995 | 901 /* 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
|
902 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
|
903 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
904 class RawFile { |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
905 public: |
995 | 906 |
1008 | 907 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
|
908 ~RawFile(); |
995 | 909 |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
910 const Exiv2::Value *find(uint16_t tag, uint16_t group); |
995 | 911 |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
912 unsigned long preview_offset(); |
995 | 913 |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
914 private: |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
915 int type; |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
916 Exiv2::TiffComponent::AutoPtr rootDir; |
1008 | 917 Exiv2::BasicIo &io_; |
918 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
|
919 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
|
920 unsigned long offset; |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
921 }; |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
922 |
1008 | 923 typedef struct _UnmapData UnmapData; |
924 struct _UnmapData | |
925 { | |
926 guchar *ptr; | |
927 guchar *map_data; | |
928 size_t map_len; | |
929 }; | |
930 | |
931 static GList *exif_unmap_list = 0; | |
932 | |
1060 | 933 extern "C" guchar *exif_get_preview(ExifData *exif, guint *data_len, gint requested_width, gint requested_height) |
1008 | 934 { |
935 unsigned long offset; | |
936 | |
937 if (!exif) return NULL; | |
1069 | 938 const char* path = exif->image()->io().path().c_str(); |
1008 | 939 |
940 /* 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
|
941 if (!filter_file_class(path, FORMAT_CLASS_RAWIMAGE)) return NULL; |
1008 | 942 |
943 try { | |
944 struct stat st; | |
945 guchar *map_data; | |
946 size_t map_len; | |
947 UnmapData *ud; | |
948 int fd; | |
949 | |
1069 | 950 RawFile rf(exif->image()->io()); |
1008 | 951 offset = rf.preview_offset(); |
952 DEBUG_1("%s: offset %lu", path, offset); | |
953 | |
954 fd = open(path, O_RDONLY); | |
955 if (fd == -1) | |
956 { | |
1048
95c418661be8
updated preview loader to work with current svn version of libexiv2
nadvornik
parents:
1025
diff
changeset
|
957 return NULL; |
1008 | 958 } |
959 | |
960 if (fstat(fd, &st) == -1) | |
961 { | |
962 close(fd); | |
1048
95c418661be8
updated preview loader to work with current svn version of libexiv2
nadvornik
parents:
1025
diff
changeset
|
963 return NULL; |
1008 | 964 } |
965 map_len = st.st_size; | |
966 map_data = (guchar *) mmap(0, map_len, PROT_READ, MAP_PRIVATE, fd, 0); | |
967 close(fd); | |
968 if (map_data == MAP_FAILED) | |
969 { | |
1048
95c418661be8
updated preview loader to work with current svn version of libexiv2
nadvornik
parents:
1025
diff
changeset
|
970 return NULL; |
1008 | 971 } |
972 *data_len = map_len - offset; | |
973 ud = g_new(UnmapData, 1); | |
974 ud->ptr = map_data + offset; | |
975 ud->map_data = map_data; | |
976 ud->map_len = map_len; | |
977 | |
978 exif_unmap_list = g_list_prepend(exif_unmap_list, ud); | |
979 return ud->ptr; | |
980 | |
981 } | |
982 catch (Exiv2::AnyError& e) { | |
983 std::cout << "Caught Exiv2 exception '" << e << "'\n"; | |
984 } | |
985 return NULL; | |
986 | |
987 } | |
988 | |
989 void exif_free_preview(guchar *buf) | |
990 { | |
991 GList *work = exif_unmap_list; | |
992 | |
993 while (work) | |
994 { | |
995 UnmapData *ud = (UnmapData *)work->data; | |
996 if (ud->ptr == buf) | |
997 { | |
998 munmap(ud->map_data, ud->map_len); | |
999 exif_unmap_list = g_list_remove_link(exif_unmap_list, work); | |
1000 g_free(ud); | |
1001 return; | |
1002 } | |
1025 | 1003 work = work->next; |
1008 | 1004 } |
1005 g_assert_not_reached(); | |
1006 } | |
1007 | |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1008 using namespace Exiv2; |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1009 |
1008 | 1010 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
|
1011 { |
1008 | 1012 /* |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1013 struct stat st; |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1014 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
|
1015 { |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1016 throw Error(14); |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1017 } |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1018 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
|
1019 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
|
1020 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
|
1021 { |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1022 throw Error(14); |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1023 } |
1008 | 1024 */ |
1025 if (io.open() != 0) { | |
1026 throw Error(9, io.path(), strError()); | |
1027 } | |
1028 | |
1029 map_data = io.mmap(); | |
1030 map_len = io.size(); | |
1031 | |
1032 | |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1033 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
|
1034 |
200 | 1035 #if EXIV2_TEST_VERSION(0,16,0) |
201 | 1036 TiffHeaderBase *tiffHeader = NULL; |
200 | 1037 #else |
201 | 1038 TiffHeade2 *tiffHeader = NULL; |
200 | 1039 #endif |
201 | 1040 Cr2Header *cr2Header = NULL; |
1041 | |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1042 switch (type) { |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1043 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
|
1044 tiffHeader = new TiffHeade2(); |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1045 break; |
201 | 1046 case Exiv2::ImageType::cr2: |
1047 cr2Header = new Cr2Header(); | |
1048 break; | |
200 | 1049 #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
|
1050 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
|
1051 tiffHeader = new OrfHeader(); |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1052 break; |
200 | 1053 #endif |
1054 #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
|
1055 case Exiv2::ImageType::raf: |
995 | 1056 if (map_len < 84 + 4) throw Error(14); |
1057 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
|
1058 return; |
200 | 1059 #endif |
191 | 1060 case Exiv2::ImageType::crw: |
1061 { | |
1062 // Parse the image, starting with a CIFF header component | |
1063 Exiv2::CiffHeader::AutoPtr parseTree(new Exiv2::CiffHeader); | |
1064 parseTree->read(map_data, map_len); | |
995 | 1065 CiffComponent *entry = parseTree->findComponent(0x2007, 0); |
191 | 1066 if (entry) offset = entry->pData() - map_data; |
1067 return; | |
1068 } | |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1069 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1070 default: |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1071 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
|
1072 } |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1073 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1074 // 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
|
1075 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1076 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
|
1077 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1078 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
|
1079 if (0 == rootDir.get()) { |
995 | 1080 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
|
1081 } |
201 | 1082 |
1083 if (tiffHeader) | |
1084 { | |
1085 if (!tiffHeader->read(map_data, map_len)) throw Error(3, "TIFF"); | |
200 | 1086 #if EXIV2_TEST_VERSION(0,16,0) |
201 | 1087 rootDir->setStart(map_data + tiffHeader->offset()); |
200 | 1088 #else |
201 | 1089 rootDir->setStart(map_data + tiffHeader->ifdOffset()); |
200 | 1090 #endif |
201 | 1091 } |
1092 | |
1093 if (cr2Header) | |
1094 { | |
1095 rootDir->setStart(map_data + cr2Header->offset()); | |
1096 } | |
1097 | |
1098 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
|
1099 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1100 TiffReader reader(map_data, |
995 | 1101 map_len, |
1102 rootDir.get(), | |
1103 state); | |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1104 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1105 rootDir->accept(reader); |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1106 |
995 | 1107 if (tiffHeader) |
201 | 1108 delete tiffHeader; |
995 | 1109 if (cr2Header) |
201 | 1110 delete cr2Header; |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1111 } |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1112 |
609
b690cecbf5b8
Use function(void) instead of function() for declaring functions which
zas_
parents:
586
diff
changeset
|
1113 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
|
1114 { |
1008 | 1115 io_.munmap(); |
1116 io_.close(); | |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1117 } |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1118 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1119 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
|
1120 { |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1121 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
|
1122 rootDir->accept(finder); |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1123 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
|
1124 if (te) |
194 | 1125 { |
495 | 1126 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
|
1127 return te->pValue(); |
194 | 1128 } |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1129 else |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1130 return NULL; |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1131 } |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1132 |
609
b690cecbf5b8
Use function(void) instead of function() for declaring functions which
zas_
parents:
586
diff
changeset
|
1133 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
|
1134 { |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1135 const Value *val; |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1136 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
|
1137 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1138 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
|
1139 { |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1140 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
|
1141 if (val) return val->toLong(); |
995 | 1142 |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1143 return 0; |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1144 } |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1145 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1146 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
|
1147 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
|
1148 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1149 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
|
1150 if (val) return val->toLong(); |
995 | 1151 |
186
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1152 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
|
1153 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
|
1154 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1155 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
|
1156 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
|
1157 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1158 return 0; |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1159 } |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1160 |
bd3fc1aa7fe9
a hack to read raw previews with exiv2 0.16, however it should be fixed
nadvornik
parents:
185
diff
changeset
|
1161 |
1008 | 1162 #endif |
178 | 1163 |
1164 | |
995 | 1165 #endif |
178 | 1166 /* HAVE_EXIV2 */ |
1055
1646720364cf
Adding a vim modeline to all files - patch by Klaus Ethgen
nadvornik
parents:
1053
diff
changeset
|
1167 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */ |