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; }
static gboolean get_coordinates (EogImage *image, gdouble *latitude, gdouble *longitude) { ExifData *exif_data; gchar buffer[32]; gdouble lon, lat; exif_data = (ExifData *) eog_image_get_exif_info (image); if (exif_data) { ExifEntry *entry; ExifByteOrder byte_order; byte_order = exif_data_get_byte_order (exif_data); entry = exif_data_get_entry (exif_data, EXIF_TAG_GPS_LONGITUDE); if (!parse_exif_gps_coordinate (entry, &lon, byte_order) || (lon > 180.0)) { exif_data_unref (exif_data); return FALSE; } eog_exif_data_get_value (exif_data, EXIF_TAG_GPS_LONGITUDE_REF, buffer, 32); if (strcmp (buffer, "W") == 0) lon *= -1; entry = exif_data_get_entry (exif_data, EXIF_TAG_GPS_LATITUDE); if (!parse_exif_gps_coordinate (entry, &lat, byte_order) || (lat > 90.0)) { exif_data_unref (exif_data); return FALSE; } eog_exif_data_get_value (exif_data, EXIF_TAG_GPS_LATITUDE_REF, buffer, 32); if (strcmp (buffer, "S") == 0) lat *= -1; *longitude = lon; *latitude = lat; exif_data_unref (exif_data); return TRUE; } return FALSE; }
int main () { ExifData *d; ExifEntry *e; char v[1024]; ExifSRational r = {1., 20.}; unsigned int i; d = exif_data_new (); if (!d) { printf ("Error running exif_data_new()\n"); exit(13); } e = exif_entry_new (); if (!e) { printf ("Error running exif_entry_new()\n"); exit(13); } exif_content_add_entry (d->ifd[EXIF_IFD_0], e); exif_entry_initialize (e, EXIF_TAG_SHUTTER_SPEED_VALUE); exif_set_srational (e->data, exif_data_get_byte_order (d), r); for (i = 30; i > 0; i--) { printf ("Length %2i: '%s'\n", i, exif_entry_get_value (e, v, i)); } exif_entry_unref (e); exif_data_unref (d); return 0; }
static void append_exif_info (NemoImagePropertiesPage *page) { #ifdef HAVE_EXIF ExifData *exifdata; exifdata = exif_loader_get_data (page->details->exifldr); if (exifdata == NULL) return; if (exifdata->ifd[0] && exifdata->ifd[0]->count) { append_tag_value_pair (page, exifdata, EXIF_TAG_MAKE, _("Camera Brand")); append_tag_value_pair (page, exifdata, EXIF_TAG_MODEL, _("Camera Model")); /* Choose which date to show in order of relevance */ if (!append_tag_value_pair (page, exifdata, EXIF_TAG_DATE_TIME_ORIGINAL, _("Date Taken"))) { if (!append_tag_value_pair (page, exifdata, EXIF_TAG_DATE_TIME_DIGITIZED, _("Date Digitized"))) { append_tag_value_pair (page, exifdata, EXIF_TAG_DATE_TIME, _("Date Modified")); } } append_tag_value_pair (page, exifdata, EXIF_TAG_EXPOSURE_TIME, _("Exposure Time")); append_tag_value_pair (page, exifdata, EXIF_TAG_APERTURE_VALUE, _("Aperture Value")); append_tag_value_pair (page, exifdata, EXIF_TAG_ISO_SPEED_RATINGS, _("ISO Speed Rating")); append_tag_value_pair (page, exifdata, EXIF_TAG_FLASH,_("Flash Fired")); append_tag_value_pair (page, exifdata, EXIF_TAG_METERING_MODE, _("Metering Mode")); append_tag_value_pair (page, exifdata, EXIF_TAG_EXPOSURE_PROGRAM, _("Exposure Program")); append_tag_value_pair (page, exifdata, EXIF_TAG_FOCAL_LENGTH,_("Focal Length")); append_tag_value_pair (page, exifdata, EXIF_TAG_SOFTWARE, _("Software")); } exif_data_unref (exifdata); #endif }
void jpeg_data_free (JPEGData *data) { unsigned int i; JPEGSection s; if (!data) return; if (data->count) { for (i = 0; i < data->count; i++) { s = data->sections[i]; switch (s.marker) { case JPEG_MARKER_SOI: case JPEG_MARKER_EOI: break; case JPEG_MARKER_APP1: exif_data_unref (s.content.app1); break; default: free (s.content.generic.data); break; } } free (data->sections); } if (data->data) free (data->data); free (data->priv); free (data); }
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; }
int main(int argc, char **argv) { int rc = 1; ExifLoader *l; if (argc < 2) { printf("Usage: %s image.jpg\n", argv[0]); printf("Extracts a thumbnail from the given EXIF image.\n"); return rc; } /* Create an ExifLoader object to manage the EXIF loading process */ l = exif_loader_new(); if (l) { ExifData *ed; /* Load the EXIF data from the image file */ exif_loader_write_file(l, argv[1]); /* Get a pointer to the EXIF data */ ed = exif_loader_get_data(l); /* The loader is no longer needed--free it */ exif_loader_unref(l); l = NULL; if (ed) { /* Make sure the image had a thumbnail before trying to write it */ if (ed->data && ed->size) { FILE *thumb; char thumb_name[1024]; /* Try to create a unique name for the thumbnail file */ snprintf(thumb_name, sizeof(thumb_name), "%s_thumb.jpg", argv[1]); thumb = fopen(thumb_name, "wb"); if (thumb) { /* Write the thumbnail image to the file */ fwrite(ed->data, 1, ed->size, thumb); fclose(thumb); printf("Wrote thumbnail to %s\n", thumb_name); rc = 0; } else { printf("Could not create file %s\n", thumb_name); rc = 2; } } else { printf("No EXIF thumbnail in file %s\n", argv[1]); rc = 1; } /* Free the EXIF data */ exif_data_unref(ed); } } return rc; }
void metadatamux_exif_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, const GstTagList * taglist, const MetaExifWriteOptions * opts) { ExifData *ed = NULL; GstBuffer *exif_chunk = NULL; const GValue *val = NULL; if (!(buf && size)) goto done; g_free (*buf); *buf = NULL; *size = 0; val = gst_tag_list_get_value_index (taglist, GST_TAG_EXIF, 0); if (val) { exif_chunk = gst_value_get_buffer (val); if (exif_chunk) { ed = exif_data_new_from_data (GST_BUFFER_DATA (exif_chunk), GST_BUFFER_SIZE (exif_chunk)); } } if (!ed) { ed = exif_data_new (); GST_DEBUG ("setting byteorder %d", opts->byteorder); switch (opts->byteorder) { case GST_META_EXIF_BYTE_ORDER_MOTOROLA: exif_data_set_byte_order (ed, EXIF_BYTE_ORDER_MOTOROLA); break; case GST_META_EXIF_BYTE_ORDER_INTEL: exif_data_set_byte_order (ed, EXIF_BYTE_ORDER_INTEL); break; default: break; } exif_data_set_data_type (ed, EXIF_DATA_TYPE_COMPRESSED); exif_data_fix (ed); } gst_tag_list_foreach (taglist, metadatamux_exif_for_each_tag_in_list, ed); exif_data_save_data (ed, buf, size); done: if (ed) exif_data_unref (ed); return; }
bool exif_date (file_t* file, date_t* date) { ExifData *ed; // ExifEntry *entry; char data[1024]; memset (data,0,sizeof(data)); /* Load an ExifData object from an EXIF file */ ed = load_file(file); if (!ed) return false; // no exif data in this file get_tag(ed, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_ORIGINAL,data,sizeof(data)); // EXIF tag 0x9003, DateTimeOriginal if (*data != 0 && read_yyyymmdd (data,date)) { exif_data_unref(ed); return true; } memset (data,0,sizeof(data)); get_tag(ed, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_DIGITIZED,data,sizeof(data)); // EXIF tag 0x9003, DateTimeDigitized if (*data != 0 && read_yyyymmdd (data,date)) { exif_data_unref(ed); return true; } memset (data,0,sizeof(data)); get_tag(ed, EXIF_IFD_0, EXIF_TAG_DATE_TIME,data,sizeof(data)); // EXIF tag 0x0132, ModifyDate if (*data != 0 && read_yyyymmdd (data,date)) { exif_data_unref(ed); return true; } exif_data_unref(ed); return false; }
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" ); } }
void Image::load_tags( gpointer data , gsize size ) { g_assert( data ); g_assert( size ); if ( ExifData * ed = exif_data_new_from_data( ( const unsigned char * ) data , size ) ) { 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; }
void jpeg_data_exclude_section (JPEGData *data, JPEGSection *exclude) { unsigned int i; //JPEGSection *s; if (!data || !data->count) return; for (i = 0; i < data->count; i++) if (&data->sections[i] == exclude) { data->count--; switch (exclude->marker) { case JPEG_MARKER_SOI: case JPEG_MARKER_EOI: break; case JPEG_MARKER_APP1: exif_data_unref (exclude->content.app1); break; default: free (exclude->content._generic.data); break; } for (; i < data->count; i++) data->sections[i] = data->sections[i + 1]; if (data->count > 0) { data->sections = (JPEGSection *)realloc (data->sections, sizeof (JPEGSection) * (data->count)); if (!data->sections) { EXIF_LOG_NO_MEMORY (data->priv->log, "jpeg-data", sizeof (JPEGSection) * (data->count)); } } else { free(data->sections); data->sections = NULL; } break; } }
void jpeg_data_set_exif_data (JPEGData *data, ExifData *exif_data) { JPEGSection *section; section = jpeg_data_get_section (data, JPEG_MARKER_APP1); if (!section) { jpeg_data_append_section (data); memmove (&data->sections[2], &data->sections[1], sizeof (JPEGSection) * (data->count - 2)); section = &data->sections[1]; } else { exif_data_unref (section->content.app1); } section->marker = JPEG_MARKER_APP1; section->content.app1 = exif_data; exif_data_ref (exif_data); }
void feh_file_free(feh_file * file) { if (!file) return; if (file->filename) free(file->filename); if (file->name) free(file->name); if (file->caption) free(file->caption); if (file->info) feh_file_info_free(file->info); #ifdef HAVE_LIBEXIF if (file->ed) exif_data_unref(file->ed); #endif free(file); return; }
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; } }
static int test_exif_data (ExifData *d) { unsigned int i, c; char v[1024], *p; ExifMnoteData *md; fprintf (stdout, "Byte order: %s\n", exif_byte_order_get_name (exif_data_get_byte_order (d))); fprintf (stdout, "Parsing maker note...\n"); md = exif_data_get_mnote_data (d); if (!md) { fprintf (stderr, "Could not parse maker note!\n"); exif_data_unref (d); return 1; } fprintf (stdout, "Increasing ref-count...\n"); exif_mnote_data_ref (md); fprintf (stdout, "Decreasing ref-count...\n"); exif_mnote_data_unref (md); fprintf (stdout, "Counting entries...\n"); c = exif_mnote_data_count (md); fprintf (stdout, "Found %i entries.\n", c); for (i = 0; i < c; i++) { fprintf (stdout, "Dumping entry number %i...\n", i); fprintf (stdout, " Name: '%s'\n", exif_mnote_data_get_name (md, i)); fprintf (stdout, " Title: '%s'\n", exif_mnote_data_get_title (md, i)); fprintf (stdout, " Description: '%s'\n", exif_mnote_data_get_description (md, i)); p = exif_mnote_data_get_value (md, i, v, sizeof (v)); if (p) { fprintf (stdout, " Value: '%s'\n", v); } } return 0; }
void metadataparse_exif_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, GstAdapter * adapter, MetadataTagMapping mapping) { const guint8 *buf; guint32 size; ExifData *exif = NULL; MEUserData user_data = { taglist, mode, 2, -1, 'k', 'k' }; if (adapter == NULL || (size = gst_adapter_available (adapter)) == 0) { goto done; } /* add chunk tag */ if (mapping & METADATA_TAG_MAP_WHOLECHUNK) metadataparse_util_tag_list_add_chunk (taglist, mode, GST_TAG_EXIF, adapter); if (!(mapping & METADATA_TAG_MAP_INDIVIDUALS)) goto done; buf = gst_adapter_peek (adapter, size); exif = exif_data_new_from_data (buf, size); if (exif == NULL) { goto done; } exif_data_foreach_content (exif, metadataparse_exif_data_foreach_content_func, (void *) &user_data); done: if (exif) exif_data_unref (exif); return; }
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; }
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; }
static void append_xmp_value_pair (GString *string, XmpPtr xmp, const char *ns, const char *propname, char *descr) { uint32_t options; XmpStringPtr value; value = xmp_string_new(); #ifdef HAVE_EXEMPI_NEW_API if (xmp_get_property (xmp, ns, propname, value, &options)) { #else if (xmp_get_property_and_bits (xmp, ns, propname, value, &options)) { #endif if (XMP_IS_PROP_SIMPLE (options)) { g_string_append_printf (string, "<b>%s:</b> %s\n", descr, xmp_string_cstr (value)); } else if (XMP_IS_PROP_ARRAY (options)) { XmpIteratorPtr iter; iter = xmp_iterator_new (xmp, ns, propname, XMP_ITER_JUSTLEAFNODES); if (iter) { gboolean first = TRUE; g_string_append_printf (string, "<b>%s:</b> ", descr); while (xmp_iterator_next (iter, NULL, NULL, value, &options) && !XMP_IS_PROP_QUALIFIER(options)) { if (!first) { g_string_append_printf (string, ", "); } else { first = FALSE; } g_string_append_printf (string, "%s", xmp_string_cstr(value)); } xmp_iterator_free(iter); g_string_append_printf(string, "\n"); } } } xmp_string_free(value); } static void append_xmpdata_string(XmpPtr xmp, GString *string) { if(xmp != NULL) { append_xmp_value_pair(string, xmp, NS_IPTC4XMP, "Location", _("Location")); append_xmp_value_pair(string, xmp, NS_DC, "description", _("Description")); append_xmp_value_pair(string, xmp, NS_DC, "subject", _("Keywords")); append_xmp_value_pair(string, xmp, NS_DC, "creator", _("Creator")); append_xmp_value_pair(string, xmp, NS_DC, "rights", _("Copyright")); append_xmp_value_pair(string, xmp, NS_XAP,"Rating", _("Rating")); /* TODO add CC licenses */ } } #endif static void load_finished (NautilusImagePropertiesPage *page) { GdkPixbufFormat *format; char *name, *desc; GString *str; if (page->details->got_size) { #ifdef HAVE_EXIF ExifData *exif_data; #endif str = g_string_new (NULL); format = gdk_pixbuf_loader_get_format (page->details->loader); name = gdk_pixbuf_format_get_name (format); desc = gdk_pixbuf_format_get_description (format); g_string_append_printf (str, "<b>%s</b> %s (%s)\n", _("Image Type:"), name, desc); g_string_append_printf (str, ngettext ("<b>Width:</b> %d pixel\n", "<b>Width:</b> %d pixels\n", page->details->width), page->details->width); g_string_append_printf (str, ngettext ("<b>Height:</b> %d pixel\n", "<b>Height:</b> %d pixels\n", page->details->height), page->details->height); g_free (name); g_free (desc); #ifdef HAVE_EXIF exif_data = exif_loader_get_data (page->details->exifldr); append_exifdata_string (exif_data, str); exif_data_unref (exif_data); #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI append_xmpdata_string(page->details->xmp, str); #endif /*HAVE EXEMPI*/ gtk_label_set_markup (GTK_LABEL (page->details->resolution), str->str); gtk_label_set_selectable (GTK_LABEL (page->details->resolution), TRUE); g_string_free (str, TRUE); } else { gtk_label_set_text (GTK_LABEL (page->details->resolution), _("Failed to load image information")); } if (page->details->loader != NULL) { gdk_pixbuf_loader_close (page->details->loader, NULL); g_object_unref (page->details->loader); page->details->loader = NULL; } #ifdef HAVE_EXIF if (page->details->exifldr != NULL) { exif_loader_unref (page->details->exifldr); page->details->exifldr = NULL; } #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI if (page->details->xmp != NULL) { xmp_free(page->details->xmp); page->details->xmp = NULL; } #endif }
int64_t GetImageMetadata(const char *path, char *name) { ExifData *ed; ExifEntry *e = NULL; ExifLoader *l; struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; FILE *infile; int width=0, height=0, thumb=0; char make[32], model[64] = {'\0'}; char b[1024]; struct stat file; int64_t ret; image_s *imsrc; metadata_t m; uint32_t free_flags = 0xFFFFFFFF; memset(&m, '\0', sizeof(metadata_t)); //DEBUG DPRINTF(E_DEBUG, L_METADATA, "Parsing %s...\n", path); if ( stat(path, &file) != 0 ) return 0; strip_ext(name); //DEBUG DPRINTF(E_DEBUG, L_METADATA, " * size: %jd\n", file.st_size); /* MIME hard-coded to JPEG for now, until we add PNG support */ m.mime = strdup("image/jpeg"); l = exif_loader_new(); exif_loader_write_file(l, path); ed = exif_loader_get_data(l); exif_loader_unref(l); if( !ed ) goto no_exifdata; e = exif_content_get_entry (ed->ifd[EXIF_IFD_EXIF], EXIF_TAG_DATE_TIME_ORIGINAL); if( e || (e = exif_content_get_entry(ed->ifd[EXIF_IFD_EXIF], EXIF_TAG_DATE_TIME_DIGITIZED)) ) { m.date = strdup(exif_entry_get_value(e, b, sizeof(b))); if( strlen(m.date) > 10 ) { m.date[4] = '-'; m.date[7] = '-'; m.date[10] = 'T'; } else { free(m.date); m.date = NULL; } } else { /* One last effort to get the date from XMP */ image_get_jpeg_date_xmp(path, &m.date); } //DEBUG DPRINTF(E_DEBUG, L_METADATA, " * date: %s\n", m.date); e = exif_content_get_entry(ed->ifd[EXIF_IFD_0], EXIF_TAG_MAKE); if( e ) { strncpyt(make, exif_entry_get_value(e, b, sizeof(b)), sizeof(make)); e = exif_content_get_entry(ed->ifd[EXIF_IFD_0], EXIF_TAG_MODEL); if( e ) { strncpyt(model, exif_entry_get_value(e, b, sizeof(b)), sizeof(model)); if( !strcasestr(model, make) ) snprintf(model, sizeof(model), "%s %s", make, exif_entry_get_value(e, b, sizeof(b))); m.creator = escape_tag(trim(model), 1); } } //DEBUG DPRINTF(E_DEBUG, L_METADATA, " * model: %s\n", model); e = exif_content_get_entry(ed->ifd[EXIF_IFD_0], EXIF_TAG_ORIENTATION); if( e ) { int rotate; switch( exif_get_short(e->data, exif_data_get_byte_order(ed)) ) { case 3: rotate = 180; break; case 6: rotate = 90; break; case 8: rotate = 270; break; default: rotate = 0; break; } if( rotate ) xasprintf(&m.rotation, "%d", rotate); } if( ed->size ) { /* We might need to verify that the thumbnail is 160x160 or smaller */ if( ed->size > 12000 ) { imsrc = image_new_from_jpeg(NULL, 0, (char *)ed->data, ed->size, 1, ROTATE_NONE); if( imsrc ) { if( (imsrc->width <= 160) && (imsrc->height <= 160) ) thumb = 1; image_free(imsrc); } } else { thumb = 1; //- 20130708 Sungmin add if(ed->data && ed->size) { char* art_file; if( !thumb_cache_exists(path, &art_file) ) { char cache_dir[MAXPATHLEN]; strncpyt(cache_dir, art_file, sizeof(cache_dir)); make_dir(dirname(cache_dir), S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH); FILE *thumb = fopen(art_file, "wb"); //DPRINTF(E_WARN, L_METADATA, " * cache_dir: %s\n", cache_dir); //DPRINTF(E_WARN, L_METADATA, " * thumbnail: %s\n", art_file); if(thumb) { fwrite(ed->data, 1, ed->size, thumb); fclose(thumb); } } free(art_file); } } } //DEBUG DPRINTF(E_DEBUG, L_METADATA, " * thumbnail: %d\n", thumb); exif_data_unref(ed); no_exifdata: /* If SOF parsing fails, then fall through to reading the JPEG data with libjpeg to get the resolution */ if( image_get_jpeg_resolution(path, &width, &height) != 0 || !width || !height ) { infile = fopen(path, "r"); if( infile ) { cinfo.err = jpeg_std_error(&jerr); jerr.error_exit = libjpeg_error_handler; jpeg_create_decompress(&cinfo); if( setjmp(setjmp_buffer) ) goto error; jpeg_stdio_src(&cinfo, infile); jpeg_read_header(&cinfo, TRUE); jpeg_start_decompress(&cinfo); width = cinfo.output_width; height = cinfo.output_height; error: jpeg_destroy_decompress(&cinfo); fclose(infile); } } //DEBUG DPRINTF(E_DEBUG, L_METADATA, " * resolution: %dx%d\n", width, height); if( !width || !height ) { free_metadata(&m, free_flags); return 0; } if( width <= 640 && height <= 480 ) m.dlna_pn = strdup("JPEG_SM"); else if( width <= 1024 && height <= 768 ) m.dlna_pn = strdup("JPEG_MED"); else if( (width <= 4096 && height <= 4096) || !GETFLAG(DLNA_STRICT_MASK) ) m.dlna_pn = strdup("JPEG_LRG"); xasprintf(&m.resolution, "%dx%d", width, height); ret = sql_exec(db, "INSERT into DETAILS" " (PATH, TITLE, SIZE, TIMESTAMP, DATE, RESOLUTION," " ROTATION, THUMBNAIL, CREATOR, DLNA_PN, MIME) " "VALUES" " (%Q, '%q', %lld, %ld, %Q, %Q, %Q, %d, %Q, %Q, %Q);", path, name, (long long)file.st_size, file.st_mtime, m.date, m.resolution, m.rotation, thumb, m.creator, m.dlna_pn, m.mime); if( ret != SQLITE_OK ) { fprintf(stderr, "Error inserting details for '%s'!\n", path); ret = 0; } else { ret = sqlite3_last_insert_rowid(db); } free_metadata(&m, free_flags); return ret; }
/** * Module execution function. Receives a pointer to a file the module is to * process. The file is represented by a TskFile interface which is used * to read the contents of the file and post extracted EXIF data to the * database. * * @param pFile A pointer to a file. * @returns TskModule::OK on success, TskModule::FAIL on error. */ TskModule::Status TSK_MODULE_EXPORT run(TskFile * pFile) { if (pFile == NULL) { LOGERROR(L"ExifExtractModule: passed NULL file pointer."); return TskModule::FAIL; } try { char buffer[FILE_BUFFER_SIZE]; int bytesRead = 0; memset(buffer, 0, FILE_BUFFER_SIZE); bytesRead = pFile->read(buffer, FILE_BUFFER_SIZE); if (bytesRead < 4) return TskModule::OK; // Check the first 4 bytes to see if this is a JPEG file. // We check for both the JFIF and EXIF signatures. if (memcmp(buffer, jfifSig, sizeof(jfifSig)) != 0 && memcmp(buffer, exifSig, sizeof(exifSig)) != 0) { // It's not a JPEG file so we skip it. return TskModule::OK; } ExifLoader * exifLoader = exif_loader_new(); if (exifLoader == NULL) { LOGERROR(L"ExifExtractModule - Received NULL ExifLoader pointer"); return TskModule::FAIL; } // Feed the file content into libexif while (bytesRead > 0) { exif_loader_write(exifLoader, reinterpret_cast<unsigned char *>(buffer), bytesRead); memset(buffer, 0, FILE_BUFFER_SIZE); bytesRead = pFile->read(buffer, FILE_BUFFER_SIZE); } ExifData * exifData = exif_loader_get_data(exifLoader); // exifData will be NULL if there is no EXIF data in the image if (exifData != NULL) { // For debugging, exif_data_dump writes all exif data to stdout //exif_data_dump(exifData); extractExifData(exifData, pFile); exif_data_unref(exifData); } // Free the loader exif_loader_unref(exifLoader); } catch (TskException& tskEx) { std::wstringstream msg; msg << L"ExifExtractModule - Error processing file id " << pFile->getId() << L": " << tskEx.what(); LOGERROR(msg.str()); return TskModule::FAIL; } catch (std::exception& ex) { std::wstringstream msg; msg << L"ExifExtractModule - Error processing file id " << pFile->getId() << L": " << ex.what(); LOGERROR(msg.str()); return TskModule::FAIL; } return TskModule::OK; }
Exif::~Exif() { exif_data_unref(m_data); }
void eom_exif_data_free (EomExifData *data) { exif_data_unref (data); }
exif_buffer *get_exif_buffer(void *params, void *gpsLocation) { ExifData *pEd; exif_buffer *sEb; ExifRational sR; struct timeval sTv; struct tm *sTime; char *TimeStr = NULL; int res; exif_params *par; if ( NULL == params) return NULL; par = (exif_params *) params; sEb = (exif_buffer *) malloc (sizeof (exif_buffer)); pEd = exif_data_new (); if(pEd == NULL) goto EXIT; exif_entry_set_string (pEd, EXIF_IFD_0, EXIF_TAG_MAKE, "Zoom"); exif_entry_set_string (pEd, EXIF_IFD_0, EXIF_TAG_MODEL, "SONY IU046"); exif_entry_set_short(pEd, EXIF_IFD_0, EXIF_TAG_IMAGE_LENGTH, par->width); exif_entry_set_short(pEd, EXIF_IFD_0, EXIF_TAG_IMAGE_WIDTH, par->height); switch( par->rotation ) { case 0: exif_entry_set_short(pEd, EXIF_IFD_0, EXIF_TAG_ORIENTATION, 1); break; case 90: exif_entry_set_short(pEd, EXIF_IFD_0, EXIF_TAG_ORIENTATION, 6); break; case 180: exif_entry_set_short(pEd, EXIF_IFD_0, EXIF_TAG_ORIENTATION, 3); break; case 270: exif_entry_set_short(pEd, EXIF_IFD_0, EXIF_TAG_ORIENTATION, 8); break; }; sR.numerator = 4*100+68; sR.denominator = 100; exif_entry_set_rational(pEd, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH, sR); exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_FLASH, 0); switch( par->metering_mode ) { case EXIF_CENTER: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_METERING_MODE, 1); break; case EXIF_AVERAGE: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_METERING_MODE, 2); break; }; switch( par->iso ) { case EXIF_ISO_AUTO: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS, 0); break; case EXIF_ISO_100: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS, 100); break; case EXIF_ISO_200: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS, 200); break; case EXIF_ISO_400: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS, 400); break; case EXIF_ISO_800: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS, 800); break; case EXIF_ISO_1000: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS, 1000); break; case EXIF_ISO_1200: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS, 1200); break; case EXIF_ISO_1600: exif_entry_set_short(pEd, EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS, 1600); break; }; sR.numerator = par->zoom*100; sR.denominator = 100; exif_entry_set_rational (pEd, EXIF_IFD_EXIF, EXIF_TAG_DIGITAL_ZOOM_RATIO, sR); if ( EXIF_WB_AUTO == par->wb ) exif_entry_set_short (pEd, EXIF_IFD_EXIF, EXIF_TAG_WHITE_BALANCE, 0); else exif_entry_set_short (pEd, EXIF_IFD_EXIF, EXIF_TAG_WHITE_BALANCE, 1); sR.numerator = par->exposure; sR.denominator = 1000000; exif_entry_set_rational (pEd, EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_TIME, sR); /* resolution */ sR.numerator = 72; sR.denominator = 1; exif_entry_set_rational (pEd, EXIF_IFD_0, EXIF_TAG_X_RESOLUTION, sR); exif_entry_set_rational (pEd, EXIF_IFD_0, EXIF_TAG_Y_RESOLUTION, sR); exif_entry_set_short (pEd, EXIF_IFD_0, EXIF_TAG_RESOLUTION_UNIT, 2); /* inches */ exif_entry_set_short (pEd, EXIF_IFD_0, EXIF_TAG_YCBCR_POSITIONING, 1); /* centered */ exif_entry_set_short(pEd, EXIF_IFD_0, EXIF_TAG_YCBCR_SUB_SAMPLING, 0); /* Exif version */ exif_entry_set_undefined (pEd, EXIF_IFD_EXIF, EXIF_TAG_EXIF_VERSION, NULL); /* flashpix version */ exif_entry_set_undefined(pEd, EXIF_IFD_EXIF, EXIF_TAG_FLASH_PIX_VERSION, NULL); /* file source */ exif_entry_set_undefined(pEd, EXIF_IFD_EXIF, EXIF_TAG_FILE_SOURCE, NULL); /* file name */ exif_entry_set_undefined(pEd, EXIF_IFD_EXIF, EXIF_TAG_DOCUMENT_NAME, NULL); /* scene type */ exif_entry_set_undefined(pEd, EXIF_IFD_EXIF, EXIF_TAG_SCENE_TYPE, NULL); /* Color Components */ exif_entry_set_undefined(pEd, EXIF_IFD_EXIF, EXIF_TAG_COMPONENTS_CONFIGURATION, NULL); /* Bits per sample */ exif_entry_set_undefined (pEd, EXIF_IFD_0, EXIF_TAG_BITS_PER_SAMPLE, NULL); /* Color space */ exif_entry_set_short (pEd, EXIF_IFD_EXIF, EXIF_TAG_COLOR_SPACE, 1); /* Interoperability index */ exif_entry_set_string(pEd, EXIF_IFD_INTEROPERABILITY, EXIF_TAG_INTEROPERABILITY_INDEX, "R98"); /* time */ /* this sould be last resort */ res = gettimeofday (&sTv, NULL); sTime = localtime (&sTv.tv_sec); if (res == 0 && sTime != NULL) { TimeStr = (char *) malloc(20);/* No data for secondary sensor */ if (TimeStr != NULL) { snprintf(TimeStr, 20, "%04d:%02d:%02d %02d:%02d:%02d", sTime->tm_year + 1900, sTime->tm_mon + 1, sTime->tm_mday, sTime->tm_hour, sTime->tm_min, sTime->tm_sec ); exif_entry_set_string (pEd, EXIF_IFD_0, EXIF_TAG_DATE_TIME, TimeStr); exif_entry_set_string (pEd, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_ORIGINAL, TimeStr); exif_entry_set_string (pEd, EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_DIGITIZED, TimeStr); snprintf(TimeStr, 20, "%06d", (int) sTv.tv_usec); exif_entry_set_string (pEd, EXIF_IFD_EXIF, EXIF_TAG_SUB_SEC_TIME, TimeStr); exif_entry_set_string (pEd, EXIF_IFD_EXIF, EXIF_TAG_SUB_SEC_TIME_ORIGINAL, TimeStr); exif_entry_set_string (pEd, EXIF_IFD_EXIF, EXIF_TAG_SUB_SEC_TIME_DIGITIZED, TimeStr); free (TimeStr); TimeStr = NULL; } else { printf ("%s():%d:!!!!!ERROR: malloc Failed.\n",__FUNCTION__,__LINE__); } } else { printf ("Error in time recognition. res: %d sTime: %p\n%s\n", res, sTime, strerror(errno)); } exif_entry_set_short (pEd, EXIF_IFD_1, EXIF_TAG_COMPRESSION, 6); /* JPEG */ exif_entry_set_long (pEd, EXIF_IFD_1, EXIF_TAG_JPEG_INTERCHANGE_FORMAT, 0xFFFFFFFF); exif_entry_set_long (pEd, EXIF_IFD_1, EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH, 0xFFFFFFFF); if ( NULL != gpsLocation ) { ExifRational r1, r2, r3; gps_data *gps = (gps_data *) gpsLocation; /* gps data */ r1.denominator = 1; r2.denominator = 1; r3.denominator = 1; r1.numerator = gps->longDeg; r2.numerator = gps->longMin; r3.numerator = gps->longSec; exif_entry_set_gps_coord(pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_LONGITUDE, r1, r2, r3); r1.numerator = gps->latDeg; r2.numerator = gps->latMin; r3.numerator = gps->latSec; exif_entry_set_gps_coord(pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_LATITUDE, r1, r2, r3); r1.numerator = gps->altitude; exif_entry_set_gps_altitude(pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_ALTITUDE, r1); sTime = localtime ((const time_t*) &gps->timestamp); if ( NULL != sTime ) { r1.numerator = sTime->tm_hour; r2.numerator = sTime->tm_min; r3.numerator = sTime->tm_sec; exif_entry_set_gps_coord(pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_TIME_STAMP, r1, r2, r3); } exif_entry_set_byte(pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_ALTITUDE_REF, (ExifByte) gps->altitudeRef); if( NULL != gps->latRef ) exif_entry_set_string (pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_LATITUDE_REF, gps->latRef); if( NULL != gps->longRef ) exif_entry_set_string (pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_LONGITUDE_REF, gps->longRef); if( NULL != gps->procMethod ) { //using strlen since i don't want the terminating null unsigned char* data = (unsigned char*)malloc(strlen(gps->procMethod) + sizeof(ExifAsciiPrefix)); exif_buffer buffer; if(data != NULL) { memcpy(data, ExifAsciiPrefix, sizeof(ExifAsciiPrefix)); memcpy(data+sizeof(ExifAsciiPrefix), gps->procMethod, strlen(gps->procMethod)); buffer.data = data; buffer.size = strlen(gps->procMethod)+sizeof(ExifAsciiPrefix); exif_entry_set_undefined (pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_PROCESSING_METHOD, &buffer); free(data); } } if( NULL != gps->mapdatum ) exif_entry_set_string (pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_MAP_DATUM, gps->mapdatum); if( strlen(gps->datestamp) == 10) exif_entry_set_string (pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_DATE_STAMP, gps->datestamp); if( NULL != gps->versionId ) exif_entry_set_gps_version(pEd, EXIF_IFD_GPS, (ExifTag) EXIF_TAG_GPS_VERSION_ID, gps->versionId[0], gps->versionId[1], gps->versionId[2], gps->versionId[3]); } /* copy data to our buffer */ exif_data_save_data (pEd, &sEb->data, &sEb->size); /* destroy exif structure */ exif_data_unref(pEd); return sEb; EXIT: if(sEb != NULL) free(sEb); return NULL; }
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); }
static void load_finished (CajaImagePropertiesPage *page) { GdkPixbufFormat *format; char *name, *desc; gtk_widget_destroy (page->details->loading_label); if (page->details->loader != NULL) { gdk_pixbuf_loader_close (page->details->loader, NULL); } if (page->details->got_size) { #ifdef HAVE_EXIF ExifData *exif_data; #endif /*HAVE_EXIF*/ format = gdk_pixbuf_loader_get_format (page->details->loader); name = gdk_pixbuf_format_get_name (format); desc = gdk_pixbuf_format_get_description (format); append_label_take_str (page->details->vbox, g_strdup_printf ("<b>%s</b> %s (%s)", _("Image Type:"), name, desc)); append_label_take_str (page->details->vbox, g_strdup_printf (ngettext ("<b>Width:</b> %d pixel", "<b>Width:</b> %d pixels", page->details->width), page->details->width)); append_label_take_str (page->details->vbox, g_strdup_printf (ngettext ("<b>Height:</b> %d pixel", "<b>Height:</b> %d pixels", page->details->height), page->details->height)); g_free (name); g_free (desc); #ifdef HAVE_EXIF exif_data = exif_loader_get_data (page->details->exifldr); append_exifdata_string (exif_data, page); exif_data_unref (exif_data); #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI append_xmpdata_string (page->details->xmp, page); #endif /*HAVE_EXEMPI*/ } else { append_label (page->details->vbox, _("Failed to load image information")); } if (page->details->loader != NULL) { g_object_unref (page->details->loader); page->details->loader = NULL; } #ifdef HAVE_EXIF if (page->details->exifldr != NULL) { exif_loader_unref (page->details->exifldr); page->details->exifldr = NULL; } #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI if (page->details->xmp != NULL) { xmp_free(page->details->xmp); page->details->xmp = NULL; } #endif /*HAVE_EXEMPI*/ }
void eog_exif_data_free (EogExifData *data) { exif_data_unref (data); }
static void pd_update_metadata_tab (EomPropertiesDialog *prop_dlg, EomImage *image) { EomPropertiesDialogPrivate *priv; GtkNotebook *notebook; #if HAVE_EXIF ExifData *exif_data; #endif #if HAVE_EXEMPI XmpPtr xmp_data; #endif g_return_if_fail (EOM_IS_PROPERTIES_DIALOG (prop_dlg)); priv = prop_dlg->priv; notebook = GTK_NOTEBOOK (priv->notebook); if (TRUE #if HAVE_EXIF && !eom_image_has_data (image, EOM_IMAGE_DATA_EXIF) #endif #if HAVE_EXEMPI && !eom_image_has_data (image, EOM_IMAGE_DATA_XMP) #endif ) { if (gtk_notebook_get_current_page (notebook) == EOM_PROPERTIES_DIALOG_PAGE_EXIF) { gtk_notebook_prev_page (notebook); } else if (gtk_notebook_get_current_page (notebook) == EOM_PROPERTIES_DIALOG_PAGE_DETAILS) { gtk_notebook_set_current_page (notebook, EOM_PROPERTIES_DIALOG_PAGE_GENERAL); } if (gtk_widget_get_visible (priv->exif_box)) { gtk_widget_hide_all (priv->exif_box); } if (gtk_widget_get_visible (priv->metadata_details_box)) { gtk_widget_hide_all (priv->metadata_details_box); } return; } else { if (!gtk_widget_get_visible (priv->exif_box)) gtk_widget_show_all (priv->exif_box); if (priv->netbook_mode && !gtk_widget_get_visible (priv->metadata_details_box)) { gtk_widget_show_all (priv->metadata_details_box); gtk_widget_hide_all (priv->exif_details_expander); } } #if HAVE_EXIF exif_data = (ExifData *) eom_image_get_exif_info (image); eom_exif_set_label (priv->exif_aperture_label, exif_data, EXIF_TAG_FNUMBER); eom_exif_set_label (priv->exif_exposure_label, exif_data, EXIF_TAG_EXPOSURE_TIME); eom_exif_set_focal_length_label (priv->exif_focal_label, exif_data); eom_exif_set_label (priv->exif_flash_label, exif_data, EXIF_TAG_FLASH); eom_exif_set_label (priv->exif_iso_label, exif_data, EXIF_TAG_ISO_SPEED_RATINGS); eom_exif_set_label (priv->exif_metering_label, exif_data, EXIF_TAG_METERING_MODE); eom_exif_set_label (priv->exif_model_label, exif_data, EXIF_TAG_MODEL); eom_exif_set_label (priv->exif_date_label, exif_data, EXIF_TAG_DATE_TIME_ORIGINAL); eom_exif_details_update (EOM_EXIF_DETAILS (priv->exif_details), exif_data); /* exif_data_unref can handle NULL-values */ exif_data_unref(exif_data); #endif #if HAVE_EXEMPI xmp_data = (XmpPtr) eom_image_get_xmp_info (image); if (xmp_data != NULL) { eom_xmp_set_label (xmp_data, NS_IPTC4XMP, "Location", priv->xmp_location_label); eom_xmp_set_label (xmp_data, NS_DC, "description", priv->xmp_description_label); eom_xmp_set_label (xmp_data, NS_DC, "subject", priv->xmp_keywords_label); eom_xmp_set_label (xmp_data, NS_DC, "creator", priv->xmp_creator_label); eom_xmp_set_label (xmp_data, NS_DC, "rights", priv->xmp_rights_label); eom_exif_details_xmp_update (EOM_EXIF_DETAILS (priv->exif_details), xmp_data); xmp_free (xmp_data); } else { /* Image has no XMP data */ /* Clear the labels so they won't display foreign data.*/ gtk_label_set_text (GTK_LABEL (priv->xmp_location_label), NULL); gtk_label_set_text (GTK_LABEL (priv->xmp_description_label), NULL); gtk_label_set_text (GTK_LABEL (priv->xmp_keywords_label), NULL); gtk_label_set_text (GTK_LABEL (priv->xmp_creator_label), NULL); gtk_label_set_text (GTK_LABEL (priv->xmp_rights_label), NULL); } #endif }