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
}