1 /* GStreamer
2 * Copyright (C) 2010 Thiago Santos <thiago.sousa.santos@collabora.co.uk>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 */
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include "gsttageditingprivate.h"
24
25 #include <string.h>
26
27 gint
__exif_tag_image_orientation_to_exif_value(const gchar * str)28 __exif_tag_image_orientation_to_exif_value (const gchar * str)
29 {
30 if (str == NULL)
31 goto end;
32
33 if (strcmp (str, "rotate-0") == 0)
34 return 1;
35 else if (strcmp (str, "flip-rotate-0") == 0)
36 return 2;
37 else if (strcmp (str, "rotate-180") == 0)
38 return 3;
39 else if (strcmp (str, "flip-rotate-180") == 0)
40 return 4;
41 else if (strcmp (str, "flip-rotate-270") == 0)
42 return 5;
43 else if (strcmp (str, "rotate-90") == 0)
44 return 6;
45 else if (strcmp (str, "flip-rotate-90") == 0)
46 return 7;
47 else if (strcmp (str, "rotate-270") == 0)
48 return 8;
49
50 end:
51 GST_WARNING ("Invalid image orientation tag: %s", str);
52 return -1;
53 }
54
55 const gchar *
__exif_tag_image_orientation_from_exif_value(gint value)56 __exif_tag_image_orientation_from_exif_value (gint value)
57 {
58 switch (value) {
59 case 1:
60 return "rotate-0";
61 case 2:
62 return "flip-rotate-0";
63 case 3:
64 return "rotate-180";
65 case 4:
66 return "flip-rotate-180";
67 case 5:
68 return "flip-rotate-270";
69 case 6:
70 return "rotate-90";
71 case 7:
72 return "flip-rotate-90";
73 case 8:
74 return "rotate-270";
75 default:
76 GST_WARNING ("Invalid tiff orientation tag value: %d", value);
77 return NULL;
78 }
79 }
80
81 gint
__exif_tag_capturing_exposure_program_to_exif_value(const gchar * str)82 __exif_tag_capturing_exposure_program_to_exif_value (const gchar * str)
83 {
84 if (str == NULL)
85 goto end;
86
87 if (strcmp (str, "undefined") == 0)
88 return 0;
89 else if (strcmp (str, "manual") == 0)
90 return 1;
91 else if (strcmp (str, "normal") == 0)
92 return 2;
93 else if (strcmp (str, "aperture-priority") == 0)
94 return 3;
95 else if (strcmp (str, "shutter-priority") == 0)
96 return 4;
97 else if (strcmp (str, "creative") == 0)
98 return 5;
99 else if (strcmp (str, "action") == 0)
100 return 6;
101 else if (strcmp (str, "portrait") == 0)
102 return 7;
103 else if (strcmp (str, "landscape") == 0)
104 return 8;
105
106 end:
107 GST_WARNING ("Invalid capturing exposure program tag: %s", str);
108 return -1;
109 }
110
111 const gchar *
__exif_tag_capturing_exposure_program_from_exif_value(gint value)112 __exif_tag_capturing_exposure_program_from_exif_value (gint value)
113 {
114 switch (value) {
115 case 0:
116 return "undefined";
117 case 1:
118 return "manual";
119 case 2:
120 return "normal";
121 case 3:
122 return "aperture-priority";
123 case 4:
124 return "shutter-priority";
125 case 5:
126 return "creative";
127 case 6:
128 return "action";
129 case 7:
130 return "portrait";
131 case 8:
132 return "landscape";
133 default:
134 GST_WARNING ("Invalid exif exposure program: %d", value);
135 return NULL;
136 }
137 }
138
139 gint
__exif_tag_capturing_exposure_mode_to_exif_value(const gchar * str)140 __exif_tag_capturing_exposure_mode_to_exif_value (const gchar * str)
141 {
142 if (str == NULL)
143 goto end;
144
145 if (strcmp (str, "auto-exposure") == 0)
146 return 0;
147 else if (strcmp (str, "manual-exposure") == 0)
148 return 1;
149 else if (strcmp (str, "auto-bracket") == 0)
150 return 2;
151
152 end:
153 GST_WARNING ("Invalid capturing exposure mode tag: %s", str);
154 return -1;
155 }
156
157 const gchar *
__exif_tag_capturing_exposure_mode_from_exif_value(gint value)158 __exif_tag_capturing_exposure_mode_from_exif_value (gint value)
159 {
160 switch (value) {
161 case 0:
162 return "auto-exposure";
163 case 1:
164 return "manual-exposure";
165 case 2:
166 return "auto-bracket";
167 default:
168 GST_WARNING ("Invalid exif exposure mode: %d", value);
169 return NULL;
170 }
171 }
172
173 gint
__exif_tag_capturing_scene_capture_type_to_exif_value(const gchar * str)174 __exif_tag_capturing_scene_capture_type_to_exif_value (const gchar * str)
175 {
176 if (str == NULL)
177 goto end;
178
179 if (strcmp (str, "standard") == 0)
180 return 0;
181 else if (strcmp (str, "landscape") == 0)
182 return 1;
183 else if (strcmp (str, "portrait") == 0)
184 return 2;
185 else if (strcmp (str, "night-scene") == 0)
186 return 3;
187
188 end:
189 GST_WARNING ("Invalid capturing scene capture type: %s", str);
190 return -1;
191 }
192
193 const gchar *
__exif_tag_capturing_scene_capture_type_from_exif_value(gint value)194 __exif_tag_capturing_scene_capture_type_from_exif_value (gint value)
195 {
196 switch (value) {
197 case 0:
198 return "standard";
199 case 1:
200 return "landscape";
201 case 2:
202 return "portrait";
203 case 3:
204 return "night-scene";
205 default:
206 GST_WARNING ("Invalid exif scene capture type: %d", value);
207 return NULL;
208 }
209 }
210
211 gint
__exif_tag_capturing_gain_adjustment_to_exif_value(const gchar * str)212 __exif_tag_capturing_gain_adjustment_to_exif_value (const gchar * str)
213 {
214 if (str == NULL)
215 goto end;
216
217 if (strcmp (str, "none") == 0)
218 return 0;
219 else if (strcmp (str, "low-gain-up") == 0)
220 return 1;
221 else if (strcmp (str, "high-gain-up") == 0)
222 return 2;
223 else if (strcmp (str, "low-gain-down") == 0)
224 return 3;
225 else if (strcmp (str, "high-gain-down") == 0)
226 return 4;
227
228 end:
229 GST_WARNING ("Invalid capturing gain adjustment type: %s", str);
230 return -1;
231 }
232
233 const gchar *
__exif_tag_capturing_gain_adjustment_from_exif_value(gint value)234 __exif_tag_capturing_gain_adjustment_from_exif_value (gint value)
235 {
236 switch (value) {
237 case 0:
238 return "none";
239 case 1:
240 return "low-gain-up";
241 case 2:
242 return "high-gain-up";
243 case 3:
244 return "low-gain-down";
245 case 4:
246 return "high-gain-down";
247 default:
248 GST_WARNING ("Invalid exif gain control type: %d", value);
249 return NULL;
250 }
251 }
252
253 gint
__exif_tag_capturing_white_balance_to_exif_value(const gchar * str)254 __exif_tag_capturing_white_balance_to_exif_value (const gchar * str)
255 {
256 if (str == NULL)
257 goto end;
258
259 if (strcmp (str, "auto") == 0)
260 return 0;
261 else /* everything else is just manual */
262 return 1;
263
264 end:
265 GST_WARNING ("Invalid white balance: %s", str);
266 return -1;
267 }
268
269 const gchar *
__exif_tag_capturing_white_balance_from_exif_value(gint value)270 __exif_tag_capturing_white_balance_from_exif_value (gint value)
271 {
272 switch (value) {
273 case 0:
274 return "auto";
275 case 1:
276 return "manual";
277 default:
278 GST_WARNING ("Invalid white balance type: %d", value);
279 return NULL;
280 }
281 }
282
283 static gint
__exif_tag_capturing_contrast_sharpness_to_exif_value(const gchar * str,const gchar * tag_name)284 __exif_tag_capturing_contrast_sharpness_to_exif_value (const gchar * str,
285 const gchar * tag_name)
286 {
287 if (str == NULL)
288 goto end;
289
290 if (strcmp (str, "normal") == 0)
291 return 0;
292 else if (strcmp (str, "soft") == 0)
293 return 1;
294 else if (strcmp (str, "hard") == 0)
295 return 2;
296
297 end:
298 GST_WARNING ("Invalid %s type: %s", tag_name, str);
299 return -1;
300 }
301
302 static const gchar *
__exif_tag_capturing_contrast_sharpness_from_exif_value(gint value,const gchar * tag_name)303 __exif_tag_capturing_contrast_sharpness_from_exif_value (gint value,
304 const gchar * tag_name)
305 {
306 switch (value) {
307 case 0:
308 return "normal";
309 case 1:
310 return "soft";
311 case 2:
312 return "hard";
313 default:
314 GST_WARNING ("Invalid %s type: %d", tag_name, value);
315 return NULL;
316 }
317 }
318
319 gint
__exif_tag_capturing_contrast_to_exif_value(const gchar * str)320 __exif_tag_capturing_contrast_to_exif_value (const gchar * str)
321 {
322 return __exif_tag_capturing_contrast_sharpness_to_exif_value (str,
323 "contrast");
324 }
325
326 const gchar *
__exif_tag_capturing_contrast_from_exif_value(gint value)327 __exif_tag_capturing_contrast_from_exif_value (gint value)
328 {
329 return __exif_tag_capturing_contrast_sharpness_from_exif_value (value,
330 "contrast");
331 }
332
333 gint
__exif_tag_capturing_saturation_to_exif_value(const gchar * str)334 __exif_tag_capturing_saturation_to_exif_value (const gchar * str)
335 {
336 if (str == NULL)
337 goto end;
338
339 if (strcmp (str, "normal") == 0)
340 return 0;
341 else if (strcmp (str, "low-saturation") == 0)
342 return 1;
343 else if (strcmp (str, "high-saturation") == 0)
344 return 2;
345
346 end:
347 GST_WARNING ("Invalid saturation type: %s", str);
348 return -1;
349 }
350
351 const gchar *
__exif_tag_capturing_saturation_from_exif_value(gint value)352 __exif_tag_capturing_saturation_from_exif_value (gint value)
353 {
354 switch (value) {
355 case 0:
356 return "normal";
357 case 1:
358 return "low-saturation";
359 case 2:
360 return "high-saturation";
361 default:
362 GST_WARNING ("Invalid saturation type: %d", value);
363 return NULL;
364 }
365 }
366
367 gint
__exif_tag_capturing_sharpness_to_exif_value(const gchar * str)368 __exif_tag_capturing_sharpness_to_exif_value (const gchar * str)
369 {
370 return __exif_tag_capturing_contrast_sharpness_to_exif_value (str,
371 "sharpness");
372 }
373
374 const gchar *
__exif_tag_capturing_sharpness_from_exif_value(gint value)375 __exif_tag_capturing_sharpness_from_exif_value (gint value)
376 {
377 return __exif_tag_capturing_contrast_sharpness_from_exif_value (value,
378 "sharpness");
379 }
380
381 gint
__exif_tag_capturing_metering_mode_to_exif_value(const gchar * str)382 __exif_tag_capturing_metering_mode_to_exif_value (const gchar * str)
383 {
384 if (str == NULL)
385 goto end;
386
387 if (strcmp (str, "unknown") == 0)
388 return 0;
389 else if (strcmp (str, "average") == 0)
390 return 1;
391 else if (strcmp (str, "center-weighted-average") == 0)
392 return 2;
393 else if (strcmp (str, "spot") == 0)
394 return 3;
395 else if (strcmp (str, "multi-spot") == 0)
396 return 4;
397 else if (strcmp (str, "pattern") == 0)
398 return 5;
399 else if (strcmp (str, "partial") == 0)
400 return 6;
401 else if (strcmp (str, "other") == 0)
402 return 255;
403
404 end:
405 GST_WARNING ("Invalid metering mode type: %s", str);
406 return -1;
407 }
408
409 const gchar *
__exif_tag_capturing_metering_mode_from_exif_value(gint value)410 __exif_tag_capturing_metering_mode_from_exif_value (gint value)
411 {
412 switch (value) {
413 case 0:
414 return "unknown";
415 case 1:
416 return "average";
417 case 2:
418 return "center-weighted-average";
419 case 3:
420 return "spot";
421 case 4:
422 return "multi-spot";
423 case 5:
424 return "pattern";
425 case 6:
426 return "partial";
427 case 255:
428 return "other";
429 default:
430 GST_WARNING ("Invalid metering mode type: %d", value);
431 return NULL;
432 }
433 }
434
435 gint
__exif_tag_capturing_source_to_exif_value(const gchar * str)436 __exif_tag_capturing_source_to_exif_value (const gchar * str)
437 {
438 if (str == NULL)
439 goto end;
440
441 if (strcmp (str, "dsc") == 0)
442 return 3;
443 else if (strcmp (str, "other") == 0)
444 return 0;
445 else if (strcmp (str, "transparent-scanner") == 0)
446 return 1;
447 else if (strcmp (str, "reflex-scanner") == 0)
448 return 2;
449
450 end:
451 GST_WARNING ("Invalid capturing source type: %s", str);
452 return -1;
453 }
454
455 const gchar *
__exif_tag_capturing_source_from_exif_value(gint value)456 __exif_tag_capturing_source_from_exif_value (gint value)
457 {
458 switch (value) {
459 case 0:
460 return "other";
461 case 1:
462 return "transparent-scanner";
463 case 2:
464 return "reflex-scanner";
465 case 3:
466 return "dsc";
467 default:
468 GST_WARNING ("Invalid capturing source type: %d", value);
469 return NULL;
470 }
471 }
472