/**
* a_geotag_create_waypoint_positioned:
* @filename: The image file to process
* @coord: The location for positioning the Waypoint
* @name: Returns a name for the Waypoint (can be NULL)
*
* Returns: An allocated Waypoint or NULL if Waypoint could not be generated
*
* Here EXIF processing is used to get non position related information (i.e. just the comment)
*
*/
VikWaypoint* a_geotag_create_waypoint_positioned ( const gchar *filename, VikCoord coord, gdouble alt, gchar **name )
{
*name = NULL;
VikWaypoint *wp = vik_waypoint_new();
wp->visible = TRUE;
wp->coord = coord;
wp->altitude = alt;
ExifData *ed = exif_data_new_from_file ( filename );
// Set info from exif values
if ( ed ) {
wp->comment = geotag_get_exif_comment ( ed );
gchar str[128];
ExifEntry *ee;
// Name
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_XP_TITLE);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
*name = g_strdup ( str );
}
// Finished with EXIF
exif_data_free ( ed );
}
vik_waypoint_set_image ( wp, filename );
return wp;
}
// Implementation using libexif
void ImageResolution::readexif(char const *fn) {
ExifData *ed;
ed = exif_data_new_from_file(fn);
if (!ed)
return;
ExifByteOrder byte_order = exif_data_get_byte_order(ed);
ExifEntry *xres = exif_content_get_entry(ed->ifd[EXIF_IFD_0],
EXIF_TAG_X_RESOLUTION);
ExifEntry *yres = exif_content_get_entry(ed->ifd[EXIF_IFD_0],
EXIF_TAG_Y_RESOLUTION);
ExifEntry *unit = exif_content_get_entry(ed->ifd[EXIF_IFD_0],
EXIF_TAG_RESOLUTION_UNIT);
if (xres && yres) {
x_ = exifDouble(xres, byte_order);
y_ = exifDouble(yres, byte_order);
if (unit) {
double u = exifDouble(unit, byte_order);
if (u==3) {
x_ *= 2.54;
y_ *= 2.54;
}
}
ok_ = true;
}
exif_data_free(ed);
}
static bool readExif(const char* path, float& shutter)
{
ExifData* data = exif_data_new_from_file(path);
if (data == nullptr)
return false;
ExifEntry *shutterEnt;
shutterEnt = exif_content_get_entry(data->ifd[EXIF_IFD_EXIF],
EXIF_TAG_EXPOSURE_TIME);
if(!shutterEnt)
shutterEnt = exif_content_get_entry(data->ifd[EXIF_IFD_0],
EXIF_TAG_EXPOSURE_TIME);
if(!shutterEnt)
shutterEnt = exif_content_get_entry(data->ifd[EXIF_IFD_1],
EXIF_TAG_EXPOSURE_TIME);
if(shutterEnt == NULL){
fprintf(stderr, "Error: Cannot read photography info.\n");
exif_data_unref(data);
return false;
}
char buf[1024];
exif_entry_get_value(shutterEnt, buf, sizeof(buf));
printf("shutter = %s\n", buf);
ExifSRational r;
r = exif_get_srational(shutterEnt->data, exif_data_get_byte_order(data));
shutter = (float)r.numerator / (float)r.denominator;
// Close
exif_data_unref(data);
return true;
}
///@todo create a dedicated EXIF class
QString ImageImporter::getExifData(const QString& filename, ExifTag tag)
{
ExifData* ed = exif_data_new_from_file(filename.ascii());
ExifContent* c0, * c1, * cExif;
c0 = ed->ifd[EXIF_IFD_0];
c1 = ed->ifd[EXIF_IFD_1];
cExif = ed->ifd[EXIF_IFD_EXIF];
switch (tag) {
case EXIF_TAG_MAKE:
case EXIF_TAG_MODEL:
case EXIF_TAG_SOFTWARE:
return getEntry(c0, tag);
break;
case EXIF_TAG_EXPOSURE_TIME:
case EXIF_TAG_FNUMBER:
case EXIF_TAG_PIXEL_X_DIMENSION:
case EXIF_TAG_PIXEL_Y_DIMENSION:
case EXIF_TAG_FLASH:
case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM:
case EXIF_TAG_ISO_SPEED_RATINGS:
case EXIF_TAG_DATE_TIME_ORIGINAL:
return getEntry(cExif, tag);
break;
default:
return "";
break;
}
exif_data_free(ed);
}
long GalleryUtil::GetNaturalRotation(const QString &filePathString)
{
long rotateAngle = 0;
#ifdef EXIF_SUPPORT
QByteArray filePathBA = filePathString.toLocal8Bit();
const char *filePath = filePathBA.constData();
try
{
ExifData *data = exif_data_new_from_file(filePath);
if (data)
{
rotateAngle = GetNaturalRotation(data);
exif_data_free(data);
}
else
{
LOG(VB_FILE, LOG_ERR, LOC +
QString("Could not load exif data from '%1'") .arg(filePath));
}
}
catch (...)
{
LOG(VB_GENERAL, LOG_ERR, LOC +
QString("Failed to extract EXIF headers from '%1'") .arg(filePath));
}
#else
// Shut the compiler up about the unused argument
(void)filePathString;
#endif
return rotateAngle;
}
/**
* a_geotag_get_exif_date_from_file:
* @filename: The image file to process
* @has_GPS_info: Returns whether the file has existing GPS information
*
* Returns: An allocated string with the date and time in EXIF_DATE_FORMAT, otherwise NULL if some kind of failure
*
* Here EXIF processing is used to get time information
*
*/
gchar* a_geotag_get_exif_date_from_file ( const gchar *filename, gboolean *has_GPS_info )
{
gchar* datetime = NULL;
ExifData *ed = exif_data_new_from_file ( filename );
// Detect EXIF load failure
if ( !ed )
return datetime;
gchar str[128];
ExifEntry *ee;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_EXIF], EXIF_TAG_DATE_TIME_ORIGINAL);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
datetime = g_strdup ( str );
}
// Check GPS Info
*has_GPS_info = FALSE;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_VERSION_ID);
// Confirm this has a GPS Id - normally "2.0.0.0" or "2.2.0.0"
if ( ee && ee->components == 4 )
*has_GPS_info = TRUE;
exif_data_free ( ed );
return datetime;
}
QPixmap ExifPixmap::createPixmap(QString path)
{
ExifData *exifData = exif_data_new_from_file(path.toStdString().c_str());
int orientation = 0;
if(exifData) {
ExifByteOrder byteOrder = exif_data_get_byte_order(exifData);
ExifEntry *exifEntry = exif_data_get_entry(exifData, EXIF_TAG_ORIENTATION);
if(exifEntry) {
orientation = exif_get_short(exifEntry->data, byteOrder);
}
exif_data_free(exifData);
}
QPixmap pic(path);
/*
0th Row 0th Column
1 top left side
2 top right side
3 bottom right side
4 bottom left side
5 left side top
6 right side top
7 right side bottom
8 left side bottom
*/
QTransform t;
switch(orientation) { // TODO : test flips
case 1:
break;
case 2:
t.scale(-1,1);
break;
case 3:
t.rotate(180);
break;
case 4:
t.rotate(180);
t.scale(-1,1);
break;
case 5:
t.rotate(90);
t.scale(-1,1);
break;
case 6:
t.rotate(90);
break;
case 7:
t.rotate(-90);
t.scale(-1,1);
break;
case 8:
t.rotate(-90);
break;
default:
break;
}
return pic.transformed(t);
}
static QImage* reorient_with_exif( producer_qimage self, int image_idx, QImage *qimage )
{
#ifdef USE_EXIF
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( &self->parent );
ExifData *d = exif_data_new_from_file( mlt_properties_get_value( self->filenames, image_idx ) );
ExifEntry *entry;
int exif_orientation = 0;
/* get orientation and rotate image accordingly if necessary */
if (d) {
if ( ( entry = exif_content_get_entry ( d->ifd[EXIF_IFD_0], EXIF_TAG_ORIENTATION ) ) )
exif_orientation = exif_get_short (entry->data, exif_data_get_byte_order (d));
/* Free the EXIF data */
exif_data_unref(d);
}
// Remember EXIF value, might be useful for someone
mlt_properties_set_int( producer_props, "_exif_orientation" , exif_orientation );
if ( exif_orientation > 1 )
{
// Rotate image according to exif data
QImage processed;
QMatrix matrix;
switch ( exif_orientation ) {
case 2:
matrix.scale( -1, 1 );
break;
case 3:
matrix.rotate( 180 );
break;
case 4:
matrix.scale( 1, -1 );
break;
case 5:
matrix.rotate( 270 );
matrix.scale( -1, 1 );
break;
case 6:
matrix.rotate( 90 );
break;
case 7:
matrix.rotate( 90 );
matrix.scale( -1, 1 );
break;
case 8:
matrix.rotate( 270 );
break;
}
processed = qimage->transformed( matrix );
delete qimage;
qimage = new QImage( processed );
}
#endif
return qimage;
}
/**
* a_geotag_get_exif_date_from_file:
* @filename: The image file to process
* @has_GPS_info: Returns whether the file has existing GPS information
*
* Returns: An allocated string with the date and time in EXIF_DATE_FORMAT, otherwise NULL if some kind of failure
*
* Here EXIF processing is used to get time information
*
*/
gchar* a_geotag_get_exif_date_from_file ( const gchar *filename, gboolean *has_GPS_info )
{
gchar* datetime = NULL;
*has_GPS_info = FALSE;
#ifdef HAVE_LIBGEXIV2
GExiv2Metadata *gemd = gexiv2_metadata_new ();
if ( gexiv2_metadata_open_path ( gemd, filename, NULL ) ) {
gdouble lat, lon;
*has_GPS_info = ( gexiv2_metadata_get_gps_longitude(gemd,&lon) && gexiv2_metadata_get_gps_latitude(gemd,&lat) );
// Prefer 'Photo' version over 'Image'
if ( gexiv2_metadata_has_tag ( gemd, "Exif.Photo.DateTimeOriginal" ) )
datetime = g_strdup ( gexiv2_metadata_get_tag_interpreted_string ( gemd, "Exif.Photo.DateTimeOriginal" ) );
else
datetime = g_strdup ( gexiv2_metadata_get_tag_interpreted_string ( gemd, "Exif.Image.DateTimeOriginal" ) );
}
metadata_free ( gemd );
#else
#ifdef HAVE_LIBEXIF
ExifData *ed = exif_data_new_from_file ( filename );
// Detect EXIF load failure
if ( !ed )
return datetime;
gchar str[128];
ExifEntry *ee;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_EXIF], EXIF_TAG_DATE_TIME_ORIGINAL);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
datetime = g_strdup ( str );
}
// Check GPS Info
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_VERSION_ID);
// Confirm this has a GPS Id - normally "2.0.0.0" or "2.2.0.0"
if ( ee && ee->components == 4 )
*has_GPS_info = TRUE;
// Check other basic GPS fields exist too
// I have encountered some images which have just the EXIF_TAG_GPS_VERSION_ID but nothing else
// So to confirm check more EXIF GPS TAGS:
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LATITUDE);
if ( !ee )
*has_GPS_info = FALSE;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LONGITUDE);
if ( !ee )
*has_GPS_info = FALSE;
exif_data_free ( ed );
#endif
#endif
return datetime;
}
/* return data structure with exif data if available */
ExifData * exif_get_data(char *path)
{
ExifData *ed = NULL;
/* Load an ExifData object from an EXIF file */
ed = exif_data_new_from_file(path);
if (ed == NULL)
{
D(("File not readable or no Exif data present in %s\n", path));
}
return(ed);
}
gboolean
rstto_file_has_exif ( RsttoFile *r_file )
{
if ( NULL == r_file->priv->exif_data )
{
r_file->priv->exif_data = exif_data_new_from_file ( rstto_file_get_path (r_file) );
}
if ( NULL == r_file->priv->exif_data )
{
return FALSE;
}
return TRUE;
}
void Image::load_tags( const gchar * filename )
{
g_assert( filename );
if ( ExifData * ed = exif_data_new_from_file( filename ) )
{
load_exif_tags( ed , tags );
exif_data_unref( ed );
}
else
{
tplog2( " FAILED TO LOAD TAGS" );
}
}
//#include "libexif/exif-tag.h" //EXIF_TAG_ORIENTATION
enum Orientation orient( const char * path) {
enum Orientation orientation = NOT_AVAILABLE;
ExifData * mExifData = exif_data_new_from_file( path);
if (mExifData) {
ExifEntry * mOrientationEntry = exif_content_get_entry( mExifData->ifd[ EXIF_IFD_0], EXIF_TAG_ORIENTATION);
if (mOrientationEntry) {
ExifByteOrder mByteOrder = exif_data_get_byte_order( mExifData);
short value=exif_get_short( mOrientationEntry->data, mByteOrder);
if (value>=NORMAL && value<=ROT_270)
orientation = value; //Orientation( value);
}
exif_data_unref( mExifData );
}
return orientation;
}
/**
* a_geotag_waypoint_positioned:
* @filename: The image file to process
* @coord: The location for positioning the Waypoint
* @name: Returns a name for the Waypoint (can be NULL)
* @waypoint: An existing waypoint to update (can be NULL to generate a new waypoint)
*
* Returns: An allocated waypoint if the input waypoint is NULL,
* otherwise the passed in waypoint is updated
*
* Here EXIF processing is used to get non position related information (i.e. just the comment)
*
*/
VikWaypoint* a_geotag_waypoint_positioned ( const gchar *filename, VikCoord coord, gdouble alt, gchar **name, VikWaypoint *wp )
{
*name = NULL;
if ( wp == NULL ) {
// Need to create waypoint
wp = vik_waypoint_new();
wp->visible = TRUE;
}
wp->coord = coord;
wp->altitude = alt;
#ifdef HAVE_LIBGEXIV2
GExiv2Metadata *gemd = gexiv2_metadata_new ();
if ( gexiv2_metadata_open_path ( gemd, filename, NULL ) ) {
wp->comment = geotag_get_exif_comment ( gemd );
if ( gexiv2_metadata_has_tag ( gemd, "Exif.Image.XPTitle" ) )
*name = g_strdup ( gexiv2_metadata_get_tag_interpreted_string ( gemd, "Exif.Image.XPTitle" ) );
}
metadata_free ( gemd );
#else
#ifdef HAVE_LIBEXIF
ExifData *ed = exif_data_new_from_file ( filename );
// Set info from exif values
if ( ed ) {
wp->comment = geotag_get_exif_comment ( ed );
gchar str[128];
ExifEntry *ee;
// Name
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_XP_TITLE);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
*name = g_strdup ( str );
}
// Finished with EXIF
exif_data_free ( ed );
}
#endif
#endif
vik_waypoint_set_image ( wp, filename );
return wp;
}
void exif_auto_orientate(const fileinfo_t *file) {
ExifData *ed;
ExifEntry *entry;
int byte_order, orientation;
if ((ed = exif_data_new_from_file(file->path)) == NULL)
return;
entry = exif_content_get_entry(ed->ifd[EXIF_IFD_0], EXIF_TAG_ORIENTATION);
if (entry != NULL) {
byte_order = exif_data_get_byte_order(ed);
orientation = exif_get_short(entry->data, byte_order);
}
exif_data_unref(ed);
if (entry == NULL)
return;
switch (orientation) {
case 5:
imlib_image_orientate(1);
case 2:
imlib_image_flip_vertical();
break;
case 3:
imlib_image_orientate(2);
break;
case 7:
imlib_image_orientate(1);
case 4:
imlib_image_flip_horizontal();
break;
case 6:
imlib_image_orientate(1);
break;
case 8:
imlib_image_orientate(3);
break;
}
}
ExifEntry *
rstto_file_get_exif ( RsttoFile *r_file, ExifTag id )
{
/* If there is no exif-data object, try to create it */
if ( NULL == r_file->priv->exif_data )
{
r_file->priv->exif_data = exif_data_new_from_file (
rstto_file_get_path (r_file) );
}
if ( NULL != r_file->priv->exif_data )
{
return exif_data_get_entry (
r_file->priv->exif_data,
id );
}
/* If there is no exif-data, return NULL */
return NULL;
}
/**
* a_geotag_get_position:
*
* @filename: The (JPG) file with EXIF information in it
*
* Returns: The position in LatLon format.
* It will be 0,0 if some kind of failure occurs.
*/
struct LatLon a_geotag_get_position ( const gchar *filename )
{
struct LatLon ll = { 0.0, 0.0 };
#ifdef HAVE_LIBGEXIV2
GExiv2Metadata *gemd = gexiv2_metadata_new ();
if ( gexiv2_metadata_open_path ( gemd, filename, NULL ) ) {
gdouble lat;
gdouble lon;
gdouble alt;
if ( gexiv2_metadata_get_gps_info ( gemd, &lon, &lat, &alt ) ) {
ll.lat = lat;
ll.lon = lon;
}
}
metadata_free ( gemd );
#else
#ifdef HAVE_LIBEXIF
// open image with libexif
ExifData *ed = exif_data_new_from_file ( filename );
// Detect EXIF load failure
if ( !ed )
return ll;
ExifEntry *ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_VERSION_ID);
// Confirm this has a GPS Id - normally "2.0.0.0" or "2.2.0.0"
if ( ! ( ee && ee->components == 4 ) )
goto MyReturn0;
ll = get_latlon ( ed );
MyReturn0:
// Finished with EXIF
exif_data_free ( ed );
#endif
#endif
return ll;
}
int
main (int argc, char **argv)
{
ExifData *d;
unsigned int buf_size;
unsigned char *buf;
int r;
if (argc <= 1) {
fprintf (stderr, "You need to supply a filename!\n");
return 1;
}
fprintf (stdout, "Loading '%s'...\n", argv[1]);
d = exif_data_new_from_file (argv[1]);
if (!d) {
fprintf (stderr, "Could not load data from '%s'!\n", argv[1]);
return 1;
}
fprintf (stdout, "Loaded '%s'.\n", argv[1]);
fprintf (stdout, "######### Test 1 #########\n");
r = test_exif_data (d);
if (r) return r;
exif_data_save_data (d, &buf, &buf_size);
exif_data_unref (d);
d = exif_data_new_from_data (buf, buf_size);
free (buf);
fprintf (stdout, "######### Test 2 #########\n");
r = test_exif_data (d);
if (r) return r;
fprintf (stdout, "Test successful!\n");
return 1;
}
QDateTime Exif2GPX::getTimeFromEXIF(const QString& filename) {
// load the exif data
ExifData* exifData;
if (!(exifData = exif_data_new_from_file((const char*)filename))) {
std::cerr<<"Could not load EXIF data from "<<filename<<std::endl;
return QDateTime();
}
// find the timestamp
ExifEntry* entry;
entry = exif_content_get_entry(exifData->ifd[EXIF_IFD_0],
EXIF_TAG_DATE_TIME);
if (!entry)
entry = exif_content_get_entry(exifData->ifd[EXIF_IFD_EXIF],
EXIF_TAG_DATE_TIME_ORIGINAL);
if (!entry)
entry = exif_content_get_entry(exifData->ifd[EXIF_IFD_EXIF],
EXIF_TAG_DATE_TIME_DIGITIZED);
if (!entry) {
std::cerr<<"Could not find a valid timestamp in "<<filename<<std::endl;
return QDateTime();
}
// parse it
int year, month, day, hour, minute, second;
if (std::sscanf((char*)entry->data, "%d:%d:%d %d:%d:%d", &year, &month, &day,
&hour, &minute, &second) != 6) {
std::cerr<<"Could not find a valid timestamp in "<<filename<<std::endl;
return QDateTime();
}
QDateTime timestamp(QDate(year, month, day), QTime(hour, minute, second));
std::cerr<<filename<<": "<<timestamp.toString()<<std::endl;
return timestamp;
}
static int
get_file_func (CameraFilesystem *fs, const char *folder, const char *filename,
CameraFileType type, CameraFile *file, void *user_data,
GPContext *context)
{
char path[1024];
int result = GP_OK;
struct stat stbuf;
int fd, id;
unsigned int curread, toread;
unsigned char *buf;
#ifdef HAVE_LIBEXIF
ExifData *data;
unsigned int buf_len;
#endif /* HAVE_LIBEXIF */
Camera *camera = (Camera*)user_data;
result = _get_path (camera->port, folder, filename, path, sizeof(path));
gp_log (GP_LOG_DEBUG, "directory/get_file_func", "%s %s",folder,filename);
if (result < GP_OK)
return result;
gp_log (GP_LOG_DEBUG, "directory/get_file_func", "->%s",path);
switch (type) {
case GP_FILE_TYPE_NORMAL:
#ifdef DEBUG
case GP_FILE_TYPE_PREVIEW:
#endif
fd = open (path,O_RDONLY);
if (fd == -1)
return GP_ERROR_IO_READ;
break;
#ifdef HAVE_LIBEXIF
case GP_FILE_TYPE_EXIF:
data = exif_data_new_from_file (path);
if (!data) {
gp_context_error (context, _("Could not open '%s'."),
path);
return (GP_ERROR);
}
exif_data_save_data (data, &buf, &buf_len);
exif_data_unref (data);
gp_file_set_data_and_size (file, buf, buf_len);
return (GP_OK);
#endif /* HAVE_LIBEXIF */
default:
return (GP_ERROR_NOT_SUPPORTED);
}
if (-1 == fstat(fd,&stbuf)) {
close (fd);
return GP_ERROR_IO_READ;
}
#define BLOCKSIZE 65536
/* do it in 64kb blocks */
buf = malloc(BLOCKSIZE);
if (!buf) {
close (fd);
return GP_ERROR_NO_MEMORY;
}
curread = 0;
id = gp_context_progress_start (context, (1.0*stbuf.st_size/BLOCKSIZE), _("Getting file..."));
GP_DEBUG ("Progress id: %i", id);
result = GP_OK;
while (curread < stbuf.st_size) {
int ret;
toread = stbuf.st_size-curread;
if (toread>BLOCKSIZE) toread = BLOCKSIZE;
ret = read(fd,buf,toread);
if (ret == -1) {
result = GP_ERROR_IO_READ;
break;
}
curread += ret;
gp_file_append (file, buf, ret);
gp_context_progress_update (context, id, (1.0*curread/BLOCKSIZE));
gp_context_idle (context);
if (gp_context_cancel (context) == GP_CONTEXT_FEEDBACK_CANCEL) {
result = GP_ERROR_CANCEL;
break;
}
#if 0
/* We could take 2 seconds to download this image. everytime. */
/* But actually this driver is used in production by some frontends,
* so do not delay at all
*/
usleep(2000000/(stbuf.st_size/BLOCKSIZE));
#endif
}
gp_context_progress_stop (context, id);
free (buf);
close (fd);
return (GP_OK);
}
void ChatImageItem::downloadOrViewImage()
{
if (retryButton)
{
message.status = FMessage::Uploading;
retryButton = false;
setButton();
emit mediaUpload(message);
} else if (message.media_wa_type == FMessage::Location)
{
QString url = (message.media_url.isEmpty())
? URL_LOCATION_SHARING +
QString::number(message.latitude) + "," +
QString::number(message.longitude) + "+(" +
message.notify_name.replace("<","<").replace(">",">") + ")"
: message.media_url;
QDesktopServices::openUrl(QUrl(url));
}
else if (!message.local_file_uri.isEmpty())
{
QString uri = "file://" + message.local_file_uri;
QDBusConnection dbus = QDBusConnection::sessionBus();
switch (message.media_wa_type)
{
case FMessage::Audio:
if (message.live)
{
AudioPlayer *player = new AudioPlayer(this);
connect(player,SIGNAL(progress(int)),this,SLOT(updateTime(int)));
connect(player,SIGNAL(finished()),this,SLOT(finishedAudioPlay()));
ui->viewImageButton->setEnabled(false);
player->play(uri);
// We need to notificate the sender that we played the audio
emit voiceNotePlayed(message);
break;
}
case FMessage::Video:
{
DBusNokiaMediaPlayerIf *mediaPlayerBus =
new DBusNokiaMediaPlayerIf(NOKIA_MEDIAPLAYER_DBUS_NAME,
NOKIA_MEDIAPLAYER_DBUS_PATH,
dbus,this);
mediaPlayerBus->mime_open(uri);
}
break;
case FMessage::Image:
{
// The following is to avoid an Image Viewer bug where files without
// EXIF data can't be opened.
QImageReader image(message.local_file_uri);
if (image.format() == "jpeg")
{
ExifData *ed = exif_data_new_from_file(message.local_file_uri.toUtf8().constData());
if (!ed)
{
ed = exif_data_new();
if (ed)
{
Utilities::logData("Creating default Exif data.");
ExifEntry *entry = exif_entry_new();
exif_content_add_entry(ed->ifd[EXIF_IFD_0], entry);
exif_entry_initialize(entry, EXIF_TAG_IMAGE_DESCRIPTION);
entry->data = (unsigned char *) YAPPARI_APPLICATION_NAME;
JPEGData *jpeg = jpeg_data_new_from_file(message.local_file_uri.toUtf8().constData());
jpeg_data_set_exif_data(jpeg, ed);
jpeg_data_save_file(jpeg, message.local_file_uri.toUtf8().constData());
jpeg_data_unref(jpeg);
}
}
if (ed)
exif_data_unref(ed);
}
DBusNokiaImageViewerIf *imageViewerBus =
new DBusNokiaImageViewerIf(NOKIA_IMAGEVIEWER_DBUS_NAME,
NOKIA_IMAGEVIEWER_DBUS_PATH,
dbus,this);
imageViewerBus->mime_open(uri);
}
break;
}
/**
* Analyzes a file and copies it if it contains image data.
* @param fpath The filename of the current entry.
* @param sb A pointer to the stat structure.
* @param typeflag The current entry type.
*/
static int
_ftw_callback(char const* fpath, struct stat const* sb, int typeflag)
{
int rc;
ExifData* exif_data;
ExifEntry* exif_entry;
char exif_entry_val[20];
struct tm tm;
// The current entry is not a file. Skip it.
if (!S_ISREG(sb->st_mode)) {
return 0;
}
// The current entry has no EXIF data. Skip it.
exif_data = exif_data_new_from_file(fpath);
if (exif_data == NULL) {
return 0;
}
rc = 0;
exif_entry = exif_content_get_entry(*(exif_data->ifd), EXIF_TAG_DATE_TIME);
if (exif_entry != NULL
&& exif_entry_get_value(exif_entry, exif_entry_val, 20) != NULL
&& strptime(exif_entry_val, "%Y:%m:%d %H:%M:%S", &tm) != 0) {
size_t dst_size;
char* dst;
dst_size = strlen(_DST) + 12;
dst = (char*) malloc(dst_size);
// Create the destination path.
if (snprintf(dst, dst_size, "%s/%d/%02d/%02d", _DST, tm.tm_year + 1900,
tm.tm_mon + 1, tm.tm_mday) >= 0
&& _mkdir_recursive(dst) == 0) {
size_t offset;
char* dst_fpath;
offset = strlen(fpath);
while (offset > 0 && fpath[offset - 1] != '/') {
--offset;
}
// Copy the file.
dst_fpath = (char*) malloc(strlen(dst) + strlen(fpath + offset) + 2);
sprintf(dst_fpath, "%s/%s", dst, fpath + offset);
rc = _cp(dst_fpath, fpath);
free(dst_fpath);
if (rc == -1 && errno == EEXIST) {
rc = 0;
}
}
free(dst);
}
exif_data_unref(exif_data);
return rc;
}
QDateTime GalleryUtil::GetTimestamp(const QString &filePath)
{
QDateTime timestamp;
try
{
#ifdef EXIF_SUPPORT
#if NEW_LIB_EXIF
char *exifvalue = new char[20];
#endif
ExifData *data = exif_data_new_from_file(
filePath.toLocal8Bit().constData());
if (data)
{
for (int i = 0; i < EXIF_IFD_COUNT; i++)
{
ExifEntry *entry = exif_content_get_entry (data->ifd[i],
EXIF_TAG_DATE_TIME_ORIGINAL);
if (entry)
{
#if NEW_LIB_EXIF
exif_entry_get_value(entry, exifvalue, 20);
QString formatted = exifvalue;
#else
QString formatted = exif_entry_get_value(entry);
#endif
timestamp = QDateTime::fromString(formatted,
"yyyy:MM:dd hh:mm:ss");
if (timestamp.isValid())
{
// Found one, done
break;
}
else
{
LOG(VB_FILE, LOG_ERR, LOC +
QString("Could not parse exif timestamp from '%1'")
.arg(filePath));
}
}
}
exif_data_free(data);
}
else
{
LOG(VB_FILE, LOG_ERR, LOC +
QString("Could not load exif data from '%1'") .arg(filePath));
}
#if NEW_LIB_EXIF
delete [] exifvalue;
#endif
#endif // EXIF_SUPPORT
}
catch (...)
{
LOG(VB_GENERAL, LOG_ERR, LOC +
QString("Failed to extract EXIF headers from '%1'") .arg(filePath));
}
return timestamp;
}
QString GalleryUtil::GetCaption(const QString &filePath)
{
QString caption("");
try
{
#ifdef EXIF_SUPPORT
#if NEW_LIB_EXIF
char *exifvalue = new char[1024];
#endif
ExifData *data = exif_data_new_from_file(
filePath.toLocal8Bit().constData());
if (data)
{
for (int i = 0; i < EXIF_IFD_COUNT; i++)
{
ExifEntry *entry = exif_content_get_entry (data->ifd[i],
EXIF_TAG_USER_COMMENT);
if (entry)
{
#if NEW_LIB_EXIF
exif_entry_get_value(entry, exifvalue, 1024);
caption = exifvalue;
#else
caption = exif_entry_get_value(entry);
#endif
// Found one, done
if(!caption.trimmed().isEmpty())
break;
}
entry = exif_content_get_entry (data->ifd[i],
EXIF_TAG_IMAGE_DESCRIPTION);
if (entry)
{
#if NEW_LIB_EXIF
exif_entry_get_value(entry, exifvalue, 1024);
caption = exifvalue;
#else
caption = exif_entry_get_value(entry);
#endif
// Found one, done
if(!caption.trimmed().isEmpty())
break;
}
}
exif_data_free(data);
}
else
{
LOG(VB_FILE, LOG_ERR, LOC +
QString("Could not load exif data from '%1'") .arg(filePath));
}
#if NEW_LIB_EXIF
delete [] exifvalue;
#endif
#endif // EXIF_SUPPORT
}
catch (...)
{
LOG(VB_GENERAL, LOG_ERR, LOC +
QString("Failed to extract EXIF headers from '%1'") .arg(filePath));
}
return caption;
}
LocImageContainer ImageProcessor::process (QString filename)
{
QImage image (m_data);
if (!image.isNull()) {
image = image.scaled(720, 500, Qt::KeepAspectRatioByExpanding);
}
LocImageContainer locImageContainer(image);
locImageContainer.setAltitude(3000.00);
//get exif data
ExifData *ed = exif_data_new_from_file (filename.toLocal8Bit().constData());
if (!ed) {
locImageContainer.setLocationAvailable(false);
locImageContainer.setExifDataAvailable(false);
return locImageContainer;
}
locImageContainer.setExifDataAvailable(true);
//save temp
char value[256]={0,};
// Retrieve make
QString make;
ExifEntry *ee = exif_content_get_entry(ed->ifd[EXIF_IFD_0], EXIF_TAG_MAKE);
if (!ee) {
make = "";
} else {
exif_entry_get_value(ee, value, sizeof(value));
locImageContainer.setMake (QString(value));
}
// Retrieve model
ee = exif_content_get_entry(ed->ifd[EXIF_IFD_0], EXIF_TAG_MODEL);
if (!ee) {
locImageContainer.setCameraModel ("");
} else {
exif_entry_get_value(ee, value, sizeof(value));
locImageContainer.setCameraModel ("Taken with the "+QString(value));
}
// Retrieve time
ee = exif_content_get_entry(ed->ifd[EXIF_IFD_EXIF], EXIF_TAG_DATE_TIME_ORIGINAL);
if (!ee) {
locImageContainer.setDateTaken ("");
} else {
exif_entry_get_value(ee, value, sizeof(value));
QString dateTime(value);
QDateTime dateTaken = QDateTime::fromString (dateTime, "yyyy:MM:dd HH:mm:ss");
locImageContainer.setDateTaken (dateTaken.toString("'on 'dddd d, MMMM yyyy 'at' HH:mm"));
}
// Retrieve LATITUDE
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], (ExifTag)EXIF_TAG_GPS_LATITUDE);
if (!ee) {
locImageContainer.setLocationAvailable(false);
locImageContainer.setLatitude(-9999.99);
} else {
if ( ( ee && ee->components == 3 && ee->format == EXIF_FORMAT_RATIONAL ) )
{
double lat = Rational2Double ( ee->data,
exif_format_get_size(ee->format),
exif_data_get_byte_order(ed) );
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], (ExifTag)EXIF_TAG_GPS_LATITUDE_REF);
if ( ee ) {
exif_entry_get_value ( ee, value, 128 );
if ( value[0] == 'S' )
lat = -lat;
}
locImageContainer.setLocationAvailable(true);
locImageContainer.setLatitude (lat);
}
}
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], (ExifTag)EXIF_TAG_GPS_LONGITUDE);
if (!ee) {
locImageContainer.setLocationAvailable(false);
locImageContainer.setLongitude(-9999.99);
} else {
if ( ( ee && ee->components == 3 && ee->format == EXIF_FORMAT_RATIONAL ) )
{
double lon = Rational2Double ( ee->data,
exif_format_get_size(ee->format),
exif_data_get_byte_order(ed) );
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], (ExifTag)EXIF_TAG_GPS_LONGITUDE_REF);
if ( ee ) {
exif_entry_get_value ( ee, value, 128 );
if ( value[0] == 'W' )
lon = -lon;
}
locImageContainer.setLocationAvailable(true);
locImageContainer.setLongitude (lon);
}
}
exif_data_free(ed);
return locImageContainer;
}
void ThumbGenerator::loadFile(QImage& image, const QFileInfo& fi)
{
static int sequence = 0;
if (GalleryUtil::IsMovie(fi.filePath()))
{
bool thumbnailCreated = false;
QDir tmpDir("/tmp/mythgallery");
if (!tmpDir.exists())
{
if (!tmpDir.mkdir(tmpDir.absolutePath()))
{
LOG(VB_GENERAL, LOG_ERR,
"Unable to create temp dir for movie thumbnail creation: " +
tmpDir.absolutePath());
}
}
if (tmpDir.exists())
{
QString thumbFile = QString("%1.png")
.arg(++sequence,8,10,QChar('0'));
QString cmd = "mythpreviewgen";
QStringList args;
args << logPropagateArgs.split(" ", QString::SkipEmptyParts);
args << "--infile" << '"' + fi.absoluteFilePath() + '"';
args << "--outfile" << '"' + tmpDir.filePath(thumbFile) + '"';
MythSystemLegacy ms(cmd, args, kMSRunShell);
ms.SetDirectory(tmpDir.absolutePath());
ms.Run();
if (ms.Wait() == GENERIC_EXIT_OK)
{
QFileInfo thumb(tmpDir.filePath(thumbFile));
if (thumb.exists())
{
QImage img(thumb.absoluteFilePath());
image = img;
thumbnailCreated = true;
}
}
}
if (!thumbnailCreated)
{
QImage *img = GetMythUI()->LoadScaleImage("gallery-moviethumb.png");
if (img)
{
image = *img;
}
}
}
else
{
#ifdef EXIF_SUPPORT
// Try to get thumbnail from exif data
ExifData *ed = exif_data_new_from_file(fi.absoluteFilePath()
.toLocal8Bit().constData());
if (ed && ed->data)
{
image.loadFromData(ed->data, ed->size);
}
if (ed)
exif_data_free(ed);
if (image.width() > m_width && image.height() > m_height)
return;
#endif
#ifdef DCRAW_SUPPORT
QString extension = fi.suffix();
QSet<QString> dcrawFormats = DcrawFormats::getFormats();
int rotateAngle;
if (dcrawFormats.contains(extension) &&
(rotateAngle = DcrawHandler::loadThumbnail(&image,
fi.absoluteFilePath())) != -1 &&
image.width() > m_width && image.height() > m_height)
{
if (rotateAngle != 0)
{
QMatrix matrix;
matrix.rotate(rotateAngle);
image = image.transformed(matrix);
}
return;
}
#endif
image.load(fi.absoluteFilePath());
}
}
void FileSystemScanner::readEXIF(File* file)
{
static QString EXIFIFD_NAME_EXIF = exif_ifd_get_name(EXIF_IFD_EXIF);
int maxDataLength = 255;
char* charData = new char[maxDataLength];
ExifData* exifData = exif_data_new_from_file(file->fileInfo()->absFilePath().ascii());
// exif_data_dump(exifData);
for (int i = 0; i < EXIF_IFD_COUNT; i++) {
ExifContent* content = exifData->ifd[i];
QString group = QString(exif_ifd_get_name((ExifIfd) i));
if (group == EXIFIFD_NAME_EXIF) {
for (unsigned int e = 0; e < content->count; e++) {
ExifEntry* entry = content->entries[e];
ExifTag exifTagType = entry->tag;
QString title = QString(exif_tag_get_title(entry->tag));
QString name = QString(exif_tag_get_name(entry->tag));
exif_entry_get_value(entry, charData, maxDataLength);
QString data = QString(charData);
QString description = QString(exif_tag_get_description(entry->tag));
// tracer->sdebug(__func__) << " - " << title << " / " << name << " = " << data << " (" << description << ")" << endl;
// get the exif tagnode title and the tagnode representing this tag from the engine
TagNode* exifTagNodeTitle = m_engine->exifTagNodeTitle();
TagNode* exifTagNodeEntry = exifTagNodeTitle->child(title);
switch (exifTagType) {
case EXIF_TAG_DATE_TIME_ORIGINAL:
case EXIF_TAG_DATE_TIME_DIGITIZED: {
QDateTime dateTime = readExifDateTime(data);
TagNodeDateTime* exifTagNodeEntryDateTime = dynamic_cast<TagNodeDateTime*>(exifTagNodeEntry);
if (exifTagNodeEntryDateTime == 0) {
// tagnode for this EXIF entry does not exist --> create it
exifTagNodeEntryDateTime = dynamic_cast<TagNodeDateTime*>(m_engine->createTag(exifTagNodeTitle, TagNode::TYPE_DATETIME, title, description, QString::null));
exifTagNodeEntryDateTime->setReadonly(true);
}
if (dateTime.isValid()) {
// create new assoc
new FileTagNodeAssocDateTime(file, exifTagNodeEntryDateTime, dateTime);
}
break;
}
default: {
TagNodeString* exifTagNodeEntryString = dynamic_cast<TagNodeString*>(exifTagNodeEntry);
if (exifTagNodeEntryString == 0) {
// tagnode for this EXIF entry does not exist --> create it
exifTagNodeEntryString = dynamic_cast<TagNodeString*>(m_engine->createTag(exifTagNodeTitle, TagNode::TYPE_STRING, title, description, QString::null));
exifTagNodeEntryString->setReadonly(true);
}
// create new assoc
new FileTagNodeAssocString(file, exifTagNodeEntryString, data);
}
}
}
}
}
exif_data_free(exifData);
delete charData;
}
/**
* a_geotag_write_exif_gps:
* @filename: The image file to save information in
* @coord: The location
* @alt: The elevation
*
* Returns: A value indicating success: 0, or some other value for failure
*
*/
gint a_geotag_write_exif_gps ( const gchar *filename, VikCoord coord, gdouble alt, gboolean no_change_mtime )
{
gint result = 0; // OK so far...
// Save mtime for later use
struct stat stat_save;
if ( no_change_mtime )
stat ( filename, &stat_save );
/*
Appears libexif doesn't actually support writing EXIF data directly to files
Thus embed command line exif writing method within Viking
(for example this is done by Enlightment - http://www.enlightenment.org/ )
This appears to be JPEG only, but is probably 99% of our use case
Alternatively consider using libexiv2 and C++...
*/
// Actual EXIF settings here...
JPEGData *jdata;
/* Parse the JPEG file. */
jdata = jpeg_data_new ();
jpeg_data_load_file (jdata, filename);
// Get current values
ExifData *ed = exif_data_new_from_file ( filename );
if ( !ed )
ed = exif_data_new ();
// Update ExifData with our new settings
ExifEntry *ee;
//
// 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
// (unless of course there is some bug in the setting of the ID, that prevents subsequent tags)
//
ee = my_exif_create_value (ed, EXIF_TAG_GPS_ALTITUDE, EXIF_IFD_GPS);
convert_to_entry ( NULL, alt, ee, exif_data_get_byte_order(ed) );
// byte 0 meaning "sea level" or 1 if the value is negative.
ee = my_exif_create_value (ed, EXIF_TAG_GPS_ALTITUDE_REF, EXIF_IFD_GPS);
convert_to_entry ( alt < 0.0 ? "1" : "0", 0.0, ee, exif_data_get_byte_order(ed) );
ee = my_exif_create_value (ed, EXIF_TAG_GPS_PROCESSING_METHOD, EXIF_IFD_GPS);
// see http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/GPS.html
convert_to_entry ( "MANUAL", 0.0, ee, exif_data_get_byte_order(ed) );
ee = my_exif_create_value (ed, EXIF_TAG_GPS_MAP_DATUM, EXIF_IFD_GPS);
convert_to_entry ( "WGS-84", 0.0, ee, exif_data_get_byte_order(ed) );
struct LatLon ll;
vik_coord_to_latlon ( &coord, &ll );
ee = my_exif_create_value (ed, EXIF_TAG_GPS_LATITUDE_REF, EXIF_IFD_GPS);
// N or S
convert_to_entry ( ll.lat < 0.0 ? "S" : "N", 0.0, ee, exif_data_get_byte_order(ed) );
ee = my_exif_create_value (ed, EXIF_TAG_GPS_LATITUDE, EXIF_IFD_GPS);
convert_to_entry ( NULL, ll.lat, ee, exif_data_get_byte_order(ed) );
ee = my_exif_create_value (ed, EXIF_TAG_GPS_LONGITUDE_REF, EXIF_IFD_GPS);
// E or W
convert_to_entry ( ll.lon < 0.0 ? "W" : "E", 0.0, ee, exif_data_get_byte_order(ed) );
ee = my_exif_create_value (ed, EXIF_TAG_GPS_LONGITUDE, EXIF_IFD_GPS);
convert_to_entry ( NULL, ll.lon, ee, exif_data_get_byte_order(ed) );
ee = my_exif_create_value (ed, EXIF_TAG_GPS_VERSION_ID, EXIF_IFD_GPS);
//convert_to_entry ( "2 0 0 0", 0.0, ee, exif_data_get_byte_order(ed) );
convert_to_entry ( "2 2 0 0", 0.0, ee, exif_data_get_byte_order(ed) );
jpeg_data_set_exif_data (jdata, ed);
if ( jdata ) {
/* Save the modified image. */
result = jpeg_data_save_file (jdata, filename);
// Convert result from 1 for success, 0 for failure into our scheme
result = !result;
jpeg_data_unref (jdata);
}
else {
// Epic fail - file probably not a JPEG
result = 2;
}
if ( no_change_mtime ) {
// Restore mtime, using the saved value
struct stat stat_tmp;
struct utimbuf utb;
stat ( filename, &stat_tmp );
utb.actime = stat_tmp.st_atime;
utb.modtime = stat_save.st_mtime;
utime ( filename, &utb );
}
return result;
}
static int ypfs_write(const char *path, const char *buf, size_t size, off_t offset,
struct fuse_file_info *fi)
{
char* full_path;
FILE* logfile;
int f;
ExifData *ed;
ExifEntry *entry;
(void) fi;
sqlite3_stmt *stmt;
int year = -1;
int month = -1;
#ifdef DEBUG
if(1){
FILE *f2 = fopen("/opfs/log2.txt", "a");
fprintf(f2, "WRITE: %s\n", path);
fclose(f2);
}
#endif
full_path = build_path(path);
f = fi->fh;
write(f, buf, size);
if (offset == 0) {
logfile = fopen("log.txt", "a");
ed = exif_data_new_from_file(full_path);
if (ed) {
entry = exif_content_get_entry(ed->ifd[EXIF_IFD_EXIF], EXIF_TAG_DATE_TIME_ORIGINAL);
if (entry) {
char buf[1024];
exif_entry_get_value(entry, buf, sizeof(buf));
fprintf(logfile, "%s had date %s\n", full_path, buf);
buf[4] = 0;
buf[7] = 0;
year = atoi(buf);
month = atoi(buf+5);
} else {
fprintf(logfile,"%s had exif data, but no date\n", full_path);
}
} else {
fprintf(logfile,"%s had no exif data\n", full_path);
}
exif_data_unref(ed);
fclose(logfile);
if ( year == -1 || month == -1) {
time_t cur_time;
struct tm * full_time;
time(&cur_time);
full_time = localtime(&cur_time);
if (year == -1)
year = 1900 + full_time->tm_year;
if (month == -1)
month = full_time->tm_mon+1;
}
sqlite3_prepare_v2(conn, "insert into pictures values(?, ?, ?, ?)", -1, &stmt, NULL);
sqlite3_bind_text(stmt, 1, path + last_index_of(path, '/'), -1, SQLITE_TRANSIENT);
sqlite3_bind_int(stmt, 2, year);
sqlite3_bind_int(stmt, 3, month);
sqlite3_bind_int(stmt, 4, CURRENT->uid);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
}
free(full_path);
return size;
}
/**
* a_geotag_create_waypoint_from_file:
* @filename: The image file to process
* @vcmode: The current location mode to use in the positioning of Waypoint
* @name: Returns a name for the Waypoint (can be NULL)
*
* Returns: An allocated Waypoint or NULL if Waypoint could not be generated (e.g. no EXIF info)
*
*/
VikWaypoint* a_geotag_create_waypoint_from_file ( const gchar *filename, VikCoordMode vcmode, gchar **name )
{
// Default return values (for failures)
*name = NULL;
VikWaypoint *wp = NULL;
// TODO use log?
//ExifLog *log = NULL;
// open image with libexif
ExifData *ed = exif_data_new_from_file ( filename );
// Detect EXIF load failure
if ( !ed )
// return with no Waypoint
return wp;
struct LatLon ll;
gchar str[128];
ExifEntry *ee;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_VERSION_ID);
// Confirm this has a GPS Id - normally "2.0.0.0" or "2.2.0.0"
if ( ! ( ee && ee->components == 4 ) )
goto MyReturn;
// Could test for these versions explicitly but may have byte order issues...
//if ( ! ( ee->data[0] == 2 && ee->data[2] == 0 && ee->data[3] == 0 ) )
// goto MyReturn;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_MAP_DATUM);
if ( ! ( ee && ee->components > 0 && ee->format == EXIF_FORMAT_ASCII ) )
goto MyReturn;
// If map datum specified - only deal in WGS-84 - the defacto standard
if ( ee && ee->components > 0 ) {
exif_entry_get_value ( ee, str, 128 );
if ( strncmp (str, "WGS-84", 6) )
goto MyReturn;
}
//
// Lat & Long is necessary to form a waypoint.
//
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LATITUDE);
if ( ! ( ee && ee->components == 3 && ee->format == EXIF_FORMAT_RATIONAL ) )
goto MyReturn;
ll.lat = Rational2Double ( ee->data,
exif_format_get_size(ee->format),
exif_data_get_byte_order(ed) );
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LATITUDE_REF);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
if ( str[0] == 'S' )
ll.lat = -ll.lat;
}
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LONGITUDE);
if ( ! ( ee && ee->components == 3 && ee->format == EXIF_FORMAT_RATIONAL ) )
goto MyReturn;
ll.lon = Rational2Double ( ee->data,
exif_format_get_size(ee->format),
exif_data_get_byte_order(ed) );
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_LONGITUDE_REF);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
if ( str[0] == 'W' )
ll.lon = -ll.lon;
}
//
// Not worried if none of the other fields exist, as can default the values to something
//
gdouble alt = VIK_DEFAULT_ALTITUDE;
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_ALTITUDE);
if ( ee && ee->components == 1 && ee->format == EXIF_FORMAT_RATIONAL ) {
alt = Rational2Double ( ee->data,
0,
exif_data_get_byte_order(ed) );
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_GPS], EXIF_TAG_GPS_ALTITUDE_REF);
if ( ee && ee->components == 1 && ee->format == EXIF_FORMAT_BYTE && ee->data[0] == 1 )
alt = -alt;
}
// Name
ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], EXIF_TAG_XP_TITLE);
if ( ee ) {
exif_entry_get_value ( ee, str, 128 );
*name = g_strdup ( str );
}
//
// Now create Waypoint with acquired information
//
wp = vik_waypoint_new();
wp->visible = TRUE;
// Set info from exif values
// Location
vik_coord_load_from_latlon ( &(wp->coord), vcmode, &ll );
// Altitude
wp->altitude = alt;
wp->comment = geotag_get_exif_comment ( ed );
vik_waypoint_set_image ( wp, filename );
MyReturn:
// Finished with EXIF
exif_data_free ( ed );
return wp;
}
