182
|
1 /*
|
|
2 * GQView
|
|
3 * (C) 2006 John Ellis
|
|
4 *
|
|
5 */
|
|
6
|
|
7 #ifdef HAVE_CONFIG_H
|
|
8 # include "config.h"
|
|
9 #endif
|
|
10
|
|
11 #include <stdio.h>
|
|
12 #include <string.h>
|
|
13 #include <fcntl.h>
|
|
14 #include <unistd.h>
|
|
15 #include <sys/types.h>
|
|
16 #include <sys/stat.h>
|
|
17 #include <sys/mman.h>
|
|
18 #include <math.h>
|
|
19
|
|
20 #include <glib.h>
|
|
21
|
|
22 #include "intl.h"
|
|
23
|
|
24 #include "gqview.h"
|
|
25 #include "exif.h"
|
|
26
|
|
27 #include "format_raw.h"
|
|
28 #include "ui_fileops.h"
|
|
29
|
|
30
|
|
31 /* human readable key list */
|
|
32
|
|
33 ExifFormattedText ExifFormattedList[] = {
|
|
34 { "fCamera", N_("Camera") },
|
|
35 { "fDateTime", N_("Date") },
|
|
36 { "fShutterSpeed", N_("Shutter speed") },
|
|
37 { "fAperture", N_("Aperture") },
|
|
38 { "fExposureBias", N_("Exposure bias") },
|
|
39 { "fISOSpeedRating", N_("ISO sensitivity") },
|
|
40 { "fFocalLength", N_("Focal length") },
|
|
41 { "fSubjectDistance", N_("Subject distance") },
|
|
42 { "fFlash", N_("Flash") },
|
|
43 { "fResolution", N_("Resolution") },
|
|
44 { NULL, NULL }
|
|
45 };
|
|
46
|
|
47 static ExifTextList ExifFlashList[] = {
|
|
48 { 0, N_("no") },
|
|
49 { 1, N_("yes") },
|
|
50 { 5, N_("yes, not detected by strobe") },
|
|
51 { 7, N_("yes, detected by strobe") },
|
|
52 EXIF_TEXT_LIST_END
|
|
53 };
|
|
54
|
|
55
|
|
56 double exif_rational_to_double(ExifRational *r, gint sign)
|
|
57 {
|
|
58 if (!r || r->den == 0.0) return 0.0;
|
|
59
|
|
60 if (sign) return (double)((int)r->num) / (double)((int)r->den);
|
|
61 return (double)r->num / r->den;
|
|
62 }
|
|
63
|
|
64 double exif_get_rational_as_double(ExifData *exif, const gchar *key)
|
|
65 {
|
|
66 ExifRational *r;
|
|
67 gint sign;
|
|
68
|
|
69 r = exif_get_rational(exif, key, &sign);
|
|
70 return exif_rational_to_double(r, sign);
|
|
71 }
|
|
72
|
|
73 static GString *append_comma_text(GString *string, const gchar *text)
|
|
74 {
|
|
75 string = g_string_append(string, ", ");
|
|
76 string = g_string_append(string, text);
|
|
77
|
|
78 return string;
|
|
79 }
|
|
80
|
|
81
|
|
82 gchar *exif_get_formatted_by_key(ExifData *exif, const gchar *key, gint *key_valid)
|
|
83 {
|
|
84 /* must begin with f, else not formatted */
|
|
85 if (key[0] != 'f')
|
|
86 {
|
|
87 if (key_valid) *key_valid = FALSE;
|
|
88 return NULL;
|
|
89 }
|
|
90
|
|
91 if (key_valid) *key_valid = TRUE;
|
|
92
|
|
93 if (strcmp(key, "fCamera") == 0)
|
|
94 {
|
|
95 gchar *text;
|
|
96 gchar *make = exif_get_data_as_text(exif, "Exif.Image.Make");
|
|
97 gchar *model = exif_get_data_as_text(exif, "Exif.Image.Model");
|
|
98 gchar *software = exif_get_data_as_text(exif, "Exif.Image.Software");
|
|
99
|
|
100 text = g_strdup_printf("%s%s%s%s%s%s", (make) ? make : "", ((make) && (model)) ? " " : "",
|
|
101 (model) ? model : "",
|
|
102 (software) ? " (" : "",
|
|
103 (software) ? software : "",
|
|
104 (software) ? ")" : "");
|
|
105
|
|
106 g_free(make);
|
|
107 g_free(model);
|
|
108 g_free(software);
|
|
109 return text;
|
|
110 }
|
|
111 if (strcmp(key, "fDateTime") == 0)
|
|
112 {
|
|
113 gchar *text = exif_get_data_as_text(exif, "Exif.Photo.DateTimeOriginal");
|
|
114 gchar *subsec = NULL;
|
|
115 if (text) subsec = exif_get_data_as_text(exif, "Exif.Photo.SubSecTimeOriginal");
|
|
116 if (!text)
|
|
117 {
|
|
118 text = exif_get_data_as_text(exif, "Exif.Image.DateTime");
|
|
119 if (text) subsec = exif_get_data_as_text(exif, "Exif.Photo.SubSecTime");
|
|
120 }
|
|
121 if (subsec)
|
|
122 {
|
|
123 gchar *tmp = text;
|
|
124 text = g_strconcat(tmp, ".", subsec, NULL);
|
|
125 g_free(tmp);
|
|
126 g_free(subsec);
|
|
127 }
|
|
128 return text;
|
|
129 }
|
|
130 if (strcmp(key, "fShutterSpeed") == 0)
|
|
131 {
|
|
132 ExifRational *r;
|
|
133
|
|
134 r = exif_get_rational(exif, "Exif.Photo.ExposureTime", NULL);
|
|
135 if (r && r->num && r->den)
|
|
136 {
|
|
137 double n = (double)r->den / (double)r->num;
|
|
138 return g_strdup_printf("%s%.0fs", n > 1.0 ? "1/" : "",
|
|
139 n > 1.0 ? n : 1.0 / n);
|
|
140 }
|
|
141 r = exif_get_rational(exif, "Exif.Photo.ShutterSpeedValue", NULL);
|
|
142 if (r && r->num && r->den)
|
|
143 {
|
|
144 double n = pow(2.0, exif_rational_to_double(r, TRUE));
|
|
145
|
|
146 /* Correct exposure time to avoid values like 1/91s (seen on Minolta DImage 7) */
|
|
147 if (n > 1.0 && (int)n - ((int)(n/10))*10 == 1) n--;
|
|
148
|
|
149 return g_strdup_printf("%s%.0fs", n > 1.0 ? "1/" : "",
|
|
150 n > 1.0 ? floor(n) : 1.0 / n);
|
|
151 }
|
|
152 return NULL;
|
|
153 }
|
|
154 if (strcmp(key, "fAperture") == 0)
|
|
155 {
|
|
156 double n;
|
|
157
|
|
158 n = exif_get_rational_as_double(exif, "Exif.Photo.FNumber");
|
|
159 if (n == 0.0) n = exif_get_rational_as_double(exif, "Exif.Photo.ApertureValue");
|
|
160 if (n == 0.0) return NULL;
|
|
161
|
|
162 return g_strdup_printf("f/%.1f", n);
|
|
163 }
|
|
164 if (strcmp(key, "fExposureBias") == 0)
|
|
165 {
|
|
166 ExifRational *r;
|
|
167 gint sign;
|
|
168 double n;
|
|
169
|
|
170 r = exif_get_rational(exif, "Exif.Photo.ExposureBiasValue", &sign);
|
|
171 if (!r) return NULL;
|
|
172
|
|
173 n = exif_rational_to_double(r, sign);
|
|
174 return g_strdup_printf("%+.1f", n);
|
|
175 }
|
|
176 if (strcmp(key, "fFocalLength") == 0)
|
|
177 {
|
|
178 double n;
|
|
179
|
|
180 n = exif_get_rational_as_double(exif, "Exif.Photo.FocalLength");
|
|
181 if (n == 0.0) return NULL;
|
|
182 return g_strdup_printf("%.2f mm", n);
|
|
183 }
|
|
184 if (strcmp(key, "fISOSpeedRating") == 0)
|
|
185 {
|
|
186 gchar *text;
|
|
187
|
|
188 text = exif_get_data_as_text(exif, "Exif.Photo.ISOSpeedRatings");
|
|
189 /* kodak may set this instead */
|
|
190 if (!text) text = exif_get_data_as_text(exif, "Exif.Photo.ExposureIndex");
|
|
191 return text;
|
|
192 }
|
|
193 if (strcmp(key, "fSubjectDistance") == 0)
|
|
194 {
|
|
195 ExifRational *r;
|
|
196 gint sign;
|
|
197 double n;
|
|
198
|
|
199 r = exif_get_rational(exif, "Exif.Photo.SubjectDistance", &sign);
|
|
200 if (!r) return NULL;
|
|
201
|
|
202 if ((long)r->num == 0xffffffff) return g_strdup(_("infinity"));
|
|
203 if ((long)r->num == 0) return g_strdup(_("unknown"));
|
|
204
|
|
205 n = exif_rational_to_double(r, sign);
|
|
206 if (n == 0.0) return _("unknown");
|
|
207 return g_strdup_printf("%.3f m", n);
|
|
208 }
|
|
209 if (strcmp(key, "fFlash") == 0)
|
|
210 {
|
|
211 /* grr, flash is a bitmask... */
|
|
212 GString *string;
|
|
213 gchar *text;
|
|
214 gint n;
|
|
215 gint v;
|
|
216
|
|
217 if (!exif_get_integer(exif, "Exif.Photo.Flash", &n)) return NULL;
|
|
218
|
|
219 /* Exif 2.1 only defines first 3 bits */
|
184
|
220 if (n <= 0x07) return exif_get_data_as_text(exif, "Exif.Photo.Flash");
|
182
|
221
|
|
222 /* must be Exif 2.2 */
|
|
223 string = g_string_new("");
|
|
224
|
|
225 /* flash fired (bit 0) */
|
|
226 string = g_string_append(string, (n & 0x01) ? _("yes") : _("no"));
|
|
227
|
|
228 /* flash mode (bits 3, 4) */
|
|
229 v = (n >> 3) & 0x03;
|
|
230 if (v) string = append_comma_text(string, _("mode:"));
|
|
231 switch (v)
|
|
232 {
|
|
233 case 1:
|
|
234 string = g_string_append(string, _("on"));
|
|
235 break;
|
|
236 case 2:
|
|
237 string = g_string_append(string, _("off"));
|
|
238 break;
|
|
239 case 3:
|
|
240 string = g_string_append(string, _("auto"));
|
|
241 break;
|
|
242 }
|
|
243
|
|
244 /* return light (bits 1, 2) */
|
|
245 v = (n >> 1) & 0x03;
|
|
246 if (v == 2) string = append_comma_text(string, _("not detected by strobe"));
|
|
247 if (v == 3) string = append_comma_text(string, _("detected by strobe"));
|
|
248
|
|
249 /* we ignore flash function (bit 5) */
|
|
250
|
|
251 /* red-eye (bit 6) */
|
|
252 if ((n >> 5) & 0x01) string = append_comma_text(string, _("red-eye reduction"));
|
|
253
|
|
254 text = string->str;
|
|
255 g_string_free(string, FALSE);
|
|
256 return text;
|
|
257 }
|
|
258 if (strcmp(key, "fResolution") == 0)
|
|
259 {
|
|
260 ExifRational *rx, *ry;
|
|
261 gchar *units;
|
|
262 gchar *text;
|
|
263
|
|
264 rx = exif_get_rational(exif, "Exif.Image.XResolution", NULL);
|
|
265 ry = exif_get_rational(exif, "Exif.Image.YResolution", NULL);
|
|
266 if (!rx || !ry) return NULL;
|
|
267
|
|
268 units = exif_get_data_as_text(exif, "Exif.Image.ResolutionUnit");
|
|
269 text = g_strdup_printf("%0.f x %0.f (%s/%s)", rx->den ? (double)rx->num / rx->den : 1.0,
|
|
270 ry->den ? (double)ry->num / ry->den : 1.0,
|
|
271 _("dot"), (units) ? units : _("unknown"));
|
|
272
|
|
273 g_free(units);
|
|
274 return text;
|
|
275 }
|
|
276
|
|
277 if (key_valid) *key_valid = FALSE;
|
|
278 return NULL;
|
|
279 }
|
|
280
|
|
281 const gchar *exif_get_description_by_key(const gchar *key)
|
|
282 {
|
|
283 gint i;
|
|
284
|
|
285 if (!key) return NULL;
|
|
286
|
|
287 i = 0;
|
|
288 while (ExifFormattedList[i].key != NULL)
|
|
289 {
|
|
290 if (strcmp(key, ExifFormattedList[i].key) == 0) return _(ExifFormattedList[i].description);
|
|
291 i++;
|
|
292 }
|
|
293
|
|
294 return exif_get_tag_description_by_key(key);
|
|
295 }
|
184
|
296
|
|
297 gint exif_get_integer(ExifData *exif, const gchar *key, gint *value)
|
|
298 {
|
|
299 ExifItem *item;
|
|
300
|
|
301 item = exif_get_item(exif, key);
|
|
302 return exif_item_get_integer(item, value);
|
|
303 }
|
|
304
|
|
305 ExifRational *exif_get_rational(ExifData *exif, const gchar *key, gint *sign)
|
|
306 {
|
|
307 ExifItem *item;
|
|
308
|
|
309 item = exif_get_item(exif, key);
|
|
310 return exif_item_get_rational(item, sign);
|
|
311 }
|
|
312
|
|
313 gchar *exif_get_data_as_text(ExifData *exif, const gchar *key)
|
|
314 {
|
|
315 ExifItem *item;
|
|
316 gchar *text;
|
|
317 gint key_valid;
|
|
318
|
|
319 if (!key) return NULL;
|
|
320
|
|
321 text = exif_get_formatted_by_key(exif, key, &key_valid);
|
|
322 if (key_valid) return text;
|
|
323
|
|
324 item = exif_get_item(exif, key);
|
|
325 if (item) return exif_item_get_data_as_text(item);
|
|
326
|
|
327 return NULL;
|
|
328 }
|