1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
3 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
5 * Copyright (C) 2011, Rob Norris <rw_norris@hotmail.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 * This uses EXIF information from images to create waypoints at those positions
26 * For the implementation I have chosen to use libexif, which keeps Viking a pure C program
27 * For an alternative implementation (a la gpscorrelate), one could use libeviv2 but it appears to be C++ only.
30 #include "geotag_exif.h"
39 #include <glib/gi18n.h>
40 #include <libexif/exif-data.h>
41 #include "libjpeg/jpeg-data.h"
44 * Attempt to get a single comment from the various exif fields
46 static gchar* geotag_get_exif_comment ( ExifData *ed )
51 // Try various options to create a comment
53 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_IMAGE_DESCRIPTION);
55 exif_entry_get_value ( ee, str, 128 );
56 return g_strdup ( str );
59 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_XP_COMMENT);
61 exif_entry_get_value ( ee, str, 128 );
62 return g_strdup ( str );
65 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_XP_SUBJECT);
67 exif_entry_get_value ( ee, str, 128 );
68 return g_strdup ( str );
71 // Consider using these for existing GPS info??
72 //#define EXIF_TAG_GPS_TIME_STAMP 0x0007
73 //#define EXIF_TAG_GPS_DATE_STAMP 0x001d
74 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_EXIF], EXIF_TAG_DATE_TIME_ORIGINAL);
76 exif_entry_get_value ( ee, str, 128 );
77 return g_strdup ( str );
80 // Otherwise nothing found
85 * Handles 3 part location Rationals
86 * Handles 1 part rational (must specify 0 for the offset)
88 static gdouble Rational2Double ( unsigned char *data, int offset, ExifByteOrder order )
90 // Explaination from GPS Correlate 'exif-gps.cpp' v 1.6.1
91 // What we are trying to do here is convert the three rationals:
95 // dd/v is easy: result = dd/v.
100 // ss/v is sorta easy.
102 // -- / 3600 = result
104 // Each part is added to the final number.
107 er = exif_get_rational (data, order);
108 ans = (gdouble)er.numerator / (gdouble)er.denominator;
112 er = exif_get_rational (data+(1*offset), order);
113 ans = ans + ( ( (gdouble)er.numerator / (gdouble)er.denominator ) / 60.0 );
114 er = exif_get_rational (data+(2*offset), order);
115 ans = ans + ( ( (gdouble)er.numerator / (gdouble)er.denominator ) / 3600.0 );
121 * a_geotag_create_waypoint_from_file:
122 * @filename: The image file to process
123 * @vcmode: The current location mode to use in the positioning of Waypoint
124 * @name: Returns a name for the Waypoint (can be NULL)
126 * Returns: An allocated Waypoint or NULL if Waypoint could not be generated (e.g. no EXIF info)
129 VikWaypoint* a_geotag_create_waypoint_from_file ( const gchar *filename, VikCoordMode vcmode, gchar **name )
131 // Default return values (for failures)
133 VikWaypoint *wp = NULL;
136 //ExifLog *log = NULL;
138 // open image with libexif
139 ExifData *ed = exif_data_new_from_file ( filename );
141 // Detect EXIF load failure
143 // return with no Waypoint
151 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_VERSION_ID);
152 // Confirm this has a GPS Id - normally "2.0.0.0" or "2.2.0.0"
153 if ( ! ( ee && ee->components == 4 ) )
155 // Could test for these versions explicitly but may have byte order issues...
156 //if ( ! ( ee->data[0] == 2 && ee->data[2] == 0 && ee->data[3] == 0 ) )
160 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_MAP_DATUM);
161 if ( ! ( ee && ee->components > 0 && ee->format == EXIF_FORMAT_ASCII ) )
164 // If map datum specified - only deal in WGS-84 - the defacto standard
165 if ( ee && ee->components > 0 ) {
166 exif_entry_get_value ( ee, str, 128 );
167 if ( strncmp (str, "WGS-84", 6) )
172 // Lat & Long is necessary to form a waypoint.
174 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LATITUDE);
175 if ( ! ( ee && ee->components == 3 && ee->format == EXIF_FORMAT_RATIONAL ) )
178 ll.lat = Rational2Double ( ee->data,
179 exif_format_get_size(ee->format),
180 exif_data_get_byte_order(ed) );
182 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LATITUDE_REF);
184 exif_entry_get_value ( ee, str, 128 );
189 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LONGITUDE);
190 if ( ! ( ee && ee->components == 3 && ee->format == EXIF_FORMAT_RATIONAL ) )
193 ll.lon = Rational2Double ( ee->data,
194 exif_format_get_size(ee->format),
195 exif_data_get_byte_order(ed) );
197 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LONGITUDE_REF);
199 exif_entry_get_value ( ee, str, 128 );
205 // Not worried if none of the other fields exist, as can default the values to something
208 gdouble alt = VIK_DEFAULT_ALTITUDE;
209 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_ALTITUDE);
210 if ( ee && ee->components == 1 && ee->format == EXIF_FORMAT_RATIONAL ) {
211 alt = Rational2Double ( ee->data,
213 exif_data_get_byte_order(ed) );
215 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_ALTITUDE_REF);
216 if ( ee && ee->components == 1 && ee->format == EXIF_FORMAT_BYTE && ee->data[0] == 1 )
221 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_XP_TITLE);
223 exif_entry_get_value ( ee, str, 128 );
224 *name = g_strdup ( str );
228 // Now create Waypoint with acquired information
230 wp = vik_waypoint_new();
232 // Set info from exif values
234 vik_coord_load_from_latlon ( &(wp->coord), vcmode, &ll );
238 wp->comment = geotag_get_exif_comment ( ed );
240 vik_waypoint_set_image ( wp, filename );
243 // Finished with EXIF
244 exif_data_free ( ed );
250 * a_geotag_waypoint_positioned:
251 * @filename: The image file to process
252 * @coord: The location for positioning the Waypoint
253 * @name: Returns a name for the Waypoint (can be NULL)
254 * @waypoint: An existing waypoint to update (can be NULL to generate a new waypoint)
256 * Returns: An allocated waypoint if the input waypoint is NULL,
257 * otherwise the passed in waypoint is updated
259 * Here EXIF processing is used to get non position related information (i.e. just the comment)
262 VikWaypoint* a_geotag_waypoint_positioned ( const gchar *filename, VikCoord coord, gdouble alt, gchar **name, VikWaypoint *wp )
266 // Need to create waypoint
267 wp = vik_waypoint_new();
273 ExifData *ed = exif_data_new_from_file ( filename );
275 // Set info from exif values
277 wp->comment = geotag_get_exif_comment ( ed );
282 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_XP_TITLE);
284 exif_entry_get_value ( ee, str, 128 );
285 *name = g_strdup ( str );
288 // Finished with EXIF
289 exif_data_free ( ed );
292 vik_waypoint_set_image ( wp, filename );
298 * a_geotag_get_exif_date_from_file:
299 * @filename: The image file to process
300 * @has_GPS_info: Returns whether the file has existing GPS information
302 * Returns: An allocated string with the date and time in EXIF_DATE_FORMAT, otherwise NULL if some kind of failure
304 * Here EXIF processing is used to get time information
307 gchar* a_geotag_get_exif_date_from_file ( const gchar *filename, gboolean *has_GPS_info )
309 gchar* datetime = NULL;
310 *has_GPS_info = FALSE;
312 ExifData *ed = exif_data_new_from_file ( filename );
314 // Detect EXIF load failure
321 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_EXIF], EXIF_TAG_DATE_TIME_ORIGINAL);
323 exif_entry_get_value ( ee, str, 128 );
324 datetime = g_strdup ( str );
329 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_VERSION_ID);
330 // Confirm this has a GPS Id - normally "2.0.0.0" or "2.2.0.0"
331 if ( ee && ee->components == 4 )
332 *has_GPS_info = TRUE;
334 // Check other basic GPS fields exist too
335 // I have encountered some images which have just the EXIF_TAG_GPS_VERSION_ID but nothing else
336 // So to confirm check more EXIF GPS TAGS:
337 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LATITUDE);
339 *has_GPS_info = FALSE;
340 ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LONGITUDE);
342 *has_GPS_info = FALSE;
344 exif_data_free ( ed );
350 /**! If the entry doesn't exist, create it.
351 * Based on exif command line action_create_value function in exif 0.6.20
353 static ExifEntry* my_exif_create_value (ExifData *ed, ExifTag tag, ExifIfd ifd)
355 ExifEntry *e = exif_content_get_entry (ed->ifd[ifd], tag);
357 e = exif_entry_new ();
358 exif_content_add_entry (ed->ifd[ifd], e);
360 exif_entry_initialize (e, tag);
362 // exif_entry_initialize doesn't seem to do much, especially for the GPS tags
363 // so have to setup fields ourselves:
366 if ( tag == EXIF_TAG_GPS_VERSION_ID ) {
367 e->format = EXIF_FORMAT_BYTE;
369 e->size = sizeof (char) * e->components;
372 e->data = g_malloc (e->size);
374 if ( tag == EXIF_TAG_GPS_MAP_DATUM ||
375 tag == EXIF_TAG_GPS_LATITUDE_REF || tag == EXIF_TAG_GPS_LONGITUDE_REF ||
376 tag == EXIF_TAG_GPS_PROCESSING_METHOD ) {
377 e->format = EXIF_FORMAT_ASCII;
378 // NB Allocation is handled later on when the actual string used is known
380 if ( tag == EXIF_TAG_GPS_LATITUDE || tag == EXIF_TAG_GPS_LONGITUDE ) {
381 e->format = EXIF_FORMAT_RATIONAL;
383 e->size = sizeof (ExifRational) * e->components;
386 e->data = g_malloc (e->size);
388 if ( tag == EXIF_TAG_GPS_ALTITUDE ) {
389 e->format = EXIF_FORMAT_RATIONAL;
391 e->size = sizeof (ExifRational) * e->components;
394 e->data = g_malloc (e->size);
396 if ( tag == EXIF_TAG_GPS_ALTITUDE_REF ) {
398 e->size = sizeof (char) * e->components;
401 e->data = g_malloc (e->size);
403 /* The entry has been added to the IFD, so we can unref it */
404 //exif_entry_unref(e);
405 // Crashes later on, when saving to jpeg if the above unref is enabled!!
406 // ?Some other malloc problem somewhere?
411 /** Heavily based on convert_arg_to_entry from exif command line tool.
412 * But without ExifLog, exitting, use of g_* io functions
413 * and can take a gdouble value instead of a string
415 static void convert_to_entry (const char *set_value, gdouble gdvalue, ExifEntry *e, ExifByteOrder o)
417 unsigned int i, numcomponents;
418 char *value_p = NULL;
421 * ASCII strings are handled separately,
422 * since they don't require any conversion.
424 if (e->format == EXIF_FORMAT_ASCII ||
425 e->tag == EXIF_TAG_USER_COMMENT) {
426 if (e->data) g_free (e->data);
427 e->components = strlen (set_value) + 1;
428 if (e->tag == EXIF_TAG_USER_COMMENT)
429 e->components += 8 - 1;
430 e->size = sizeof (char) * e->components;
431 e->data = g_malloc (e->size);
433 g_warning (_("Not enough memory."));
436 if (e->tag == EXIF_TAG_USER_COMMENT) {
437 /* assume ASCII charset */
438 /* TODO: get this from the current locale */
439 memcpy ((char *) e->data, "ASCII\0\0\0", 8);
440 memcpy ((char *) e->data + 8, set_value,
443 strcpy ((char *) e->data, set_value);
448 * Make sure we can handle this entry
450 if ((e->components == 0) && *set_value) {
451 g_warning (_("Setting a value for this tag is unsupported!"));
455 gboolean use_string = (set_value != NULL);
457 /* Copy the string so we can modify it */
458 buf = g_strdup (set_value);
461 value_p = strtok (buf, " ");
464 numcomponents = e->components;
465 for (i = 0; i < numcomponents; ++i) {
470 g_warning (_("Too few components specified (need %d, found %d)\n"), numcomponents, i);
473 if (!isdigit(*value_p) && (*value_p != '+') && (*value_p != '-')) {
474 g_warning (_("Numeric value expected\n"));
479 s = exif_format_get_size (e->format);
481 case EXIF_FORMAT_ASCII:
482 g_warning (_("This shouldn't happen!"));
485 case EXIF_FORMAT_SHORT:
486 exif_set_short (e->data + (s * i), o, atoi (value_p));
488 case EXIF_FORMAT_SSHORT:
489 exif_set_sshort (e->data + (s * i), o, atoi (value_p));
491 case EXIF_FORMAT_RATIONAL: {
495 if ( use_string && value_p )
496 val = fabs (atol (value_p));
498 val = fabs (gdvalue);
501 // One (or first) part rational
503 // Sneak peek into tag as location tags need rounding down to give just the degrees part
504 if ( e->tag == EXIF_TAG_GPS_LATITUDE || e->tag == EXIF_TAG_GPS_LONGITUDE ) {
505 er.numerator = (ExifLong) floor ( val );
506 er.denominator = 1.0;
509 // I don't see any point in doing anything too complicated here,
510 // such as trying to work out the 'best' denominator
511 // For the moment use KISS principle.
512 // Fix a precision of 1/100 metre as that's more than enough for GPS accuracy especially altitudes!
513 er.denominator = 100.0;
514 er.numerator = (ExifLong) (val * er.denominator);
518 // Now for Location 3 part rationals do Mins and Seconds format
520 // Rounded down minutes
522 er.denominator = 1.0;
523 er.numerator = (ExifLong) ( (int) floor ( ( val - floor (val) ) * 60.0 ) );
528 er.denominator = 100.0;
530 // Fractional minute.
531 double FracPart = ((val - floor(val)) * 60) - (double)(int) floor ( ( val - floor (val) ) * 60.0 );
532 er.numerator = (ExifLong) ( (int)floor(FracPart * 6000) ); // Convert to seconds.
534 exif_set_rational (e->data + (s * i), o, er );
537 case EXIF_FORMAT_LONG:
538 exif_set_long (e->data + (s * i), o, atol (value_p));
540 case EXIF_FORMAT_SLONG:
541 exif_set_slong (e->data + (s * i), o, atol (value_p));
543 case EXIF_FORMAT_BYTE:
544 case EXIF_FORMAT_SBYTE:
545 case EXIF_FORMAT_UNDEFINED: /* treat as byte array */
546 e->data[s * i] = atoi (value_p);
548 case EXIF_FORMAT_FLOAT:
549 case EXIF_FORMAT_DOUBLE:
550 case EXIF_FORMAT_SRATIONAL:
552 g_warning (_("Not yet implemented!"));
557 value_p = strtok (NULL, " ");
565 g_warning (_("Warning; Too many components specified!"));
569 * a_geotag_write_exif_gps:
570 * @filename: The image file to save information in
571 * @coord: The location
572 * @alt: The elevation
574 * Returns: A value indicating success: 0, or some other value for failure
577 gint a_geotag_write_exif_gps ( const gchar *filename, VikCoord coord, gdouble alt, gboolean no_change_mtime )
579 gint result = 0; // OK so far...
581 // Save mtime for later use
582 struct stat stat_save;
583 if ( no_change_mtime )
584 stat ( filename, &stat_save );
587 Appears libexif doesn't actually support writing EXIF data directly to files
588 Thus embed command line exif writing method within Viking
589 (for example this is done by Enlightment - http://www.enlightenment.org/ )
590 This appears to be JPEG only, but is probably 99% of our use case
591 Alternatively consider using libexiv2 and C++...
594 // Actual EXIF settings here...
597 /* Parse the JPEG file. */
598 jdata = jpeg_data_new ();
599 jpeg_data_load_file (jdata, filename);
601 // Get current values
602 ExifData *ed = exif_data_new_from_file ( filename );
604 ed = exif_data_new ();
606 // Update ExifData with our new settings
609 // I don't understand it, but when saving the 'ed' nothing gets set after putting in the GPS ID tag - so it must come last
610 // (unless of course there is some bug in the setting of the ID, that prevents subsequent tags)
613 ee = my_exif_create_value (ed, EXIF_TAG_GPS_ALTITUDE, EXIF_IFD_GPS);
614 convert_to_entry ( NULL, alt, ee, exif_data_get_byte_order(ed) );
616 // byte 0 meaning "sea level" or 1 if the value is negative.
617 ee = my_exif_create_value (ed, EXIF_TAG_GPS_ALTITUDE_REF, EXIF_IFD_GPS);
618 convert_to_entry ( alt < 0.0 ? "1" : "0", 0.0, ee, exif_data_get_byte_order(ed) );
620 ee = my_exif_create_value (ed, EXIF_TAG_GPS_PROCESSING_METHOD, EXIF_IFD_GPS);
621 // see http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/GPS.html
622 convert_to_entry ( "MANUAL", 0.0, ee, exif_data_get_byte_order(ed) );
624 ee = my_exif_create_value (ed, EXIF_TAG_GPS_MAP_DATUM, EXIF_IFD_GPS);
625 convert_to_entry ( "WGS-84", 0.0, ee, exif_data_get_byte_order(ed) );
628 vik_coord_to_latlon ( &coord, &ll );
630 ee = my_exif_create_value (ed, EXIF_TAG_GPS_LATITUDE_REF, EXIF_IFD_GPS);
632 convert_to_entry ( ll.lat < 0.0 ? "S" : "N", 0.0, ee, exif_data_get_byte_order(ed) );
634 ee = my_exif_create_value (ed, EXIF_TAG_GPS_LATITUDE, EXIF_IFD_GPS);
635 convert_to_entry ( NULL, ll.lat, ee, exif_data_get_byte_order(ed) );
637 ee = my_exif_create_value (ed, EXIF_TAG_GPS_LONGITUDE_REF, EXIF_IFD_GPS);
639 convert_to_entry ( ll.lon < 0.0 ? "W" : "E", 0.0, ee, exif_data_get_byte_order(ed) );
641 ee = my_exif_create_value (ed, EXIF_TAG_GPS_LONGITUDE, EXIF_IFD_GPS);
642 convert_to_entry ( NULL, ll.lon, ee, exif_data_get_byte_order(ed) );
644 ee = my_exif_create_value (ed, EXIF_TAG_GPS_VERSION_ID, EXIF_IFD_GPS);
645 //convert_to_entry ( "2 0 0 0", 0.0, ee, exif_data_get_byte_order(ed) );
646 convert_to_entry ( "2 2 0 0", 0.0, ee, exif_data_get_byte_order(ed) );
648 jpeg_data_set_exif_data (jdata, ed);
651 /* Save the modified image. */
652 result = jpeg_data_save_file (jdata, filename);
654 // Convert result from 1 for success, 0 for failure into our scheme
657 jpeg_data_unref (jdata);
660 // Epic fail - file probably not a JPEG
664 if ( no_change_mtime ) {
665 // Restore mtime, using the saved value
666 struct stat stat_tmp;
668 stat ( filename, &stat_tmp );
669 utb.actime = stat_tmp.st_atime;
670 utb.modtime = stat_save.st_mtime;
671 utime ( filename, &utb );