annotate src/exiv2.cc @ 1442:e37cde2857c1

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