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