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;
}
void imFileFormatJPEG::iWriteExifAttrib(imAttribTable* attrib_table)
{
ExifData* exif = exif_data_new();
ExifByteOrder byte_order;
if (imBinCPUByteOrder() == IM_LITTLEENDIAN)
byte_order = EXIF_BYTE_ORDER_INTEL;
else
byte_order = EXIF_BYTE_ORDER_MOTOROLA;
exif_data_set_byte_order(exif, byte_order);
attrib_table->ForEach(exif, (imAttribTableCallback)iExifWriteTag);
imbyte* data = NULL;
unsigned int data_size = 0;
exif_data_save_data(exif, &data, &data_size);
if (data)
{
jpeg_write_marker(&this->cinfo, JPEG_APP0+1, data, data_size);
free(data);
}
exif_data_free(exif);
}
ExifData* load_file (file_t* file)
{
ExifData* ed = exif_data_new ();
exif_data_unset_option (ed, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
exif_data_set_option (ed, EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS);
exif_data_load_data (ed, file->addr, file->st.st_size);
return ed;
}
ExifData *
exif_data_new_from_data (const unsigned char *data, unsigned int size)
{
ExifData *edata;
edata = exif_data_new ();
exif_data_load_data (edata, data, size);
return (edata);
}
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;
}
/* Like exif_data_new_from_data(), but don't default missing fields.
*
* If we do exif_data_new_from_data(), then missing fields are set to
* their default value and we won't know about it.
*/
static ExifData *
vips_exif_load_data_without_fix( void *data, int length )
{
ExifData *ed;
if( !(ed = exif_data_new()) ) {
vips_error( "exif", "%s", _( "unable to init exif" ) );
return( NULL );
}
exif_data_unset_option( ed, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION );
exif_data_load_data( ed, data, length );
return( ed );
}
static int
write_exif( Write *write )
{
#ifdef HAVE_EXIF
unsigned char *data;
size_t data_length;
unsigned int idl;
ExifData *ed;
/* Either parse from the embedded EXIF, or if there's none, make
* some fresh EXIF we can write the resolution to.
*/
if( vips_image_get_typeof( write->in, VIPS_META_EXIF_NAME ) ) {
if( vips_image_get_blob( write->in, VIPS_META_EXIF_NAME,
(void *) &data, &data_length ) )
return( -1 );
if( !(ed = exif_data_new_from_data( data, data_length )) )
return( -1 );
}
else {
ed = exif_data_new();
exif_data_set_option( ed,
EXIF_DATA_OPTION_FOLLOW_SPECIFICATION );
exif_data_set_data_type( ed, EXIF_DATA_TYPE_COMPRESSED );
exif_data_set_byte_order( ed, EXIF_BYTE_ORDER_INTEL );
/* Create the mandatory EXIF fields with default data.
*/
exif_data_fix( ed );
}
/* Update EXIF tags from the image metadata.
*/
vips_exif_update( ed, write->in );
/* Update EXIF resolution from the vips image header.
*/
if( vips__set_exif_resolution( ed, write->in ) ) {
exif_data_free( ed );
return( -1 );
}
/* Update EXIF image dimensions from the vips image header.
*/
if( set_exif_dimensions( ed, write->in ) ) {
exif_data_free( ed );
return( -1 );
}
/* Update EXIF orientation from the vips image header.
*/
if( set_exif_orientation( ed, write->in ) ) {
exif_data_free( ed );
return( -1 );
}
/* Reserialise and write. exif_data_save_data() returns an int for some
* reason.
*/
exif_data_save_data( ed, &data, &idl );
if( !idl ) {
vips_error( "VipsJpeg", "%s", _( "error saving EXIF" ) );
exif_data_free( ed );
return( -1 );
}
data_length = idl;
#ifdef DEBUG
printf( "write_exif: attaching %zd bytes of EXIF\n", data_length );
#endif /*DEBUG*/
exif_data_free( ed );
jpeg_write_marker( &write->cinfo, JPEG_APP0 + 1, data, data_length );
free( data );
#else /*!HAVE_EXIF*/
/* No libexif ... just copy the embedded EXIF over.
*/
if( write_blob( write, VIPS_META_EXIF_NAME, JPEG_APP0 + 1 ) )
return( -1 );
#endif /*!HAVE_EXIF*/
return( 0 );
}
ExifData* createExifData(const CameraParameters& params) {
ExifData* exifData = exif_data_new();
exif_data_set_option(exifData, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
exif_data_set_data_type(exifData, EXIF_DATA_TYPE_COMPRESSED);
exif_data_set_byte_order(exifData, EXIF_BYTE_ORDER_INTEL);
// Create mandatory exif fields and set their default values
exif_data_fix(exifData);
float triplet[3];
float floatValue = 0.0f;
const char* stringValue;
int64_t degrees;
// Datetime, creating and initializing a datetime tag will automatically
// set the current date and time in the tag so just do that.
createEntry(exifData, EXIF_IFD_0, EXIF_TAG_DATE_TIME);
// Make and model
createEntry(exifData, EXIF_IFD_0, EXIF_TAG_MAKE, "Emulator-Goldfish");
createEntry(exifData, EXIF_IFD_0, EXIF_TAG_MODEL, "Emulator-Goldfish");
// Picture size
int width = -1, height = -1;
params.getPictureSize(&width, &height);
if (width >= 0 && height >= 0) {
createEntry(exifData, EXIF_IFD_EXIF,
EXIF_TAG_PIXEL_X_DIMENSION, width);
createEntry(exifData, EXIF_IFD_EXIF,
EXIF_TAG_PIXEL_Y_DIMENSION, height);
}
// Orientation
if (getCameraParam(params,
CameraParameters::KEY_ROTATION,
°rees)) {
// Exif orientation values, please refer to
// http://www.exif.org/Exif2-2.PDF, Section 4.6.4-A-Orientation
// Or these websites:
// http://sylvana.net/jpegcrop/exif_orientation.html
// http://www.impulseadventure.com/photo/exif-orientation.html
enum {
EXIF_ROTATE_CAMERA_CW0 = 1,
EXIF_ROTATE_CAMERA_CW90 = 6,
EXIF_ROTATE_CAMERA_CW180 = 3,
EXIF_ROTATE_CAMERA_CW270 = 8,
};
uint16_t exifOrien = 1;
switch (degrees) {
case 0:
exifOrien = EXIF_ROTATE_CAMERA_CW0;
break;
case 90:
exifOrien = EXIF_ROTATE_CAMERA_CW90;
break;
case 180:
exifOrien = EXIF_ROTATE_CAMERA_CW180;
break;
case 270:
exifOrien = EXIF_ROTATE_CAMERA_CW270;
break;
}
createEntry(exifData, EXIF_IFD_0, EXIF_TAG_ORIENTATION, exifOrien);
}
// Focal length
if (getCameraParam(params,
CameraParameters::KEY_FOCAL_LENGTH,
&floatValue)) {
createEntry(exifData, EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH, floatValue);
}
// GPS latitude and reference, reference indicates sign, store unsigned
if (getCameraParam(params,
CameraParameters::KEY_GPS_LATITUDE,
&floatValue)) {
convertGpsCoordinate(floatValue, &triplet);
createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE, triplet);
const char* ref = floatValue < 0.0f ? "S" : "N";
createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF, ref);
}
// GPS longitude and reference, reference indicates sign, store unsigned
if (getCameraParam(params,
CameraParameters::KEY_GPS_LONGITUDE,
&floatValue)) {
convertGpsCoordinate(floatValue, &triplet);
createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE, triplet);
const char* ref = floatValue < 0.0f ? "W" : "E";
createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF, ref);
}
// GPS altitude and reference, reference indicates sign, store unsigned
if (getCameraParam(params,
CameraParameters::KEY_GPS_ALTITUDE,
&floatValue)) {
createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE,
static_cast<float>(fabs(floatValue)));
// 1 indicated below sea level, 0 indicates above sea level
uint8_t ref = floatValue < 0.0f ? 1 : 0;
createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_ALTITUDE_REF, ref);
}
// GPS timestamp and datestamp
int64_t timestamp = 0;
if (getCameraParam(params,
CameraParameters::KEY_GPS_TIMESTAMP,
×tamp)) {
std::string date;
if (convertTimestampToTimeAndDate(timestamp, &triplet, &date)) {
createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_TIME_STAMP,
triplet, 1.0f);
createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_DATE_STAMP,
date.c_str());
}
}
// GPS processing method
if (getCameraParam(params,
CameraParameters::KEY_GPS_PROCESSING_METHOD,
&stringValue)) {
std::vector<unsigned char> data;
// Because this is a tag with an undefined format it has to be prefixed
// with the encoding type. Insert an ASCII prefix first, then the
// actual string. Undefined tags do not have to be null terminated.
data.insert(data.end(),
std::begin(kAsciiPrefix),
std::end(kAsciiPrefix));
data.insert(data.end(), stringValue, stringValue + strlen(stringValue));
createEntry(exifData, EXIF_IFD_GPS, EXIF_TAG_GPS_PROCESSING_METHOD,
&data[0], data.size());
}
return exifData;
}
/* Examine the metadata tags on the image and update the EXIF block.
*/
int
vips__exif_update( VipsImage *image )
{
unsigned char *data;
size_t length;
unsigned int idl;
ExifData *ed;
/* Either parse from the embedded EXIF, or if there's none, make
* some fresh EXIF we can write the resolution to.
*/
if( vips_image_get_typeof( image, VIPS_META_EXIF_NAME ) ) {
if( vips_image_get_blob( image, VIPS_META_EXIF_NAME,
(void *) &data, &length ) )
return( -1 );
if( !(ed = exif_data_new_from_data( data, length )) )
return( -1 );
}
else {
ed = exif_data_new();
exif_data_set_option( ed,
EXIF_DATA_OPTION_FOLLOW_SPECIFICATION );
exif_data_set_data_type( ed, EXIF_DATA_TYPE_COMPRESSED );
exif_data_set_byte_order( ed, EXIF_BYTE_ORDER_INTEL );
/* Create the mandatory EXIF fields with default data.
*/
exif_data_fix( ed );
}
/* Update EXIF tags from the image metadata.
*/
vips_exif_update( ed, image );
/* Update EXIF resolution from the vips image header.
*/
if( vips_exif_resolution_from_image( ed, image ) ) {
exif_data_free( ed );
return( -1 );
}
/* Update EXIF image dimensions from the vips image header.
*/
if( vips_exif_set_dimensions( ed, image ) ) {
exif_data_free( ed );
return( -1 );
}
/* Update EXIF orientation from the vips image header.
*/
if( vips_exif_set_orientation( ed, image ) ) {
exif_data_free( ed );
return( -1 );
}
/* Update the thumbnail.
*/
if( vips_exif_set_thumbnail( ed, image ) ) {
exif_data_free( ed );
return( -1 );
}
/* Reserialise and write. exif_data_save_data() returns an int for some
* reason.
*/
exif_data_save_data( ed, &data, &idl );
if( !idl ) {
vips_error( "exif", "%s", _( "error saving EXIF" ) );
exif_data_free( ed );
return( -1 );
}
length = idl;
#ifdef DEBUG
printf( "vips__exif_update: generated %zd bytes of EXIF\n", length );
#endif /*DEBUG*/
vips_image_set_blob( image, VIPS_META_EXIF_NAME,
(VipsCallbackFn) vips_free, data, length );
exif_data_free( ed );
return( 0 );
}
gint32
load_image (const gchar *filename,
GimpRunMode runmode,
gboolean preview,
GError **error)
{
GimpPixelRgn pixel_rgn;
GimpDrawable *drawable;
gint32 volatile image_ID;
gint32 layer_ID;
struct jpeg_decompress_struct cinfo;
struct my_error_mgr jerr;
jpeg_saved_marker_ptr marker;
FILE *infile;
guchar *buf;
guchar **rowbuf;
gint image_type;
gint layer_type;
gint tile_height;
gint scanlines;
gint i, start, end;
#ifdef HAVE_LIBEXIF
gint orientation = 0;
#endif
#ifdef HAVE_LCMS
cmsHTRANSFORM cmyk_transform = NULL;
#else
gpointer cmyk_transform = NULL;
#endif
/* We set up the normal JPEG error routines. */
cinfo.err = jpeg_std_error (&jerr.pub);
jerr.pub.error_exit = my_error_exit;
if (!preview)
{
jerr.pub.output_message = my_output_message;
}
if ((infile = g_fopen (filename, "rb")) == NULL)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return -1;
}
if (!preview)
gimp_progress_init_printf (_("Opening '%s'"),
gimp_filename_to_utf8 (filename));
image_ID = -1;
/* Establish the setjmp return context for my_error_exit to use. */
if (setjmp (jerr.setjmp_buffer))
{
/* If we get here, the JPEG code has signaled an error.
* We need to clean up the JPEG object, close the input file, and return.
*/
jpeg_destroy_decompress (&cinfo);
if (infile)
fclose (infile);
if (image_ID != -1 && !preview)
gimp_image_delete (image_ID);
if (preview)
destroy_preview ();
return -1;
}
/* Now we can initialize the JPEG decompression object. */
jpeg_create_decompress (&cinfo);
/* Step 2: specify data source (eg, a file) */
jpeg_stdio_src (&cinfo, infile);
if (! preview)
{
/* - step 2.1: tell the lib to save the comments */
jpeg_save_markers (&cinfo, JPEG_COM, 0xffff);
/* - step 2.2: tell the lib to save APP1 data (EXIF or XMP) */
jpeg_save_markers (&cinfo, JPEG_APP0 + 1, 0xffff);
/* - step 2.3: tell the lib to save APP2 data (ICC profiles) */
jpeg_save_markers (&cinfo, JPEG_APP0 + 2, 0xffff);
}
/* Step 3: read file parameters with jpeg_read_header() */
jpeg_read_header (&cinfo, TRUE);
/* We can ignore the return value from jpeg_read_header since
* (a) suspension is not possible with the stdio data source, and
* (b) we passed TRUE to reject a tables-only JPEG file as an error.
* See libjpeg.doc for more info.
*/
/* Step 4: set parameters for decompression */
/* In this example, we don't need to change any of the defaults set by
* jpeg_read_header(), so we do nothing here.
*/
/* Step 5: Start decompressor */
jpeg_start_decompress (&cinfo);
/* We may need to do some setup of our own at this point before reading
* the data. After jpeg_start_decompress() we have the correct scaled
* output image dimensions available, as well as the output colormap
* if we asked for color quantization.
*/
/* temporary buffer */
tile_height = gimp_tile_height ();
buf = g_new (guchar,
tile_height * cinfo.output_width * cinfo.output_components);
rowbuf = g_new (guchar *, tile_height);
for (i = 0; i < tile_height; i++)
rowbuf[i] = buf + cinfo.output_width * cinfo.output_components * i;
switch (cinfo.output_components)
{
case 1:
image_type = GIMP_GRAY;
layer_type = GIMP_GRAY_IMAGE;
break;
case 3:
image_type = GIMP_RGB;
layer_type = GIMP_RGB_IMAGE;
break;
case 4:
if (cinfo.out_color_space == JCS_CMYK)
{
image_type = GIMP_RGB;
layer_type = GIMP_RGB_IMAGE;
break;
}
/*fallthrough*/
default:
g_message ("Don't know how to load JPEG images "
"with %d color channels, using colorspace %d (%d).",
cinfo.output_components, cinfo.out_color_space,
cinfo.jpeg_color_space);
return -1;
break;
}
if (preview)
{
image_ID = preview_image_ID;
}
else
{
image_ID = gimp_image_new (cinfo.output_width, cinfo.output_height,
image_type);
gimp_image_undo_disable (image_ID);
gimp_image_set_filename (image_ID, filename);
}
if (preview)
{
preview_layer_ID = gimp_layer_new (preview_image_ID, _("JPEG preview"),
cinfo.output_width,
cinfo.output_height,
layer_type, 100, GIMP_NORMAL_MODE);
layer_ID = preview_layer_ID;
}
else
{
layer_ID = gimp_layer_new (image_ID, _("Background"),
cinfo.output_width,
cinfo.output_height,
layer_type, 100, GIMP_NORMAL_MODE);
}
drawable_global = drawable = gimp_drawable_get (layer_ID);
gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0,
drawable->width, drawable->height, TRUE, FALSE);
if (! preview)
{
GString *comment_buffer = NULL;
guint8 *profile = NULL;
guint profile_size = 0;
#ifdef HAVE_LIBEXIF
ExifData *exif_data = NULL;
#endif
/* Step 5.0: save the original JPEG settings in a parasite */
jpeg_detect_original_settings (&cinfo, image_ID);
/* Step 5.1: check for comments, or EXIF metadata in APP1 markers */
for (marker = cinfo.marker_list; marker; marker = marker->next)
{
const gchar *data = (const gchar *) marker->data;
gsize len = marker->data_length;
if (marker->marker == JPEG_COM)
{
#ifdef GIMP_UNSTABLE
g_print ("jpeg-load: found image comment (%d bytes)\n",
marker->data_length);
#endif
if (! comment_buffer)
{
comment_buffer = g_string_new_len (data, len);
}
else
{
/* concatenate multiple comments, separate them with LF */
g_string_append_c (comment_buffer, '\n');
g_string_append_len (comment_buffer, data, len);
}
}
else if ((marker->marker == JPEG_APP0 + 1)
&& (len > sizeof (JPEG_APP_HEADER_EXIF) + 8)
&& ! strcmp (JPEG_APP_HEADER_EXIF, data))
{
#ifdef GIMP_UNSTABLE
g_print ("jpeg-load: found EXIF block (%d bytes)\n",
(gint) (len - sizeof (JPEG_APP_HEADER_EXIF)));
#endif
#ifdef HAVE_LIBEXIF
if (! exif_data)
exif_data = exif_data_new ();
/* if there are multiple blocks, their data will be merged */
exif_data_load_data (exif_data, (unsigned char *) data, len);
#endif
}
}
#ifdef HAVE_LIBEXIF
if (!jpeg_load_exif_resolution (image_ID, exif_data))
#endif
jpeg_load_resolution (image_ID, &cinfo);
/* if we found any comments, then make a parasite for them */
if (comment_buffer && comment_buffer->len)
{
GimpParasite *parasite;
jpeg_load_sanitize_comment (comment_buffer->str);
parasite = gimp_parasite_new ("gimp-comment",
GIMP_PARASITE_PERSISTENT,
strlen (comment_buffer->str) + 1,
comment_buffer->str);
gimp_image_attach_parasite (image_ID, parasite);
gimp_parasite_free (parasite);
g_string_free (comment_buffer, TRUE);
}
#ifdef HAVE_LIBEXIF
/* if we found any EXIF block, then attach the metadata to the image */
if (exif_data)
{
gimp_metadata_store_exif (image_ID, exif_data);
orientation = jpeg_exif_get_orientation (exif_data);
exif_data_unref (exif_data);
exif_data = NULL;
}
#endif
/* Step 5.2: check for XMP metadata in APP1 markers (after EXIF) */
for (marker = cinfo.marker_list; marker; marker = marker->next)
{
const gchar *data = (const gchar *) marker->data;
gsize len = marker->data_length;
if ((marker->marker == JPEG_APP0 + 1)
&& (len > sizeof (JPEG_APP_HEADER_XMP) + 20)
&& ! strcmp (JPEG_APP_HEADER_XMP, data))
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *xmp_packet;
#ifdef GIMP_UNSTABLE
g_print ("jpeg-load: found XMP packet (%d bytes)\n",
(gint) (len - sizeof (JPEG_APP_HEADER_XMP)));
#endif
xmp_packet = g_strndup (data + sizeof (JPEG_APP_HEADER_XMP),
len - sizeof (JPEG_APP_HEADER_XMP));
/* FIXME: running this through the PDB is not very efficient */
return_vals = gimp_run_procedure ("plug-in-metadata-decode-xmp",
&nreturn_vals,
GIMP_PDB_IMAGE, image_ID,
GIMP_PDB_STRING, xmp_packet,
GIMP_PDB_END);
if (return_vals[0].data.d_status != GIMP_PDB_SUCCESS)
{
g_warning ("JPEG - unable to decode XMP metadata packet");
}
gimp_destroy_params (return_vals, nreturn_vals);
g_free (xmp_packet);
}
}
/* Step 5.3: check for an embedded ICC profile in APP2 markers */
jpeg_icc_read_profile (&cinfo, &profile, &profile_size);
if (cinfo.out_color_space == JCS_CMYK)
{
cmyk_transform = jpeg_load_cmyk_transform (profile, profile_size);
}
else if (profile) /* don't attach the profile if we are transforming */
{
GimpParasite *parasite;
parasite = gimp_parasite_new ("icc-profile",
GIMP_PARASITE_PERSISTENT |
GIMP_PARASITE_UNDOABLE,
profile_size, profile);
gimp_image_attach_parasite (image_ID, parasite);
gimp_parasite_free (parasite);
}
g_free (profile);
/* Do not attach the "jpeg-save-options" parasite to the image
* because this conflicts with the global defaults (bug #75398).
*/
}
/* Step 6: while (scan lines remain to be read) */
/* jpeg_read_scanlines(...); */
/* Here we use the library's state variable cinfo.output_scanline as the
* loop counter, so that we don't have to keep track ourselves.
*/
while (cinfo.output_scanline < cinfo.output_height)
{
start = cinfo.output_scanline;
end = cinfo.output_scanline + tile_height;
end = MIN (end, cinfo.output_height);
scanlines = end - start;
for (i = 0; i < scanlines; i++)
jpeg_read_scanlines (&cinfo, (JSAMPARRAY) &rowbuf[i], 1);
if (cinfo.out_color_space == JCS_CMYK)
jpeg_load_cmyk_to_rgb (buf, drawable->width * scanlines,
cmyk_transform);
gimp_pixel_rgn_set_rect (&pixel_rgn, buf,
0, start, drawable->width, scanlines);
if (! preview && (cinfo.output_scanline % 32) == 0)
gimp_progress_update ((gdouble) cinfo.output_scanline /
(gdouble) cinfo.output_height);
}
/* Step 7: Finish decompression */
jpeg_finish_decompress (&cinfo);
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
#ifdef HAVE_LCMS
if (cmyk_transform)
cmsDeleteTransform (cmyk_transform);
#endif
/* Step 8: Release JPEG decompression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_decompress (&cinfo);
/* free up the temporary buffers */
g_free (rowbuf);
g_free (buf);
/* After finish_decompress, we can close the input file.
* Here we postpone it until after no more JPEG errors are possible,
* so as to simplify the setjmp error logic above. (Actually, I don't
* think that jpeg_destroy can do an error exit, but why assume anything...)
*/
fclose (infile);
/* At this point you may want to check to see whether any corrupt-data
* warnings occurred (test whether jerr.num_warnings is nonzero).
*/
/* Detach from the drawable and add it to the image.
*/
if (! preview)
{
gimp_progress_update (1.0);
gimp_drawable_detach (drawable);
}
gimp_image_insert_layer (image_ID, layer_ID, -1, 0);
#ifdef HAVE_LIBEXIF
jpeg_exif_rotate_query (image_ID, orientation);
#endif
return image_ID;
}
/**
* a_geotag_write_exif_gps:
* @filename: The image file to save information in
* @coord: The location
* @alt: The elevation
* @direction: The image direction (if NAN then these direction fields are not written)
* @direction_ref: The image direction value type
*
* 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,
gdouble direction, VikWaypointImageDirectionRef direction_ref,
gboolean no_change_mtime )
{
gint result = 0; // OK so far...
// Save mtime for later use
struct stat stat_save;
if ( no_change_mtime )
if ( stat ( filename, &stat_save ) != 0 )
g_warning ( "%s couldn't read: %s", __FUNCTION__, filename );
#ifdef HAVE_LIBGEXIV2
GExiv2Metadata *gemd = gexiv2_metadata_new ();
if ( gexiv2_metadata_open_path ( gemd, filename, NULL ) ) {
struct LatLon ll;
vik_coord_to_latlon ( &coord, &ll );
if ( ! gexiv2_metadata_set_gps_info ( gemd, ll.lon, ll.lat, alt ) ) {
result = 1; // Failed
}
else {
if ( !isnan(direction) ) {
gint nom = (gint)round(direction * 10.0);
gboolean set_d = gexiv2_metadata_set_exif_tag_rational ( gemd, EXIF_GPS_IMGDIR, nom, 10 );
if ( !set_d ) result = 1; // Failed
gboolean set_r = gexiv2_metadata_set_tag_string ( gemd, EXIF_GPS_IMGDIR_REF, direction_ref == WP_IMAGE_DIRECTION_REF_TRUE ? "T" : "M" );
if ( !set_r ) result = 1; // Failed
}
// Still OK to save - no fails yet
if ( result == 0 ) {
GError *error = NULL;
if ( ! gexiv2_metadata_save_file ( gemd, filename, &error ) ) {
result = 2;
g_warning ( "Write EXIF failure:%s" , error->message );
g_error_free ( error );
}
}
}
}
metadata_free ( gemd );
#else
#ifdef HAVE_LIBEXIF
/*
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;
}
exif_data_free ( ed );
#endif
#endif
if ( no_change_mtime ) {
// Restore mtime, using the saved value
struct stat stat_tmp;
struct utimbuf utb;
(void)stat ( filename, &stat_tmp );
utb.actime = stat_tmp.st_atime;
utb.modtime = stat_save.st_mtime;
// Not security critical, thus potential Time of Check Time of Use race condition is not bad
// coverity[toctou]
if ( g_utime ( filename, &utb ) != 0 )
g_warning ( "%s couldn't set time on: %s", __FUNCTION__, filename );
}
return result;
}
void
jpeg_data_load_data (JPEGData *data, const unsigned char *d,
unsigned int size)
{
unsigned int i, o, len;
JPEGSection *s;
JPEGMarker marker;
if (!data) return;
if (!d) return;
for (o = 0; o < size;) {
/*
* JPEG sections start with 0xff. The first byte that is
* not 0xff is a marker (hopefully).
*/
for (i = 0; i < MIN(7, size - o); i++)
if (d[o + i] != 0xff)
break;
if ((i >= size - o) || !JPEG_IS_MARKER (d[o + i])) {
exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "jpeg-data",
_("Data does not follow JPEG specification."));
return;
}
marker = d[o + i];
/* Append this section */
jpeg_data_append_section (data);
if (!data->count) return;
s = &data->sections[data->count - 1];
s->marker = marker;
o += i + 1;
switch (s->marker) {
case JPEG_MARKER_SOI:
case JPEG_MARKER_EOI:
break;
default:
/* Read the length of the section */
if (2 > size - o) { o = size; break; }
len = ((d[o] << 8) | d[o + 1]) - 2;
if (len > size) { o = size; break; }
o += 2;
if (len > size - o) { o = size; break; }
switch (s->marker) {
case JPEG_MARKER_APP1:
/* Changed to add the EXIF_LOG feature.
2012.04.05 - Samsung Electronics */
/*s->content.app1 = exif_data_new_from_data (
d + o - 4, len + 4); */
s->content.app1 = exif_data_new();
exif_data_log(s->content.app1, data->priv->log);
exif_data_load_data (s->content.app1, d + o - 4, len + 4);
break;
default:
s->content.generic.data =
malloc (sizeof (char) * len);
if (!s->content.generic.data) {
EXIF_LOG_NO_MEMORY (data->priv->log, "jpeg-data", sizeof (char) * len);
return;
}
s->content.generic.size = len;
memcpy (s->content.generic.data, &d[o], len);
/* In case of SOS, image data will follow. */
if (s->marker == JPEG_MARKER_SOS) {
data->size = size - o - len;
if (data->size >= 2) {
/* -2 means 'take all but the last 2 bytes which are
hoped to be JPEG_MARKER_EOI */
data->size -= 2;
if (d[o + len + data->size] != 0xFF) {
/* A truncated file (i.e. w/o JPEG_MARKER_EOI at the end).
Instead of trying to use the last two bytes as marker,
touching memory beyond allocated memory and posssibly saving
back screwed file, we rather take the rest of the file. */
data->size += 2;
}
}
data->data = malloc (
sizeof (char) * data->size);
if (!data->data) {
EXIF_LOG_NO_MEMORY (data->priv->log, "jpeg-data", sizeof (char) * data->size);
data->size = 0;
return;
}
memcpy (data->data, d + o + len,
data->size);
o += data->size;
}
break;
}
o += len;
break;
}
}
}
static int Lnew (lua_State *L) { /** new() */
pushdata(L, exif_data_new());
return 1;
}
int createEXIF(dc1394featureset_t *xFeatures, ExifData ** pParentEd)
{
ExifEntry *pE;
ExifData * pEd;
int i = !xFeatures->feature[DC1394_FEATURE_WHITE_BALANCE - DC1394_FEATURE_MIN].auto_active;
ExifSRational xR = {xFeatures->feature[DC1394_FEATURE_BRIGHTNESS - DC1394_FEATURE_MIN].value, xFeatures->feature[DC1394_FEATURE_BRIGHTNESS - DC1394_FEATURE_MIN].max};;
printf ("Creating EXIF data...\n");
pEd = exif_data_new ();
printf ("Adding a Make reference\n");
pE = exif_entry_new ();
exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
exif_entry_initialize (pE, EXIF_TAG_MAKE);
pE->data="AVT";
exif_entry_unref (pE);
printf ("Adding a Model reference\n");
pE = exif_entry_new ();
exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
exif_entry_initialize (pE, EXIF_TAG_MODEL);
pE->data="510c";
exif_entry_unref (pE);
printf ("Adding a Tag to reference # samples per pixel\n");
pE = exif_entry_new ();
exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
exif_entry_initialize (pE, EXIF_TAG_SAMPLES_PER_PIXEL);
exif_entry_unref (pE);
printf ("Adding a White Balance Reference\n");
pE = exif_entry_new ();
exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
exif_entry_initialize (pE, EXIF_TAG_WHITE_BALANCE);
exif_set_short(pE->data, exif_data_get_byte_order (pEd), i);
exif_entry_unref (pE);
printf ("Adding a Sharpness Reference\n");
pE = exif_entry_new ();
exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
exif_entry_initialize (pE, EXIF_TAG_SHARPNESS);
exif_set_short(pE->data, exif_data_get_byte_order (pEd), 0);
exif_entry_unref (pE);
printf ("Adding a Brightness reference\n");
pE = exif_entry_new ();
exif_content_add_entry (pEd->ifd[EXIF_IFD_0], pE);
exif_entry_initialize (pE, EXIF_TAG_BRIGHTNESS_VALUE);
exif_set_srational (pE->data, exif_data_get_byte_order (pEd), xR);
*pParentEd = pEd;
printf("Done!\n");
return 0;
}
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;
}
/**
* 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;
}
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
write_exif( Write *write )
{
unsigned char *data;
size_t data_length;
unsigned int idl;
#ifdef HAVE_EXIF
ExifData *ed;
/* Either parse from the embedded EXIF, or if there's none, make
* some fresh EXIF we can write the resolution to.
*/
if( im_header_get_typeof( write->in, IM_META_EXIF_NAME ) ) {
if( im_meta_get_blob( write->in, IM_META_EXIF_NAME,
(void *) &data, &data_length ) )
return( -1 );
if( !(ed = exif_data_new_from_data( data, data_length )) )
return( -1 );
}
else
ed = exif_data_new();
/* Update EXIF resolution from VIPS.
*/
if( set_exif_resolution( ed, write->in ) ) {
exif_data_free( ed );
return( -1 );
}
/* Reserialise and write. exif_data_save_data() returns an int for some
* reason.
*/
exif_data_save_data( ed, &data, &idl );
if( !idl ) {
im_error( "im_jpeg2vips", "%s", _( "error saving EXIF" ) );
exif_data_free( ed );
return( -1 );
}
data_length = idl;
#ifdef DEBUG
printf( "im_vips2jpeg: attaching %zd bytes of EXIF\n", data_length );
#endif /*DEBUG*/
exif_data_free( ed );
jpeg_write_marker( &write->cinfo, JPEG_APP0 + 1, data, data_length );
free( data );
#else /*!HAVE_EXIF*/
/* No libexif ... just copy the embedded EXIF over.
*/
if( im_header_get_typeof( write->in, IM_META_EXIF_NAME ) ) {
if( im_meta_get_blob( write->in, IM_META_EXIF_NAME,
(void *) &data, &data_length ) )
return( -1 );
#ifdef DEBUG
printf( "im_vips2jpeg: attaching %d bytes of EXIF\n",
data_length );
#endif /*DEBUG*/
jpeg_write_marker( &write->cinfo, JPEG_APP0 + 1,
data, data_length );
}
#endif /*!HAVE_EXIF*/
return( 0 );
}