static void
write_rational( ExifEntry *entry, ExifByteOrder bo, void *data )
{
ExifRational *v = (ExifRational *) data;
exif_set_rational( entry->data, bo, *v );
}
/* Does both signed and unsigned rationals from a double*.
*
* Don't change the exit entry if the value currently there is a good
* approximation of the double we are trying to set.
*/
static void
vips_exif_set_double( ExifData *ed,
ExifEntry *entry, unsigned long component, void *data )
{
double value = *((double *) data);
ExifByteOrder bo;
size_t sizeof_component;
size_t offset;
double old_value;
if( entry->components <= component ) {
VIPS_DEBUG_MSG( "vips_exif_set_double: "
"too few components\n" );
return;
}
/* Wait until after the component check to make sure we cant get /0.
*/
bo = exif_data_get_byte_order( ed );
sizeof_component = entry->size / entry->components;
offset = component * sizeof_component;
VIPS_DEBUG_MSG( "vips_exif_set_double: %s = %g\n",
vips_exif_entry_get_name( entry ), value );
if( entry->format == EXIF_FORMAT_RATIONAL ) {
ExifRational rv;
rv = exif_get_rational( entry->data + offset, bo );
old_value = (double) rv.numerator / rv.denominator;
if( VIPS_FABS( old_value - value ) > 0.0001 ) {
vips_exif_double_to_rational( value, &rv );
VIPS_DEBUG_MSG( "vips_exif_set_double: %u / %u\n",
rv.numerator,
rv.denominator );
exif_set_rational( entry->data + offset, bo, rv );
}
}
else if( entry->format == EXIF_FORMAT_SRATIONAL ) {
ExifSRational srv;
srv = exif_get_srational( entry->data + offset, bo );
old_value = (double) srv.numerator / srv.denominator;
if( VIPS_FABS( old_value - value ) > 0.0001 ) {
vips_exif_double_to_srational( value, &srv );
VIPS_DEBUG_MSG( "vips_exif_set_double: %d / %d\n",
srv.numerator, srv.denominator );
exif_set_srational( entry->data + offset, bo, srv );
}
}
}
void exif_entry_set_gps_coord(ExifData * pEdata, ExifIfd eEifd, ExifTag eEtag,
ExifRational r1, ExifRational r2, ExifRational r3)
{
ExifEntry *pE;
ExifByteOrder eO;
pE = exif_entry_new ();
exif_content_add_entry (pEdata->ifd[eEifd], pE);
exif_entry_gps_initialize(pE, eEtag);
eO = exif_data_get_byte_order (pE->parent->parent);
if (pE->data) {
exif_set_rational (pE->data, eO, r1);
exif_set_rational (pE->data + exif_format_get_size (pE->format), eO, r2);
exif_set_rational (pE->data + 2 * exif_format_get_size (pE->format), eO,
r3);
} else {
printf ("ERROR: unallocated e->data Tag %d\n", eEtag);
}
exif_entry_fix (pE);
exif_entry_unref (pE);
}
/* Does both signed and unsigned rationals from a char *.
*/
static void
vips_exif_set_rational( ExifData *ed,
ExifEntry *entry, unsigned long component, void *data )
{
char *value = (char *) data;
ExifByteOrder bo;
size_t sizeof_component;
size_t offset;
if( entry->components <= component ) {
VIPS_DEBUG_MSG( "vips_exif_set_rational: "
"too few components\n" );
return;
}
/* Wait until after the component check to make sure we cant get /0.
*/
bo = exif_data_get_byte_order( ed );
sizeof_component = entry->size / entry->components;
offset = component * sizeof_component;
VIPS_DEBUG_MSG( "vips_exif_set_rational: %s = \"%s\"\n",
vips_exif_entry_get_name( entry ), value );
if( entry->format == EXIF_FORMAT_RATIONAL ) {
ExifRational rv;
vips_exif_parse_rational( value, &rv );
VIPS_DEBUG_MSG( "vips_exif_set_rational: %u / %u\n",
rv.numerator,
rv.denominator );
exif_set_rational( entry->data + offset, bo, rv );
}
else if( entry->format == EXIF_FORMAT_SRATIONAL ) {
ExifSRational srv;
vips_exif_parse_srational( value, &srv );
VIPS_DEBUG_MSG( "vips_exif_set_rational: %d / %d\n",
srv.numerator, srv.denominator );
exif_set_srational( entry->data + offset, bo, srv );
}
}
static bool createEntry(ExifData* exifData,
ExifIfd ifd,
int tag,
const float (&values)[N],
float denominator = 1000.0) {
removeExistingEntry(exifData, ifd, tag);
ExifByteOrder byteOrder = exif_data_get_byte_order(exifData);
ExifEntry* entry = allocateEntry(tag, EXIF_FORMAT_RATIONAL, N);
exif_content_add_entry(exifData->ifd[ifd], entry);
unsigned int rationalSize = exif_format_get_size(EXIF_FORMAT_RATIONAL);
for (size_t i = 0; i < N; ++i) {
ExifRational rational = {
static_cast<uint32_t>(values[i] * denominator),
static_cast<uint32_t>(denominator)
};
exif_set_rational(&entry->data[i * rationalSize], byteOrder, rational);
}
// Unref entry after changing owner to the ExifData struct
exif_entry_unref(entry);
return true;
}
static int iExifWriteTag(ExifData* exif, int index, const char* name, int data_type, int attrib_count, const void* attrib_data)
{
int c;
ExifTag tag = exif_tag_from_name(name);
if (tag == 0)
{
if (!imStrEqual(name, "GPSVersionID")) // EXIF_TAG_GPS_VERSION_ID==0
return 1;
}
ExifEntry *entry = exif_entry_new();
ExifByteOrder byte_order = exif_data_get_byte_order(exif);
ExifContent *content;
if (name[0] == 'G' && name[1] == 'P' && name[2] == 'S')
{
content = exif->ifd[EXIF_IFD_GPS]; // GPS tags
if (!iExifGetGPSTagInfo((int)tag, &(entry->format), &(entry->components)))
{
exif_entry_free(entry);
return 1;
}
}
else
{
if (tag > EXIF_TAG_COPYRIGHT)
content = exif->ifd[EXIF_IFD_EXIF]; // EXIF tags
else
content = exif->ifd[EXIF_IFD_0]; // TIFF tags
if (!iExifGetTagInfo(tag, &(entry->format), &(entry->components)))
{
exif_entry_free(entry);
return 1;
}
}
int format_size = exif_format_get_size(entry->format);
if (entry->components == 0)
entry->components = attrib_count;
entry->tag = tag;
entry->size = format_size * entry->components;
entry->data = (imbyte*)malloc(entry->size);
if (tag == EXIF_TAG_RESOLUTION_UNIT)
{
int res_unit;
if (imStrEqual((char*)attrib_data, "DPI"))
res_unit = 2;
else
res_unit = 3;
exif_content_add_entry(content, entry);
exif_set_short(entry->data, byte_order, (imushort)res_unit);
return 1;
}
/* test if tag type is the same as the attribute type */
if (iExifGetDataType(entry->format) != data_type)
{
exif_entry_free(entry);
return 1;
}
exif_content_add_entry(content, entry);
switch (entry->format)
{
case EXIF_FORMAT_UNDEFINED:
case EXIF_FORMAT_ASCII:
case EXIF_FORMAT_SBYTE:
case EXIF_FORMAT_BYTE:
{
imbyte *bvalue = (imbyte*)attrib_data;
for (c = 0; c < (int)entry->components; c++)
entry->data[c] = bvalue[c];
}
break;
case EXIF_FORMAT_SHORT:
{
imushort *usvalue = (imushort*)attrib_data;
for (c = 0; c < (int)entry->components; c++)
exif_set_short(entry->data + format_size * c, byte_order, usvalue[c]);
}
break;
case EXIF_FORMAT_SSHORT:
{
short *svalue = (short*)attrib_data;
for (c = 0; c < (int)entry->components; c++)
exif_set_sshort(entry->data + format_size * c, byte_order, svalue[c]);
}
break;
case EXIF_FORMAT_LONG:
{
int *ivalue = (int*)attrib_data;
for (c = 0; c < (int)entry->components; c++)
exif_set_long(entry->data + format_size * c, byte_order, (unsigned int)ivalue[c]);
}
break;
case EXIF_FORMAT_SLONG:
{
int *ivalue = (int*)attrib_data;
for (c = 0; c < (int)entry->components; c++)
exif_set_slong(entry->data + format_size * c, byte_order, (int)ivalue[c]);
}
break;
case EXIF_FORMAT_RATIONAL:
{
ExifRational v_rat;
int num, den;
float *fvalue = (float*)attrib_data;
for (c = 0; c < (int)entry->components; c++)
{
iGetRational(fvalue[c], &num, &den, 1);
v_rat.numerator = num;
v_rat.denominator = den;
exif_set_rational(entry->data + format_size * c, byte_order, v_rat);
}
}
break;
case EXIF_FORMAT_SRATIONAL:
{
ExifSRational v_srat;
int num, den;
float *fvalue = (float*)attrib_data;
for (c = 0; c < (int)entry->components; c++)
{
iGetRational(fvalue[c], &num, &den, 1);
v_srat.numerator = num;
v_srat.denominator = den;
exif_set_srational(entry->data + format_size * c, byte_order, v_srat);
}
}
break;
case EXIF_FORMAT_FLOAT: // defined but unsupported in libEXIF
case EXIF_FORMAT_DOUBLE: // defined but unsupported in libEXIF
break;
}
/* no need to release the entry here,
it will be handled internally
because we added the entry to the ExifContent */
(void)index;
return 1;
}
static void
metadatamux_exif_for_each_tag_in_list (const GstTagList * list,
const gchar * tag, gpointer user_data)
{
ExifData *ed = (ExifData *) user_data;
ExifTag exif_tag;
GType type = G_TYPE_INVALID;
ExifEntry *entry = NULL;
ExifIfd ifd = EXIF_IFD_COUNT;
const ExifByteOrder byte_order = exif_data_get_byte_order (ed);
exif_tag = metadatamux_exif_get_exif_from_tag (tag, &type, &ifd);
if (!exif_tag)
goto done;
entry = exif_data_get_entry (ed, exif_tag);
if (entry)
exif_entry_ref (entry);
else {
entry = exif_entry_new ();
exif_content_add_entry (ed->ifd[ifd], entry);
exif_entry_initialize (entry, exif_tag);
}
if (entry->data == NULL) {
if (entry->tag == EXIF_TAG_GPS_ALTITUDE) {
entry->format = EXIF_FORMAT_RATIONAL;
entry->components = 1;
entry->size = exif_format_get_size (entry->format) * entry->components;
entry->data = g_malloc (entry->size);
} else if (entry->tag == EXIF_TAG_GPS_LATITUDE
|| entry->tag == EXIF_TAG_GPS_LONGITUDE) {
entry->format = EXIF_FORMAT_RATIONAL;
entry->components = 3;
entry->size = exif_format_get_size (entry->format) * entry->components;
entry->data = g_malloc (entry->size);
}
}
if (type == GST_TYPE_FRACTION) {
const GValue *gvalue = gst_tag_list_get_value_index (list, tag, 0);
gint numerator = gst_value_get_fraction_numerator (gvalue);
gint denominator = gst_value_get_fraction_denominator (gvalue);
switch (entry->format) {
case EXIF_FORMAT_SRATIONAL:
{
ExifSRational sr = { numerator, denominator };
exif_set_srational (entry->data, byte_order, sr);
}
break;
case EXIF_FORMAT_RATIONAL:
{
ExifRational r;
if (entry->tag == EXIF_TAG_X_RESOLUTION ||
entry->tag == EXIF_TAG_Y_RESOLUTION) {
ExifEntry *unit_entry = NULL;
unit_entry = exif_data_get_entry (ed, EXIF_TAG_RESOLUTION_UNIT);
if (unit_entry) {
ExifShort vsh = exif_get_short (unit_entry->data, byte_order);
if (vsh != 2) /* inches */
exif_set_short (unit_entry->data, byte_order, 2);
}
}
r.numerator = numerator;
r.denominator = denominator;
if (numerator < 0)
r.numerator = -numerator;
if (denominator < 0)
r.denominator = -denominator;
exif_set_rational (entry->data, byte_order, r);
}
break;
default:
break;
}
} else if (type == GST_TYPE_BUFFER) {
const GValue *val = NULL;
GstBuffer *buf;
val = gst_tag_list_get_value_index (list, tag, 0);
buf = gst_value_get_buffer (val);
entry->components = GST_BUFFER_SIZE (buf);
entry->size = GST_BUFFER_SIZE (buf);
entry->data = g_malloc (entry->size);
memcpy (entry->data, GST_BUFFER_DATA (buf), entry->size);
} else {
switch (type) {
case G_TYPE_STRING:
{
gchar *value = NULL;
if (gst_tag_list_get_string (list, tag, &value)) {
if (entry->tag == EXIF_TAG_DATE_TIME_DIGITIZED
|| entry->tag == EXIF_TAG_DATE_TIME
|| entry->tag == EXIF_TAG_DATE_TIME_ORIGINAL) {
GString *datetime = g_string_new_len (value,
20); /* enough memory to hold "YYYY:MM:DD HH:MM:SS" */
if (metadatamux_exif_convert_from_datetime (datetime)) {
} else {
GST_ERROR ("Unexpected date & time format for %s", tag);
}
g_free (value);
value = datetime->str;
g_string_free (datetime, FALSE);
} else if (value) {
entry->components = strlen (value) + 1;
entry->size =
exif_format_get_size (entry->format) * entry->components;
entry->data = (guint8 *) value;
value = NULL;
}
}
}
break;
case G_TYPE_UINT:
case G_TYPE_INT:
{
gint value;
ExifShort v_short;
if (G_TYPE_UINT == type) {
gst_tag_list_get_uint (list, tag, (guint *) & value);
} else {
gst_tag_list_get_int (list, tag, &value);
}
switch (entry->format) {
case EXIF_FORMAT_SHORT:
if (entry->tag == EXIF_TAG_CONTRAST
|| entry->tag == EXIF_TAG_SATURATION) {
if (value < -33)
value = 1; /* low */
else if (value < 34)
value = 0; /* normal */
else
value = 2; /* high */
}
v_short = value;
exif_set_short (entry->data, byte_order, v_short);
break;
case EXIF_FORMAT_LONG:
exif_set_long (entry->data, byte_order, value);
break;
default:
break;
}
}
break;
case G_TYPE_DOUBLE:
{
gdouble value;
gst_tag_list_get_double (list, tag, &value);
if (entry->tag == EXIF_TAG_GPS_LATITUDE
|| entry->tag == EXIF_TAG_GPS_LONGITUDE) {
ExifRational *rt = (ExifRational *) entry->data;
gdouble v = fabs (value);
ExifEntry *ref_entry = NULL;
char ref;
const ExifTag ref_tag = entry->tag == EXIF_TAG_GPS_LATITUDE ?
EXIF_TAG_GPS_LATITUDE_REF : EXIF_TAG_GPS_LONGITUDE_REF;
/* DDD - degrees */
rt->numerator = (gulong) v;
rt->denominator = 1;
GST_DEBUG ("deg: %lf : %lu / %lu", v, (gulong) rt->numerator,
(gulong) rt->denominator);
v -= rt->numerator;
rt++;
/* MM - minutes */
rt->numerator = (gulong) (v * 60.0);
rt->denominator = 1;
GST_DEBUG ("min: %lf : %lu / %lu", v, (gulong) rt->numerator,
(gulong) rt->denominator);
v -= ((gdouble) rt->numerator / 60.0);
rt++;
/* SS - seconds */
rt->numerator = (gulong) (0.5 + v * 3600.0);
rt->denominator = 1;
GST_DEBUG ("sec: %lf : %lu / %lu", v, (gulong) rt->numerator,
(gulong) rt->denominator);
if (entry->tag == EXIF_TAG_GPS_LONGITUDE) {
GST_DEBUG ("longitude : %lf", value);
ref = (value < 0.0) ? 'W' : 'E';
} else {
GST_DEBUG ("latitude : %lf", value);
ref = (value < 0.0) ? 'S' : 'N';
}
ref_entry = exif_data_get_entry (ed, ref_tag);
if (ref_entry) {
exif_entry_ref (ref_entry);
} else {
ref_entry = exif_entry_new ();
exif_content_add_entry (ed->ifd[EXIF_IFD_GPS], ref_entry);
exif_entry_initialize (ref_entry, ref_tag);
}
if (ref_entry->data == NULL) {
ref_entry->format = EXIF_FORMAT_ASCII;
ref_entry->components = 2;
ref_entry->size = 2;
ref_entry->data = g_malloc (2);
}
ref_entry->data[0] = ref;
ref_entry->data[1] = 0;
exif_entry_unref (ref_entry);
} else if (entry->tag == EXIF_TAG_GPS_ALTITUDE) {
ExifEntry *ref_entry = NULL;
ExifRational *rt = (ExifRational *) entry->data;
rt->numerator = (gulong) fabs (10.0 * value);
rt->denominator = 10;
GST_DEBUG ("altitude : %lf", value);
ref_entry = exif_data_get_entry (ed, EXIF_TAG_GPS_ALTITUDE_REF);
if (ref_entry) {
exif_entry_ref (ref_entry);
} else {
ref_entry = exif_entry_new ();
exif_content_add_entry (ed->ifd[EXIF_IFD_GPS], ref_entry);
exif_entry_initialize (ref_entry, EXIF_TAG_GPS_ALTITUDE_REF);
}
if (ref_entry->data == NULL) {
ref_entry->format = EXIF_FORMAT_BYTE;
ref_entry->components = 1;
ref_entry->size = 1;
ref_entry->data = g_malloc (1);
}
if (value > 0.0) {
ref_entry->data[0] = 0;
} else {
ref_entry->data[0] = 1;
}
exif_entry_unref (ref_entry);
}
}
break;
default:
break;
}
}
done:
if (entry)
exif_entry_unref (entry);
}
void
jpeg_setup_exif_for_save (ExifData *exif_data,
const gint32 image_ID)
{
ExifRational r;
gdouble xres, yres;
ExifEntry *entry;
gint byte_order = exif_data_get_byte_order (exif_data);
/* set orientation to top - left */
if ((entry = exif_content_get_entry (exif_data->ifd[EXIF_IFD_0],
EXIF_TAG_ORIENTATION)))
{
exif_set_short (entry->data, byte_order, (ExifShort) 1);
}
/* set x and y resolution */
gimp_image_get_resolution (image_ID, &xres, &yres);
r.numerator = xres;
r.denominator = 1;
if ((entry = exif_content_get_entry (exif_data->ifd[EXIF_IFD_0],
EXIF_TAG_X_RESOLUTION)))
{
exif_set_rational (entry->data, byte_order, r);
}
r.numerator = yres;
if ((entry = exif_content_get_entry (exif_data->ifd[EXIF_IFD_0],
EXIF_TAG_Y_RESOLUTION)))
{
exif_set_rational (entry->data, byte_order, r);
}
/* set resolution unit, always inches */
if ((entry = exif_content_get_entry (exif_data->ifd[EXIF_IFD_0],
EXIF_TAG_RESOLUTION_UNIT)))
{
exif_set_short (entry->data, byte_order, (ExifShort) 2);
}
/* set software to "GIMP" and include the version number */
if ((entry = exif_content_get_entry (exif_data->ifd[EXIF_IFD_0],
EXIF_TAG_SOFTWARE)))
{
const gchar *name = "GIMP " GIMP_VERSION;
entry->data = (guchar *) g_strdup (name);
entry->size = strlen (name) + 1;
entry->components = entry->size;
}
/* set the width and height */
if ((entry = exif_content_get_entry (exif_data->ifd[EXIF_IFD_EXIF],
EXIF_TAG_PIXEL_X_DIMENSION)))
{
exif_set_long (entry->data, byte_order,
(ExifLong) gimp_image_width (image_ID));
}
if ((entry = exif_content_get_entry (exif_data->ifd[EXIF_IFD_EXIF],
EXIF_TAG_PIXEL_Y_DIMENSION)))
{
exif_set_long (entry->data, byte_order,
(ExifLong) gimp_image_height (image_ID));
}
/*
* set the date & time image was saved
* note, date & time of original photo is stored elsewwhere, we
* aren't losing it.
*/
if ((entry = exif_content_get_entry (exif_data->ifd[EXIF_IFD_0],
EXIF_TAG_DATE_TIME)))
{
/* small memory leak here */
entry->data = NULL;
exif_entry_initialize (entry, EXIF_TAG_DATE_TIME);
}
/* should set components configuration, don't know how */
/*
* remove entries that don't apply to jpeg
* (may have come from tiff or raw)
*/
gimp_exif_data_remove_entry (exif_data, EXIF_IFD_0, EXIF_TAG_COMPRESSION);
gimp_exif_data_remove_entry (exif_data, EXIF_IFD_0, EXIF_TAG_IMAGE_WIDTH);
gimp_exif_data_remove_entry (exif_data, EXIF_IFD_0, EXIF_TAG_IMAGE_LENGTH);
gimp_exif_data_remove_entry (exif_data, EXIF_IFD_0, EXIF_TAG_BITS_PER_SAMPLE);
gimp_exif_data_remove_entry (exif_data, EXIF_IFD_0, EXIF_TAG_SAMPLES_PER_PIXEL);
gimp_exif_data_remove_entry (exif_data, EXIF_IFD_0, EXIF_TAG_PHOTOMETRIC_INTERPRETATION);
gimp_exif_data_remove_entry (exif_data, EXIF_IFD_0, EXIF_TAG_STRIP_OFFSETS);
gimp_exif_data_remove_entry (exif_data, EXIF_IFD_0, EXIF_TAG_PLANAR_CONFIGURATION);
gimp_exif_data_remove_entry (exif_data, EXIF_IFD_0, EXIF_TAG_YCBCR_SUB_SAMPLING);
/* should set thumbnail attributes */
}
/** Heavily based on convert_arg_to_entry from exif command line tool.
* But without ExifLog, exitting, use of g_* io functions
* and can take a gdouble value instead of a string
*/
static void convert_to_entry (const char *set_value, gdouble gdvalue, ExifEntry *e, ExifByteOrder o)
{
unsigned int i, numcomponents;
char *value_p = NULL;
char *buf = NULL;
/*
* ASCII strings are handled separately,
* since they don't require any conversion.
*/
if (e->format == EXIF_FORMAT_ASCII ||
e->tag == EXIF_TAG_USER_COMMENT) {
if (e->data) g_free (e->data);
e->components = strlen (set_value) + 1;
if (e->tag == EXIF_TAG_USER_COMMENT)
e->components += 8 - 1;
e->size = sizeof (char) * e->components;
e->data = g_malloc (e->size);
if (!e->data) {
g_warning (_("Not enough memory."));
return;
}
if (e->tag == EXIF_TAG_USER_COMMENT) {
/* assume ASCII charset */
/* TODO: get this from the current locale */
memcpy ((char *) e->data, "ASCII\0\0\0", 8);
memcpy ((char *) e->data + 8, set_value,
strlen (set_value));
} else
strcpy ((char *) e->data, set_value);
return;
}
/*
* Make sure we can handle this entry
*/
if ((e->components == 0) && *set_value) {
g_warning (_("Setting a value for this tag is unsupported!"));
return;
}
gboolean use_string = (set_value != NULL);
if ( use_string ) {
/* Copy the string so we can modify it */
buf = g_strdup (set_value);
if (!buf)
return;
value_p = strtok (buf, " ");
}
numcomponents = e->components;
for (i = 0; i < numcomponents; ++i) {
unsigned char s;
if ( use_string ) {
if (!value_p) {
g_warning (_("Too few components specified (need %d, found %d)\n"), numcomponents, i);
return;
}
if (!isdigit(*value_p) && (*value_p != '+') && (*value_p != '-')) {
g_warning (_("Numeric value expected\n"));
return;
}
}
s = exif_format_get_size (e->format);
switch (e->format) {
case EXIF_FORMAT_ASCII:
g_warning (_("This shouldn't happen!"));
return;
break;
case EXIF_FORMAT_SHORT:
exif_set_short (e->data + (s * i), o, atoi (value_p));
break;
case EXIF_FORMAT_SSHORT:
exif_set_sshort (e->data + (s * i), o, atoi (value_p));
break;
case EXIF_FORMAT_RATIONAL: {
ExifRational er;
double val = 0.0 ;
if ( use_string && value_p )
val = fabs (atol (value_p));
else
val = fabs (gdvalue);
if ( i == 0 ) {
// One (or first) part rational
// Sneak peek into tag as location tags need rounding down to give just the degrees part
if ( e->tag == EXIF_TAG_GPS_LATITUDE || e->tag == EXIF_TAG_GPS_LONGITUDE ) {
er.numerator = (ExifLong) floor ( val );
er.denominator = 1.0;
}
else {
// I don't see any point in doing anything too complicated here,
// such as trying to work out the 'best' denominator
// For the moment use KISS principle.
// Fix a precision of 1/100 metre as that's more than enough for GPS accuracy especially altitudes!
er.denominator = 100.0;
er.numerator = (ExifLong) (val * er.denominator);
}
}
// Now for Location 3 part rationals do Mins and Seconds format
// Rounded down minutes
if ( i == 1 ) {
er.denominator = 1.0;
er.numerator = (ExifLong) ( (int) floor ( ( val - floor (val) ) * 60.0 ) );
}
// Finally seconds
if ( i == 2 ) {
er.denominator = 100.0;
// Fractional minute.
double FracPart = ((val - floor(val)) * 60) - (double)(int) floor ( ( val - floor (val) ) * 60.0 );
er.numerator = (ExifLong) ( (int)floor(FracPart * 6000) ); // Convert to seconds.
}
exif_set_rational (e->data + (s * i), o, er );
break;
}
case EXIF_FORMAT_LONG:
exif_set_long (e->data + (s * i), o, atol (value_p));
break;
case EXIF_FORMAT_SLONG:
exif_set_slong (e->data + (s * i), o, atol (value_p));
break;
case EXIF_FORMAT_BYTE:
case EXIF_FORMAT_SBYTE:
case EXIF_FORMAT_UNDEFINED: /* treat as byte array */
e->data[s * i] = atoi (value_p);
break;
case EXIF_FORMAT_FLOAT:
case EXIF_FORMAT_DOUBLE:
case EXIF_FORMAT_SRATIONAL:
default:
g_warning (_("Not yet implemented!"));
return;
}
if ( use_string )
value_p = strtok (NULL, " ");
}
g_free (buf);
if ( use_string )
if ( value_p )
g_warning (_("Warning; Too many components specified!"));
}