annotate src/exiv2.cc @ 1811:f405ec9b696b default tip

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